C++

Prácticas: POO

Franma 1 / 30
 Índice
❖ Índice

C++ Básico

C++ POO
C++ Básico
C++ POO

Franma 2 / 30
❖ Índice

C++ Básico
❖ Tipos primitivos
❖ Literales
❖ Punteros y
referencias
❖ Funciones
❖ Operadores C++
❖ Namespace
❖ Variables
constantes
C++ Básico
❖ Referencias
constantes

C++ POO

Franma 3 / 30
 Tipos primitivos
❖ Índice

C++ Básico bool

❖ Tipos primitivos
❖ Literales
char wchar_t
❖ Punteros y
referencias
int
❖ Funciones float double
❖ Operadores C++
❖ Namespace
void // no es un tipo propiamente dicho
❖ Variables
constantes
❖ Referencias
constantes Modificadores:
C++ POO
• De signo. Para int y char: signed, unsigend.
• De tamaño entero. Para int: short, long, long long.
• De tamaño real. Para double: long.

Franma 4 / 30
 Literales
❖ Índice

C++ Básico long : 123 L

❖ Tipos primitivos
❖ Literales
long long : 123 LL
❖ Punteros y
referencias
unsigned : 123 U
❖ Funciones unsigned long long : 123 ULL
❖ Operadores C++
❖ Namespace
float : 123.0[ f ]
❖ Variables
constantes
double : 123.0 ( por defecto )
❖ Referencias
constantes
long double : 123.0 L
C++ POO

Franma 5 / 30
 Entrada/Salida
❖ Índice

C++ Básico # include < iostream >

❖ Tipos primitivos
❖ Literales
using namespace std ;
❖ Punteros y
referencias
// Salida :
❖ Funciones cout << variable << " hola " << endl ;
❖ Operadores C++
❖ Namespace
❖ Variables
constantes
// Entrada :
❖ Referencias
constantes
cout << " Qu é edad tienes ? "
C++ POO cin >> edad ;

// Salida est á ndar de error

cerr << " Error : sin disco " << endl ;

// Salida est á ndar de log

clog << " Usuario logado " << endl ;

Franma 6 / 30
 Punteros y referencias
❖ Índice
Punteros:
C++ Básico
❖ Tipos primitivos int * p ; // declaraci ó n puntero
❖ Literales
❖ Punteros y p = & variable ; // direcci ó n de
referencias
❖ Funciones variable = * p ; // indirecci ó n de
❖ Operadores C++
❖ Namespace
int ** pp ; / puntero a puntero
❖ Variables
constantes
❖ Referencias
constantes
Referencias:
C++ POO
int & ref = variable ; // declaraci ó n ref .

• Una referencia es un sinónimo.

• Deben ser inicializada en su declaración.
• No existe referencias nulas.
• Una vez inicializada no podemos cambiar una
referencia (si el objeto al que referencia).

Franma 7 / 30
 Funciones
❖ Índice
Parámetros por defecto:
C++ Básico
❖ Tipos primitivos // declaraci ó n ( siempre los ú ltimos ):
❖ Literales
❖ Punteros y int funcion ( int a , int b =1 , int c =2);
referencias
❖ Funciones ...
❖ Operadores C++
❖ Namespace
// definici ó n :
❖ Variables int funcion ( int a , int b , int c ) {
constantes
❖ Referencias ...
constantes

C++ POO
}

Sobrecarga: funciones con el mismo nombre y distintas

signaturas (número y tipo de parámetros, sin retorno).
int suma ( int a , int b );
int suma ( int a , int b , double peso );

Franma 8 / 30
 Operadores C++
❖ Índice
Además de los operadores de C:
C++ Básico
❖ Tipos primitivos Operador de á mbito :
❖ Literales
❖ Punteros y ::
referencias
❖ Funciones
❖ Operadores C++
❖ Namespace
Identificaci ó n tipo :
❖ Variables typeid ( variable | tipos )
constantes
❖ Referencias
constantes

C++ POO
Memoria din á mica :
new delete
new [] delete []

Franma 9 / 30
 Namespace
❖ Índice
Def: zona separada donde se pueden declarar y definir objetos,
C++ Básico
❖ Tipos primitivos
funciones, tipos, clases, estructuras, etc.
❖ Literales
❖ Punteros y
Por defecto: espacio global.
referencias Definición:
❖ Funciones
❖ Operadores C++
❖ Namespace
namespace [ < identificador >] {
❖ Variables ...
constantes
❖ Referencias < declaraciones y definiciones >
constantes

C++ POO
...
}
Activación:
using namespace < identificador >;
Alias:
namespace < alias > = < nombre_original >
Franma 10 / 30
 Variables constantes

int var = 1;
const int cte = 2; // valor en declaraci ó n
const int * ptr_a_cte = & var ; // o & cte
int * const ptr_cte_a_var = & var ;
const int * const ptr_cte_a_cte = & var ; // o & cte

Franma 11 / 30
 Referencias constantes

Las referencias (no su valor) son siempre constantes.

