2 POO Presentación

2,131 views

Published on

Clase de presentación del tema de introducción a la programación en C++

Published in: Education, Technology, Business
1 Comment
3 Likes
Statistics
Notes
  • POO c++ for dummys
       Reply 
    Are you sure you want to  Yes  No
    Your message goes here
No Downloads
Views
Total views
2,131
On SlideShare
0
From Embeds
0
Number of Embeds
48
Actions
Shares
0
Downloads
145
Comments
1
Likes
3
Embeds 0
No embeds

No notes for slide
























































































































  • 2 POO Presentación

    1. 1. P O O PM EL LENGUAJE C++ Y LA POO Algunas diferencias entre C y C++ Objetos, métodos, encapsulado. Tema Clases Métodos Constructores y Destructores 2 Sobrecarga Amigos Entrada y salida en C++ Espacios de nombres Miembros estáticos PM. 2. POO 1
    2. 2. Classes PM. 2. POO 2
    3. 3. Classes La mayor diferencia entre C y C++ está en soporte que este último ofrece para las clases PM. 2. POO 2
    4. 4. Classes La mayor diferencia entre C y C++ está en soporte que este último ofrece para las clases El nombre original de C++ era "C with Classes" PM. 2. POO 2
    5. 5. Classes La mayor diferencia entre C y C++ está en soporte que este último ofrece para las clases El nombre original de C++ era "C with Classes" Esencialmente una clase es una PM. 2. POO 2
    6. 6. Classes La mayor diferencia entre C y C++ está en soporte que este último ofrece para las clases El nombre original de C++ era "C with Classes" Esencialmente una clase es una Estructura de datos junto a operadores para acceder y modificarlos PM. 2. POO 2
    7. 7. Cómo se usaría una clase PM. 2. POO 3
    8. 8. Cómo se usaría una clase Se puede definir una clase "Complejo" y variables de tipo Complejo: int main() { Complejo c1, c2, c3; … PM. 2. POO 3
    9. 9. Cómo se usaría una clase Se puede definir una clase "Complejo" y variables de tipo Complejo: int main() { Complejo c1, c2, c3; … PM. 2. POO 3
    10. 10. Clases, declaración PM. 2. POO 4
    11. 11. Clases, declaración La declaración es muy parecida a la declaración de estructuras, de la que son extensión: struct Complejo { class float parteReal; float parteImaginaria; }; PM. 2. POO 4
    12. 12. Clases, declaración La declaración es muy parecida a la declaración de estructuras, de la que son extensión: class Complejo { float parteReal; float parteImaginaria; }; PM. 2. POO 4
    13. 13. Clases, declaración La declaración es muy parecida a la declaración de estructuras, de la que son extensión: class Complejo { float parteReal; float parteImaginaria; }; Los campos son ahora llamados PM. 2. POO 4
    14. 14. Clases, declaración La declaración es muy parecida a la declaración de estructuras, de la que son extensión: class Complejo { float parteReal; float parteImaginaria; }; Los campos son ahora llamados atributos PM. 2. POO 4
    15. 15. Clases, declaración La declaración es muy parecida a la declaración de estructuras, de la que son extensión: class Complejo { float parteReal; float parteImaginaria; }; Los campos son ahora llamados atributos de la clase. PM. 2. POO 4
    16. 16. Las class permiten recoger más cosas PM. 2. POO 5
    17. 17. Las class permiten recoger más cosas Puede haber también tipos, constantes, etc. PM. 2. POO 5
    18. 18. MÉTODOS class Complejo { typedef TUno int; float parteReal; float parteImaginaria; }; Las funciones dentro son ahora llamados de la clase. PM. 2. POO 6
    19. 19. MÉTODOS class Complejo { typedef TUno int; float parteReal; float parteImaginaria; métodos }; Las funciones dentro son ahora llamados de la clase. PM. 2. POO 6
    20. 20. MÉTODOS class Complejo { typedef TUno int; float parteReal; float parteImaginaria; void dividepor(float d); métodos }; Las funciones dentro son ahora llamados de la clase. PM. 2. POO 6
    21. 21. MÉTODOS class Complejo { typedef TUno int; float parteReal; float parteImaginaria; void dividepor(float d); }; Las funciones dentro son ahora llamados métodos de la clase. PM. 2. POO 6
    22. 22. Clases, uso Una vez declarada la clase, se pueden crear objetos de esa clase: Complejo c1, c2; Los objetos c1 y c2 son instancias de la clase Complejo PM. 2. POO 7
    23. 23. Los atributos están ocultos atributos, métodos, tipos, En una class constantes, etc los miembros están por defecto PM. 2. POO 8
    24. 24. Los atributos están ocultos atributos, métodos, tipos, En una class constantes, etc los miembros están ocultos por defecto PM. 2. POO 8
    25. 25. Los atributos están ocultos atributos, métodos, tipos, En una class constantes, etc los miembros están ocultos por defecto son inaccesibles PM. 2. POO 8
    26. 26. ocultos… PM. 2. POO 9
    27. 27. ocultos… int main() { PM. 2. POO 9
    28. 28. ocultos… int main() { class CComplejo { float re, im; }; PM. 2. POO 9
    29. 29. ocultos… int main() { class CComplejo { float re, im; }; CComplejo c1; PM. 2. POO 9
    30. 30. ocultos… int main() { class CComplejo { float re, im; }; CComplejo c1; c1.parteReal = 0.0; PM. 2. POO 9
    31. 31. ocultos… int main() { class CComplejo { float re, im; }; CComplejo c1; c1.parteReal = 0.0; im = c2.parteImaginaria; Decimos que parteReal y parteImaginaria son miembros privados de la clase Complejo. PM. 2. POO 9
    32. 32. ocultos… int main() { class CComplejo { float re, im; }; CComplejo c1; c1.parteReal = 0.0; im = c2.parteImaginaria; Decimos que parteReal y parteImaginaria son miembros privados de la clase Complejo. PM. 2. POO 9
    33. 33. ocultos… int main() { class CComplejo { float re, im; }; CComplejo c1; ilegal, c1.parteReal = 0.0; los atributos no son im = c2.parteImaginaria; accesibles Decimos que parteReal y parteImaginaria son miembros privados de la clase Complejo. PM. 2. POO 9
    34. 34. Atributos public PM. 2. POO 10
    35. 35. Atributos public Si queremos permitir class Complejo { el acceso desde fuera public: a los atributos de una float parteReal; clase hay que float parteImaginaria; declararlos públicos: }; PM. 2. POO 10
    36. 36. Atributos public Si queremos permitir class Complejo { el acceso desde fuera public: a los atributos de una float parteReal; clase hay que float parteImaginaria; declararlos públicos: }; class Complejo { Podemos public: combinar partes float parteReal; públicas y privadas private: de una clase: float parteImaginaria; }; PM. 2. POO 10
    37. 37. Miembros Si no son visibles los miembros privados de una clase… ¿cómo se pueden modificar o ver sus valores? La respuesta es simple: PM. 2. POO 11
    38. 38. Miembros Si no son visibles los miembros privados de una clase… ¿cómo se pueden modificar o ver sus valores? La respuesta es simple: Las funciones que necesiten acceder a los datos miembros de una clase deben estar declarados dentro de la misma clase PM. 2. POO 11
    39. 39. Miembros Si no son visibles los miembros privados de una clase… ¿cómo se pueden modificar o ver sus valores? La respuesta es simple: Las funciones que necesiten acceder a los datos miembros de una clase deben estar declarados dentro de la misma clase Son las funciones miembro o métodos. PM. 2. POO 11
    40. 40. Diferencia con las estructuras En resumen • Para controlar el uso de la información que determina el estado de un objeto se deben usar métodos • Un objeto tiene un estado interno sólo reconocible por las respuestas a las llamadas a sus métodos • Para modificar el estado de un objeto se debe llamar a sus métodos de acceso PM. 2. POO 12
    41. 41. Ejemplo de métodos class Complejo { public: void crear(int preal, int pimag); void print(); private: float parteReal; float parteImaginaria; }; PM. 2. POO 13
    42. 42. Métodos públicos y privados Vemos que los métodos pueden ser declarados: • en la parte pública: son la interfaz de uso • en la parte privada: procedimientos internos necesarios para el funcionamiento del objeto. PM. 2. POO 14
    43. 43. Ejemplo class Fraccion { public: interfaz de void crear(int num, int denom); uso void print(); private: procedimientos internos void reduce(); atributos int numerador, denominador; } PM. 2. POO 15
    44. 44. Métodos, ¿dónde se desarrollan? Aunque los métodos se ponen dentro de la clase, sólo se pone su prototipo, no su cuerpo class Fraccion { public: void crear(int num, int denom); }; Para desarrollar el cuerpo se necesita referirse al método desde fuera de la clase. PM. 2. POO 16
    45. 45. Métodos, ¿dónde se desarrollan? class Fraccion { public: void crear(int num, int denom); }; void Fraccion::crear(int num, int denom) { código de crear… } PM. 2. POO 17
    46. 46. Cuerpo de los métodos La mayoría de los métodos no se desarrollan en línea, sino que el desarrollo (los cuerpos de los métodos) se desarrollan en el fichero pareja de la cabecera .h y que sería .cpp ♥ .h .cpp dentro de él se accede a los miembros de la clase mediante la notación de ámbito nombreClase:: PM. 2. POO 18
    47. 47. Cuerpo de los métodos naves.h PM. 2. POO 19
    48. 48. Cuerpo de los métodos class Nave { naves.h public: Nave(const int x=0, const int y=0); void Mover(const int dx, const int dy); ... } PM. 2. POO 19
    49. 49. Cuerpo de los métodos class Nave { naves.h public: Nave(const int x=0, const int y=0); void Mover(const int dx, const int dy); ... } #include “naves.h” naves.cpp Nave:: Nave(const int x, const int y) { X=x;Y=y; } void Nave:: Mover(const int dx, const int dy) { X += dx; Y += dy; } PM. 2. POO 19
    50. 50. Ejemplo: complejo.cpp #include <iostream> #include <cstdlib> #include "complejo.h" // …al final de los includes Complejo::pon(const int re, const int im) { real = re; imag = im; } Complejo::print() { cout << real <<"+ i "<<imag; } PM. 2. POO 20
    51. 51. Uso de una clase Para usar una clase hay que importar su descripción (la declaración de la clase que está en la cabecera .h) y crear objetos, etcétera, en el programa: PM. 2. POO 21
    52. 52. Uso de una clase ojo: se importa clase.h tanto en clase.cpp como en prueba.cpp clase.h #include "clase.h" #include "clase.h" clase.cpp prueba.cpp PM. 2. POO 22
    53. 53. ++Compilación++ Tenemos más de un fuente (.cpp) ¿cómo compilarlos juntos? c++ clase.cpp prueba.cpp a.out Si lo tenemos todo en un directorio bastaría con: c++ *.cpp PM. 2. POO 23
    54. 54. PM. 2. POO 24
    55. 55. Construir, como ejemplo, los tres ficheros correspondientes a una clase CComplejo y un PruebaComplejo.cpp PM. 2. POO 24
    56. 56. Construir, como ejemplo, los tres ficheros correspondientes a una clase CComplejo y un PruebaComplejo.cpp PM. 2. POO 24
    57. 57. Métodos especializados PM. 2. POO 25
    58. 58. Métodos especializados • En la mayoría de las clases es necesario dar valores iniciales a sus atributos: Constructor PM. 2. POO 25
    59. 59. Constructor PM. 2. POO 26
    60. 60. Constructor ‣ Sería el miembro público cuyo nombre es el mismo que el de la clase, sin devolver nada, ni void PM. 2. POO 26
    61. 61. Constructor ‣ Sería el miembro público cuyo nombre es el mismo que el de la clase, sin devolver nada, ni void ‣ Puede llevar parámetros PM. 2. POO 26
    62. 62. Constructor ‣ Sería el miembro público cuyo nombre es el mismo que el de la clase, sin devolver nada, ni void ‣ Puede llevar parámetros ‣ Puede haber varios con distintas signaturas PM. 2. POO 26
    63. 63. Ejemplo: complejo.h class CComplejo { constructor automático public: CComplejo(int re=0, int im=1) interfaz de uso void print() const; // no modif. objeto void pon(const int re=0, const int im=1); private: int real, imag; atributos }; CComplejo c1(3,2), c2; PM. 2. POO 27
    64. 64. Constructor, casos Ejemplos de uso de Constructor Según encajen pueden ser llamados un constructor u otro. CComplejo c(10, -2), c2(5,4), c3[8]; al no poderse poner valores para cada elemento debe haber un constructor sin parámetros con valores por defecto PM. 2. POO 28
    65. 65. Ejemplo: prucomp.cpp #include <iostream.h> #include "complejo.h" llamada implícita a constructor int main() { del objeto CComplejo c1; c1.print(); cout << endl; c1.pon(2,-3); c1.print(); cout << endl; } PM. 2. POO 29
    66. 66. Construcción por copia de objetos • Constructor por copia – Sería el miembro público cuyo nombre es el mismo que el de la clase y cuyo único argumento es un objeto de la clase en modo const clase& CComplejo sin(3,2); CComplejo sin(con); // actua constructor por copia • No siempre hace falta. PM. 2. POO 30
    67. 67. Construcción por copia de objetos La construcción por copia se "ejecuta" con la declaración: • explícita en la creación: CMatriz m2 = m1; • implícita en la creación: CMatriz m3(m1); PM. 2. POO 31
    68. 68. Copia errónea de objetos La iniciación de objetos durante la construcción admite pues diversas formas: class T { public: T(); // Creador sin parámetros T(tipo uno); // Creador con un parámetro T(const T& de); // constructor por copia… PERO SI NO HAY UN OPERADOR DE COPIA, EN GENERAL: ... t1 = t2; ... YA QUE hará sólo la copia de los atributos y no se hará la construcción de la estructura correcta de una nueva copia. PM. 2. POO 32
    69. 69. Copia errónea de objetos La iniciación de objetos durante la construcción admite pues diversas formas: class T { public: T(); // Creador sin parámetros T(tipo uno); // Creador con un parámetro T(const T& de); // constructor por copia… PERO SI NO HAY UN OPERADOR DE COPIA, EN GENERAL: ... t1 = t2; ERROR ... YA QUE hará sólo la copia de los atributos y no se hará la construcción de la estructura correcta de una nueva copia. PM. 2. POO 32
    70. 70. Ejemplo: matriz.h class Matriz { public: Matriz(int n, int m); constructor Matriz(const Matriz& origen); constructor por copia ~Matriz(void); int ver(const int fila,const int col); void pon(const int fila,const int col,const int x); void dims(int &n, int &m) {n=N;m=M;}; private: int N, M; int *datos; }; PM. 2. POO 33
    71. 71. Métodos destructor PM. 2. POO 34
    72. 72. Métodos destructor • Destructor PM. 2. POO 34
    73. 73. Métodos destructor • Destructor – Miembro público cuyo nombre es el mismo que el de la clase con un ~ delante PM. 2. POO 34
    74. 74. Métodos destructor • Destructor – Miembro público cuyo nombre es el mismo que el de la clase con un ~ delante – No devolver nada, ni void PM. 2. POO 34
    75. 75. Métodos destructor • Destructor – Miembro público cuyo nombre es el mismo que el de la clase con un ~ delante – No devolver nada, ni void – No parámetros PM. 2. POO 34
    76. 76. Métodos destructor • Destructor – Miembro público cuyo nombre es el mismo que el de la clase con un ~ delante – No devolver nada, ni void – No parámetros PM. 2. POO 34
    77. 77. Métodos destructor • Destructor – Miembro público cuyo nombre es el mismo que el de la clase con un ~ delante – No devolver nada, ni void – No parámetros PM. 2. POO 34
    78. 78. Destrucción implícita La destrucción implícita se llama sola, automáticamente, cuando el objeto deja de estar accesible, por ejemplo, al acabar el ámbito de su visibilidad La destrucción puede llamarse explícitamente llamando al método de destrucción aunque esto último suele ser innecesario PM. 2. POO 35
    79. 79. Peligro de la copia de parámetros Peor ocurre aún, si hacemos una llamada a una función externa como: ... pinta(t1); ... siendo void pinta(const T t1) los resultados serán igualmente desastrosos. ¿Por qué? PM. 2. POO 36
    80. 80. Peligro de la copia de parámetros El motivo es que pinta(t1) construye una copia (mal) de t1 para el parámetro local de pinta y al acabar pinta() destruye esa copia destruyendo de camino el original. Una solución es hacer void pinta(const T& t) • sea, declarar el parámetro como referencia constante – No se copia – No se cambia PM. 2. POO 37
    81. 81. Peligro de la copia de parámetros Al recibirse el objeto por referencia no hay destrucción automática al acabar el procedimiento y no habrá sorpresas en los casos de memoria dinámica enlazada como veremos. void pinta(const T& t) PM. 2. POO 38
    82. 82. Operador de asignación = Pero el problema de la copia es más general: sólo hemos visto como evitarlo durante la creación por copia y durante el paso de parámetros. Para que la operación = funcione correctamente con nuestros objetos particulares hará falta sobrecargar el operador asignación con nuestro algoritmo particular de copiado. T& operator= (const T& orig); PM. 2. POO 39
    83. 83. Copia por asignación de objetos en general ejemplo: class T { public: T(); // Creador sin parámetros T(tipo uno); // Creador con un parámetro T(const T& de); // constructor por copia T& operator= (const T& de); // operador de copia .... PM. 2. POO 40
    84. 84. Las relaciones entre classes A veces es conveniente que otra clase pueda ver mi parte privada cuando se quiere delegar una operación común a otra clase que necesitaría ver nuestra parte privada para hacerla PM. 2. POO 41
    85. 85. AMISTAD entre clases ¿Puede ser posible que otra clase acceda a nuestra parte privada? PM. 2. POO 42
    86. 86. AMISTAD entre clases ¿Puede ser posible que otra clase acceda a nuestra parte privada? Sí PM. 2. POO 42
    87. 87. amistad entre clases permiso garantizado PM. 2. POO 43
    88. 88. amistad entre clases permiso garantizado class Una { class Otra { friend class Otra; void metodo2(Una u) { private: u.atri = 33; int atri; u.metodo(); void metodo(); } }; }; PM. 2. POO 43
    89. 89. Sobrecarga de << Si se define la clase ostream que tiene el operador a << como amiga friend ostream& operator<<(ostream &os, const Text& orig); y se desarrolla como por ejemplo: ostream& operator<<(ostream &os, const Text& orig) { os << orig.s; // accede a su parte privada return os; } PM. 2. POO 44
    90. 90. class Text { public: uso: Text(const char* txtPtr); Text() : s(0) {}; ~Text(); Text(const Text& orig); bool operator== (const Text& derecho) const; t1 == t2 Ejemplo +completo char operator[ ] (unsigned long indice) const; t1[33] unsigned long Longitud() const; void pinta(const bool nl = true) const; friend Text operator+ (const Text& ls, const Text& rs); t3 = t1 + t2 operator const char*() const; (char*) (t2) Text& operator= (const Text& orig); t1 = t2 Text& operator= (const char *str); t1 = "abc" cout << t1; friend ostream& operator<<(ostream &os, const Text& orig); private: char *s; // la cadena C unsigned long l; unsigned long strlen(const char *str) const; void strasigna(const char *desde); bool strcmp(const char *con) const; }; 45
    91. 91. #include <iostream.h> bool Text::operator== (const Text& derecho) const { #include "text.h" if (derecho.l == 0 && 0 == l) return true; // Constructor desde cadena C else Ejemplo +completo Text::Text(const char* txtPtr) : s(0), return strcmp(derecho.s); l(0) { } if (txtPtr != 0) char Text::operator[] (unsigned long indice) const { strasigna(txtPtr); if (0 <= indice && indice < l) } return s[indice]; // Constructor de copia else Text::Text(const Text& orig) : s(0), return '0'; l(orig.l) { } if (orig.l != 0) // averigua la longitud unsigned long Text::Longitud() const { strasigna(orig.s); return l; } } // destructor // Adapta el tipo (cast) a cadena C Text::~Text() { Text::operator const char*() const { delete[] s; return s; } } 46
    92. 92. // Operador de asignación unsigned long Text::strlen(const char *str) Text& Text::operator= (const Text& orig) const { { unsigned long n = 0; // evita a = a; while (str[n]) if (this == &orig) n++; Ejemplo +completo return *this; return n; if (l != 0) { } delete[] s; void Text::strasigna(const char *desde) { l = 0; unsigned long i = 0; l = strlen(desde); } s = new char[l+1]; if (orig.l) while (s[i] = desde[i]) strasigna(orig.s); i++; return *this; } } bool Text::strcmp(const char *con) const // Operador de asignación desde una str { Text& Text::operator= (const char *str) { unsigned long i = 0; if (l != 0) { while (s[i] && con[i] && s[i] == con[i]) delete[] s; i++; l = 0; return s[i] == '0' && con[i] == '0'; } } if (str != 0) strasigna(str); return *this; } 47
    93. 93. // amigo que permite sobrecargar '+' para concatenar Texts Text operator+ (const Text& ls, const Text& rs) { Text ret; unsigned long i=0, ii=0; Ejemplo +completo ret.l = ls.l + rs.l; ret.s = new char[ret.l+1]; ret.s[0] = '0'; if (ls.s != NULL) { while (ret.s[i] = ls.s[i]) i++; ii = i-1; i = 0; } if (rs.s != NULL) while (ret.s[ii] = rs.s[i]) i++; ii++; return ret; } ostream& operator<<(ostream &os, const Text& orig) { 48
    94. 94. espacios de nombres Una declaración accesible en todo el programa es una declaración global. La colección de todas las declaraciones se denomina espacio de nombres global. PM. 2. POO 49
    95. 95. using namespace C++, sin embargo, proporciona a los programadores la posibilidad de situar las declaraciones en espacios de nombres definidos por el programa. namespace nombre { void f() { cout << desde f en nombre<<endl; }; la llamada hay que hacerla: nombre::f(); excepto que se ponga antes: using namespace nombre; PM. 2. POO 50
    96. 96. librerías con namespace Las cabeceras que utilizan el espacio de nombres global suelen acabarse como clásicamente: .h Las librerías que sitúan sus declaraciones dentro de espacios de nombres (no globales) no usan extensión. Por ejemplo: <iostream> es un archivo de cabecera cuyas declaraciones están en el espacio de nombres std PM. 2. POO 51
    97. 97. librerías con namespace Por eso hacemos: #include <iostream> #include <iomanip> using namespace std; int main () { cout << setw (10); cout << 77 << endl; return 0; } PM. 2. POO 52
    98. 98. Miembros estáticos PM. 2. POO 53
    99. 99. Miembros estáticos Se pueden definir miembros (atributos o métodos) con el atributo static: PM. 2. POO 53
    100. 100. Miembros estáticos Se pueden definir miembros (atributos o métodos) con el atributo static: • Tal miembro es común a todos los objetos de tal clase. PM. 2. POO 53
    101. 101. Miembros estáticos Se pueden definir miembros (atributos o métodos) con el atributo static: • Tal miembro es común a todos los objetos de tal clase. • Tales miembros existen aunque no haya ningún objeto de tal clase PM. 2. POO 53
    102. 102. Miembros estáticos Se pueden definir miembros (atributos o métodos) con el atributo static: • Tal miembro es común a todos los objetos de tal clase. • Tales miembros existen aunque no haya ningún objeto de tal clase • Para usarlos se puede usar un objeto cualquiera de los de la clase o usar el especificador de ámbito Clase::cuenta = 33; PM. 2. POO 53
    103. 103. Miembros estáticos Se pueden definir miembros (atributos o métodos) con el atributo static: • Tal miembro es común a todos los objetos de tal clase. • Tales miembros existen aunque no haya ningún objeto de tal clase • Para usarlos se puede usar un objeto cualquiera de los de la clase o usar el especificador de ámbito Clase::cuenta = 33; • Pueden servir, por ejemplo, para mantener información global, como la cuenta de todos los objetos. No son datos globales, ya que mantienen los criterios de visibilidad. PM. 2. POO 53
    104. 104. STL string http://www.cplusplus.com/reference/string/string/ PM. 2. POO 54
    105. 105. 1 #include <iostream> 2 #include <string> 3 using namespace std; Ejemplo uso 5 int main(int argc, char *argv[]) { 6 string s = "Juan"; string 7 cout << s << endl; 8 cout << s + " Falgueras" << endl; 9 s += " (fin)"; 10 cout << s << endl; 11 cout << s.empty() << endl; 12 cout << s.length() << endl; 13 cout << s.max_size() << endl; 14 cout << s.append(" adiós") << endl; 15 cout << s.find("fin", 2) << endl; 16 cout << "En 6: " << s.at(6) << endl; 17 cout << "En 6: " << s[6] << endl; 18 cout << s.replace(6, 3, "hola") << endl; 19 cout << s.insert(10, " y adiós") << endl; 20 cout << s.erase(10, 4) << endl; 21 cout << s.substr(6, 9) << endl; 22 int i=0; 23 for(string::const_iterator it = s.begin(); it != s.end(); it++) 24 cout << i++ << " " << *it << endl; 25 getline(cin, s); 26 cout << s << endl; 27 return 0; 28 } 55
    106. 106. Características especiales de la POO en C++ PM. 2. POO 56
    107. 107. Características especiales de la POO en C++ Respecto a la POO, las características más importantes de C++ son: PM. 2. POO 56
    108. 108. Características especiales de la POO en C++ Respecto a la POO, las características más importantes de C++ son: PM. 2. POO 56
    109. 109. Características especiales de la POO en C++ Respecto a la POO, las características más importantes de C++ son: • Herencia múltiple PM. 2. POO 56
    110. 110. Características especiales de la POO en C++ Respecto a la POO, las características más importantes de C++ son: • Herencia múltiple • Sobrecarga de operadores y funciones PM. 2. POO 56
    111. 111. Características especiales de la POO en C++ Respecto a la POO, las características más importantes de C++ son: • Herencia múltiple • Sobrecarga de operadores y funciones • Derivación PM. 2. POO 56
    112. 112. Características especiales de la POO en C++ Respecto a la POO, las características más importantes de C++ son: • Herencia múltiple • Sobrecarga de operadores y funciones • Derivación • Funciones virtuales PM. 2. POO 56
    113. 113. Características especiales de la POO en C++ Respecto a la POO, las características más importantes de C++ son: • Herencia múltiple • Sobrecarga de operadores y funciones • Derivación • Funciones virtuales • Plantillas PM. 2. POO 56
    114. 114. Características especiales de la POO en C++ Respecto a la POO, las características más importantes de C++ son: • Herencia múltiple • Sobrecarga de operadores y funciones • Derivación • Funciones virtuales • Plantillas • Gestión de excepciones. PM. 2. POO 56
    115. 115. Diferencias C-C++ Se pueden sobrecargar las funciones void swap(int& a, int& b); void swap(char& a, char& b); void swap(int& a, int& b, bool& nose); bool swap(int& a, char& b); todas son homónimas pero el compilador sabe en cada llamada a quién llamar por el tipo de argumentos que se le pongan PM. 2. POO 57
    116. 116. Valores por defecto Argumentos con valor por defecto leehasta(char s[], int MAX, char delim = ‘n’) int a(int c, int a=1, int b=2) hace que a(1), ó a(1,2) ó a(1,2,3) no sean ambiguos pero int a(int a=1, int b=2, int c) NO al final a(4,5) ?? NOTA: También se pueden dar ambigüedades si se ponen valores por defecto a funciones sobrecargadas PM. 2. POO 58
    117. 117. Pequeñas diferencias C-C++ (2) Funciones inline frente a macros de preprocesador supongamos definido #define cuadrado(x) (x*x) entonces void f(double d, int i) { r = cuadrado(d); // va bien r = cuadrado(i++); // va mal: significa (i++*i++); r = cuadrado(d+1); // va mal: significa (d+1*d+1); // = (d+d+1); iría mejor, aunque no siempre bien: #define cuadrado(x) ((x)*(x)) PM. 2. POO 59
    118. 118. Pequeñas difs. C-C++: funciones inline sigue sin resolver cuadrado(i++) Así que C++ aporta una solución: inline int icuadrado(int x) { return x * x; } que expande C++ (no el procesador), sí resuelve el problema: icuadrado(i++) // va bien ya que es el propio parser de C++ el que interpreta el código PM. 2. POO 60
    119. 119. Pequeñas difs. C-C++: funciones inline • La ventaja de las funciones inline es que no hay retraso con llamadas a función. • Son expresiones que se repiten en el código cada vez que se usan sin llamar (más lento) a una función • A cambio generan un código más largo es como una función normal pero que se expande entre las líneas del código que la llama PM. 2. POO 61
    120. 120. 62
    121. 121. F I N 62

    ×