Àrea LSI, Departament IMAE, Universitat de Girona
METODOLOGIA I TECNOLOGIA DE LA
PROGRAMACIÓ 2
(GEINF, GDDV i GEB)
Anton Bardera, Miquel Feixas, Mateu Sbert,
Joan Surrell, Mateu Villaret, Pau Xiberta
Curs 2018-19
1
Prepara tus exámenes
Prepara tus exámenes y mejora tus resultados gracias a la gran cantidad de recursos disponibles en Docsity
Consigue puntos base para descargar
Gana puntos ayudando a otros estudiantes o consíguelos activando un Plan Premium
Orientación Universidad
Prepara tus exámenes
Prepara tus exámenes y mejora tus resultados gracias a la gran cantidad de recursos disponibles en Docsity
Busca documentos
Prepara tus exámenes con los documentos que comparten otros estudiantes como tú en Docsity
Busca tu universidad
Encuentra los documentos específicos para los exámenes de tu universidad
Video Cursos
Estudia con lecciones y exámenes resueltos basados en los programas académicos de las mejores universidades
Quiz
Responde a preguntas de exámenes reales y pon a prueba tu preparación
Consigue puntos base para descargar
Gana puntos ayudando a otros estudiantes o consíguelos activando un Plan Premium
Comunidad
Pregúntale a la comunidad
Pide ayuda a la comunidad y resuelve tus dudas de estudio
Ebooks gratuitos
¡Nuestros e-books salva-estudiantes!
Descarga nuestras guías gratuitas sobre técnicas de estudio, métodos para controlar la ansiedad y consejos para la tesis preparadas por los tutores de Docsity
Aquest power point conté part de la segona part de l'assignatura de porgramació
Tipo: Apuntes
2019/2020
1 / 45
Esta página no es visible en la vista previa
¡No te pierdas las partes importantes!
Documentos relacionados
Vista previa parcial del texto
¡Descarga Power point explicatiu c++ y más Apuntes en PDF de Programación C solo en Docsity!
Àrea LSI, Departament IMAE, Universitat de Girona
METODOLOGIA I TECNOLOGIA DE LA
PROGRAMACIÓ 2
(GEINF, GDDV i GEB)
Anton Bardera, Miquel Feixas, Mateu Sbert,
Joan Surrell, Mateu Villaret, Pau Xiberta
Curs 2018 - 19
Sessions de laboratori
S1. Introducció i conceptes previs
S2. Introducció als objectes
S3. Objectes compostos
S4. Taules d’objectes
S5. Pràctica d’objectes completa
S6. Punters
S7. Cues
S8. Llistes ordenades
S9. Taules dinàmiques
S10. Matrius dinàmiques – Pràctica final
S11. Herència – Pràctica final
S12. Recursivitat – Pràctica final
Continguts
1. Programació orientada a objectes (POO)
2. Disseny i implementació d'una classe
3. Constructors
4. Aspectes pràctics
5. Exemple
6. Activitats ACME
1. Programació orientada a objectes (POO)
- objecte = estat + comportament
- estat : dades (atributs)
- comportament : operacions (mètodes)
- Un objecte rep ordres ( missatges ) i hi respon executant
l’operació ( mètode ) corresponent
- classe = plantilla que ens permet crear objectes d’un cert
tipus
- La definició d’una classe dóna a tots els seus objectes
- la mateixa estructura de dades (atributs)
- una funcionalitat comú (mètodes)
- La definició d’una classe suposa la creació d’un nou tipus de
dades
1. Programació orientada a objectes (POO)
- L’ encapsulament estableix, per a una classe, dos nivells ben
diferenciats
- interfície (part pública) : capçaleres dels constructors i dels
mètodes públics , constants públiques
- determina la funcionalitat de l’objecte
- cal fer abstracció de la representació dels atributs i de la
implementació dels constructors i mètodes
- l’especificació ha de ser independent dels atributs usats per
representar la classe
- implementació (part privada) : atributs , implementació dels
constructors, mètodes públics i privats , constants i tipus
- mètodes privats: apareixen en el disseny descendent d’altres
mètodes de la classe; només són visibles des de dins de la classe,
que és on es necessiten
- Per usar una classe només cal conèixer la seva interfície
2. Disseny i implementació d'una classe
1. Programació orientada a objectes (POO)
2. Disseny i implementació d'una classe
- estructura de fitxers
- fitxer de capçaleres .h
- fitxer d'implementació .cpp
- exemple de classe
- ús de classes en un programa
3. Constructors
4. Aspectes pràctics
5. Exemple
6. Activitats ACME
2. Disseny i implementació d'una classe
- Així, tenim tres tipus de fitxers
- fitxer de capçalera (header file), Nom_classe.h
- fitxer d’implementació (implementation file): Nom_classe.cpp
- programa principal (no forma part de cap classe): main.cpp
a. Nom_classe.h
- s’hi defineixen els prototipus (les capçaleres) de tots els mètodes
de la classe (públics i privats), els atributs i les constants de tipus
no estructurats (públiques i privades)
b. Nom_classe.cpp
- cal fer #include "Nom_classe.h", a l’inici
- conté la implementació de tots els constructors i mètodes que hi
ha definits al fitxer Nom_classe.h
- s’inicialitzen les constants de tipus estructurats i també les
constants de tipus bàsics no inicialitzades al .h
c. main.cpp
- cal fer #include "Nom_classe.h" per a poder usar Nom_classe
2. Disseny i implementació d'una classe
Nom_classe.h
public: Nom_classe() Nom_classe(…) met_consultor1(…) met_consutor2(…) met_modificador1(…) ...
Nom_classe.cpp
#include "Nom_classe.h" Nom_classe::Nom_classe() {…} Nom_classe::Nom_classe(…) {…} Nom_classe::met_consultor1(…) {…} ...
main.cpp
#include "Nom_classe.h" // es poden usar objectes de la classe // i els seus mètodes públics, però // no els atributs ni mètodes privats private: int atribut bool atribut ...
#include "Nom_classe.h" // constants estructurades o no inicialitzades al .h const tipus Nom_classe ::NOM_CONSTANT2 = valor; // constructors Nom_classe ::Nom_classe() { // per defecte nom_atribut=... nom_atribut2=... nom_atribut3=... } Nom_classe ::Nom_classe(...) { // amb paràmetres nom_atribut=... nom_atribut2=... nom_atribut3=... } // mètodes consultors (accions o funcions) void Nom_classe ::nom_mètode(...) const { ... } tipus Nom_classe ::nom_mètode(...) const { ... }
2. Disseny i implementació d'una classe
// mètodes modificadors void Nom_classe ::nom_mètode(...) { ... } tipus Nom_classe ::nom_mètode(...) { ... } // mètodes privats // es codifiquen igual que els públics // mètodes classe void Nom_classe ::nom_acció (...){ ... } // acció tipus Nom_classe ::nom_funció (...){ ... } // funció
Nom_classe.cpp (source file)
#include <...>: el compilador llegeix un fitxer amb definicions de sistema #include ʺFitxer.hʺ llegeix un fitxer de capçalera i garanteix la coherència entre el .h i el .cpp
Element Des de dins de la classe (part pública i part privada) Des de fora de la classe (només la part pública) Constants públiques Constants privades nom_constant Nom_classe::nom_constant (només públiques) Atributs de l’obj. actual Atributs de l’obj. var nom_atribut var.nom_atribut (no es permet) Mètodes de l’obj. actual Mètodes de l’obj. var nom_metode( paràmetres ) var.nom_metode( paràmetres ) (només mètodes públics) var.nom_metode( paràmetres ) Mètodes de classe (accions o funcions) nom_accio( paràmetres ) nom_funcio( paràmetres ) Nom_classe::nom_accio( paràmetres ) Nom_classe::nom_funcio( paràmetres ) (només accions i funcions públiques) (La part de punters s’explicarà al bloc 2, sessió 6) Objecte actual this (punter no modificable) (this)* (objecte) Accés als elements (this).element this->element*
Accés als diferents elements d'una classe
2. Disseny i implementació d'una classe
2. Disseny i implementació d'una classe: main que usa Punt2D
- Llegeix un punt i un vector desplaçament (tots dos en 2D) i
mostra el punt desplaçat i la distància fins al punt original
#include
2. Disseny i implementació d'una classe: Punt2D.cpp
#include
2. Disseny i implementació d'una classe: Punt2D.cpp
// Consultors void Punt2D::mostrar() const { //Pre: --; Post: mostra el punt en forma (x,y) cout << "(" << a_x << "," << a_y << ")" << endl; } bool Punt2D::es_igual(Punt2D p) const { //: --; Post: retorna cert si el punt i p són iguals return a_x == p.a_x and a_y == p.a_y; } Punt2D Punt2D::punt_mig(Punt2D p) const { //Pre:--; Post: retorna el punt mig entre el punt i p return Punt2D((a_x+p.a_x)/2, (a_y+p.a_y)/2); }
2. Disseny i implementació d'una classe: Punt2D.cpp
// Modificadors void Punt2D::moure(double x, double y) { //Pre:--; Post: punt desplaçat amb vector (x,y) a_x += x; a_y += y; } void Punt2D::moure(Punt2D p) { //Pre:--; Post: punt desplaçat amb vector (0,0)->p a_x += p.a_x; a_y += p.a_y; } void Punt2D::llegir() { //Pre:--; Post: el punt és el llegit de teclat cin >> a_x >> a_y; }