int var = 1;
const int cte = 2;
const int & ref_a_cte = var ; // cte

Franma 12 / 30
❖ Índice

C++ Básico

C++ POO
❖ Clases
❖ Constructor
❖ Destructor
❖ Definiciones friend
❖ Herencia
❖ Herencia
❖ Override métodos
C++ POO
❖ Sobrecarga op.
❖ Override métodos
virtual

Franma 13 / 30
 Clases
❖ Índice

C++ Básico class < nombre > {

C++ POO public :
❖ Clases
❖ Constructor
< lista de miembros >
❖ Destructor
❖ Definiciones friend
❖ Herencia private : // por defecto
❖ Herencia
❖ Override métodos
< lista de miembros >
❖ Sobrecarga op.
❖ Override métodos
virtual protected :
< lista de miembros >
} [ < lista objetos >];

Franma 14 / 30
 Constructor
❖ Índice
• Mismo nombre que la clase.
C++ Básico
• Por defecto: si no se define ningún constructor el
C++ POO
❖ Clases compilador creará uno sin parámetros, que no hace nada.
❖ Constructor
❖ Destructor
• Uso constructor por defecto:
❖ Definiciones friend
❖ Herencia
Clase variable (); // MAL
❖ Herencia Clase variable ; // BIEN sin par é ntesis
❖ Override métodos
❖ Sobrecarga op.
❖ Override métodos
• Asignación rápidas (solo constructor):
virtual
Clase :: Clase ( int par_a , int par_b ) {
a = par_a ;
b = par_b ;
}
// Hay que cambiarlo por :
Clase :: Clase ( int par_a , int par_b ):
a ( par_a ) , b ( par_b ) {}
Franma 15 / 30
 Constructor
❖ Índice
• Con argumentos por defecto:
C++ Básico

C++ POO Clase ( int a =0 , int b =1); // los ú ltimos

❖ Clases
❖ Constructor • Constructor copia:
❖ Destructor
❖ Definiciones friend
❖ Herencia
Clase ( const Clase & a_copiar );
❖ Herencia
❖ Override métodos
❖ Sobrecarga op.
❖ Override métodos
virtual

Franma 16 / 30
 Destructor
❖ Índice
• Mismo nombre de la clase con
C++ Básico
• Sin tipo de retorno ni parámetros.
C++ POO
❖ Clases • No se heredan.
❖ Constructor
❖ Destructor
• Deben ser públicos.
❖ Definiciones friend • No pueden ser sobrecargados.
❖ Herencia
❖ Herencia
❖ Override métodos
❖ Sobrecarga op.
❖ Override métodos
virtual

Franma 17 / 30
 Definiciones friend
❖ Índice

C++ Básico class Clase {

C++ POO ...
❖ Clases
❖ Constructor
friend class ClaseAmiga ;
❖ Destructor friend int funcion_amiga ( Clase c , ...);
❖ Definiciones friend
❖ Herencia };
❖ Herencia
❖ Override métodos • ClaseAmiga tiene acceso a todos los miembros de Clase.
❖ Sobrecarga op.
❖ Override métodos • funcion_amiga() no es un miembro de Clase, pero tiene
virtual
acceso a todos sus miembros.

• La amistad no puede transferirse.

• La amistad no puede heredarse.
• La amistad no es simétrica.

Franma 18 / 30
 Herencia
❖ Índice

C++ Básico class Derivada : < visibilidad > Base1 ,

C++ POO < visibilidad > Base2 ... {
❖ Clases
❖ Constructor
❖ Destructor Derivada (): Base1 () , Base2 () {};
❖ Definiciones friend
❖ Herencia };
❖ Herencia
❖ Override métodos <visibilidad> :
❖ Sobrecarga op.
❖ Override métodos
virtual
• public: se mantiene el nivel la visibilidad de las propiedades
heredadas.
• protected: porpiedades public heredadas como protected.
• private: todas las propiedades se heredan como privadas.
(Por defecto).

Franma 19 / 30
 Herencia
❖ Índice

C++ Básico class A { public : int a ;

C++ POO protected : int b ;
❖ Clases
❖ Constructor
private : int c ; };
❖ Destructor
❖ Definiciones friend
❖ Herencia class B : private A {};
❖ Herencia
❖ Override métodos
// -a y b se heredan como privado
❖ Sobrecarga op. // -c al ser privado , no se hereda
❖ Override métodos
virtual

class C : protected A {};

// -a y b se heredan como protegido
// -c al ser privado , no se hereda

class D : public A {};

// -a sigue p ú blico y b sigue protegido
// -c al ser privado , no se hereda
Franma 20 / 30
 Herencia: constructor
❖ Índice

C++ Básico class Derivada : public Base {

C++ POO
❖ Clases
❖ Constructor
Derivada (): Base () {};
❖ Destructor
❖ Definiciones friend
❖ Herencia };
❖ Herencia
❖ Override métodos • Los constructores no se heredan.
❖ Sobrecarga op.
❖ Override métodos • Lo primero que hace un constructor es invocar el contructor
virtual
de la clase base (que tiene que ser la primera cosa que se
ejecute).

