El documento describe las diferencias entre C y C++ en relación al paradigma de programación orientada a objetos. Explica que C++ agrega soporte para clases, las cuales permiten definir objetos con atributos y métodos. También describe conceptos como constructores, métodos públicos y privados, y cómo se definen y usan las clases en C++.

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. Classes
PM. 2. POO 2

3. Classes
La mayor diferencia entre C y C++ está en
soporte que este último ofrece para las
clases
PM. 2. POO 2

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. 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. 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. Cómo se usaría una clase
PM. 2. POO 3

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. 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. Clases, declaración
PM. 2. POO 4

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. 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. 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. 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. 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. Las class permiten recoger más cosas
PM. 2. POO 5

17. Las class permiten recoger más cosas
Puede haber también tipos, constantes, etc.
PM. 2. POO 5

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. 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. 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. 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. 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. 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. 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. 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. ocultos…
PM. 2. POO 9

27. ocultos…
int main() {
PM. 2. POO 9

28. ocultos…
int main() {
class CComplejo { float re, im; };
PM. 2. POO 9

29. ocultos…
int main() {
class CComplejo { float re, im; };
CComplejo c1;
PM. 2. POO 9

30. ocultos…
int main() {
class CComplejo { float re, im; };
CComplejo c1;
c1.parteReal = 0.0;
PM. 2. POO 9

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. 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. 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. Atributos public
PM. 2. POO 10

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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. Cuerpo de los métodos
naves.h
PM. 2. POO 19

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. 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. 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. 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. 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. ++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. PM. 2. POO 24

55. Construir, como ejemplo, los tres
ficheros correspondientes a una
clase CComplejo y un
PruebaComplejo.cpp
PM. 2. POO 24

56. Construir, como ejemplo, los tres
ficheros correspondientes a una
clase CComplejo y un
PruebaComplejo.cpp
PM. 2. POO 24

57. Métodos especializados
PM. 2. POO 25

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. Constructor
PM. 2. POO 26

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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. Métodos destructor
PM. 2. POO 34

72. Métodos destructor
• Destructor
PM. 2. POO 34

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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. AMISTAD entre clases
¿Puede ser posible que
otra clase
acceda a nuestra parte privada?
PM. 2. POO 42

86. AMISTAD entre clases
¿Puede ser posible que
otra clase
acceda a nuestra parte privada?
Sí
PM. 2. POO 42

87. amistad entre clases
permiso
garantizado
PM. 2. POO 43

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. 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. 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. #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. // 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. // 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. 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. 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. 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. 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. Miembros estáticos
PM. 2. POO 53

99. Miembros estáticos
Se pueden definir miembros (atributos o métodos)
con el atributo static:
PM. 2. POO 53

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. 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. 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. 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. STL string
http://www.cplusplus.com/reference/string/string/
PM. 2. POO 54

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. Características especiales de la POO en C++
PM. 2. POO 56

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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 62

121. F I N
62