Franma 21 / 30
 Override métodos
❖ Índice
• Sustituye/override un método de la clase base.
C++ Básico
• Idéntica signatura.
C++ POO
❖ Clases • Se invocan según el tipo de la variable.
❖ Constructor
❖ Destructor
❖ Definiciones friend
❖ Herencia
❖ Herencia
❖ Override métodos
❖ Sobrecarga op.
❖ Override métodos
virtual

Franma 22 / 30
 Override métodos
❖ Índice

C++ Básico class Base {

C++ POO int suma ( int , int ) {...}
❖ Clases
❖ Constructor
};
❖ Destructor class Derivada: Base {
❖ Definiciones friend
❖ Herencia double suma ( int , int ) {...} // override
❖ Herencia
❖ Override métodos
};
❖ Sobrecarga op.
❖ Override métodos
virtual Base *base = new Base ();
Derivada *deri = new Derivada ();

base-> suma (1 ,2) //Base::suma()

deri-> suma (1 ,2) //Derivada::suma()
base = deri ;
base-> suma (1 , 2) //Base::suma()

Franma 23 / 30
 Sobrecarga operadores
❖ Índice
Operadores que no se pueden sobrecargar:
C++ Básico

C++ POO # directiva del preprocesador

❖ Clases
❖ Constructor
## directiva del preprocesador
❖ Destructor . acceso a miembro
❖ Definiciones friend
❖ Herencia
: valor por defecto en funciones
❖ Herencia :: acceso a á mbito
❖ Override métodos
❖ Sobrecarga op. .* puntero a miembro
❖ Override métodos
virtual ? condicional ternario
sizeof
typeid
Sólo pueden ser sobrecargados como miembros de una clase:
= [] -> ()
new delete

Franma 24 / 30
 Sobrecarga operadores
❖ Índice
• Como una función friend.
C++ Básico
• Como miembro de una clase.
C++ POO
❖ Clases
❖ Constructor
❖ Destructor
Clase operator +( const Clase & otro )
❖ Definiciones friend friend Clase & operator +( const Clase & a ,
❖ Herencia
❖ Herencia
const Clase & b )
❖ Override métodos
❖ Sobrecarga op.
❖ Override métodos
virtual

Franma 25 / 30
 Sobrecarga « y »
❖ Índice
Siempre como funciones friend:
C++ Básico

C++ POO ostream & operator < < ( ostream & os ,

❖ Clases
❖ Constructor
const Clase & c )
❖ Destructor
❖ Definiciones friend
❖ Herencia
istream & operator > > ( istream & is ,
❖ Herencia Clase & c )
❖ Override métodos
❖ Sobrecarga op.
❖ Override métodos
virtual

Franma 26 / 30
 Sobrecarga ++
❖ Índice
Preincremento:
C++ Básico

C++ POO Clase & operator ++() {

❖ Clases
❖ Constructor
...
❖ Destructor return * this ;
❖ Definiciones friend
❖ Herencia
}
❖ Herencia
❖ Override métodos Postincremento:
❖ Sobrecarga op.
❖ Override métodos
virtual
Clase operator ++ ( int ) {
Clase old = * this ; // copia antiguo
operator ++(); // preincremento
return old ;
}

Franma 27 / 30
 Override métodos virtual
❖ Índice
• virtual indica método polimórfico.
C++ Básico
• override (opcional) indica override de un método virtual.
C++ POO
❖ Clases • Sustituye/override un método de la clase base.
❖ Constructor
❖ Destructor
• Idéntico prototipo (signatura + tipo devuelto).
❖ Definiciones friend • Se invocan según el tipo del objeto.
❖ Herencia
❖ Herencia
❖ Override métodos
❖ Sobrecarga op.
❖ Override métodos
virtual

Franma 28 / 30
 Override métodos virtual
❖ Índice

C++ Básico class Base {

C++ POO virtual int suma ( int , int ) {...}
❖ Clases
❖ Constructor
};
❖ Destructor class Derivada: Base {
❖ Definiciones friend
❖ Herencia int suma ( int , int ) override {...}
❖ Herencia
❖ Override métodos
};
❖ Sobrecarga op.
❖ Override métodos
virtual Base * base = new Base();
Derivada * deri = new Derivada();

base - > suma (1 ,2) //Base::suma()

deri - > suma (1 ,2) //Derivada::suma()
base = deri ;
base - > suma (1 , 2) //Derivada::suma()

Franma 29 / 30
 Método virtual puro
❖ Índice
• Método sin implementación.
C++ Básico
• Pensado para heredar.
C++ POO
❖ Clases • La clase que lo contiene: clase abstracta.
❖ Constructor
❖ Destructor
❖ Definiciones friend class Base {
❖ Herencia
❖ Herencia
virtual int suma ( int , int )=0;
❖ Override métodos };
❖ Sobrecarga op.
❖ Override métodos
virtual
class Derivada }: Base {
int suma ( int , int ) override {
...
}
};

Franma 30 / 30