El lenguaje C++

A partir del lenguaje C

Entorno de programación
Visual C++
El entorno de programación
 Solución
 Proyecto
 Hola mundo
 Compilar
 Build
 Link
 Debug
Nuevas palabras reservadas
asm operator
inline this
public delete
virtual private
catch throw
new friend
template protected
class try
 Nueva forma para E/S
 Cualquier compilador de C++, acepta C.
 La biblioteca iostream incluye los operadores cin
y cout (#include <iostream>).
 Ejemplo:
char nombre;
int num=2;
std :: cout << "Introduzca el nombre del archivo " << num << ": ";
std :: cin >> nombre;
Declaración de variables
 En cualquier lugar del bloque:
for (double suma = 0.0, int i = 0; i<n; i++)
suma += a[i]
 Variables const para tamaño de
vectores:
int main() {
const int SIZE = 5;
char cs[SIZE] ;
}
Punteros const
 Apuntan siempre a la misma dirección.
 El valor de la variable apuntada se
puede modificar.
 Se declaran así:
char* const nombre2 = "Ramón";
 Un puntero a variable const no puede
modificar el valor de esa variable.
 Punteros a variables const
 Se declaran así:
const char *nombre1 = "Ramón";
 El código: #include <stdio.h>
int main() {
const int i = 2;
En ANSI C int *p;
produce i = 3, p = &i;
*p = 3;
pero en C++ no
printf("i = %d", i);
compila.
}
Conversiones explícitas de tipo
 Ejemplo de cast: (C y C++)
return (int) (x/y);

 C++ dispone de otra conversión:

y = double(25);
return int(x/y);
Sobrecarga de funciones
 Funciones distintas con mismo nombre.
 Distinto tipo y/o número de
argumentos.
 No pueden diferir sólo en el tipo de
retorno.
 Tampoco en que un argumento se pase
por valor en una función y por
referencia en la otra.
 Parámetros con valores por
defecto

 En C++ se pueden definir valores por defecto

para todos o algunos argumentos formales.
 En la llamada, si no están los argumentos
correspondientes, se toma el valor asignado.
 Los argumentos con valores por defecto deben
estar al final de la lista.
Parámetros con valores por
defecto
 Si se omite un argumento en la
llamada, se deben omitir los siguientes
en la lista.
 Ejemplo:
double modulo(double x[], int n=3);
 En C++ se puede invocar así:
v = modulo(x, n);
v = modulo(x);
Variables de tipo referencia
 Se declaran con el operador '&'.
 Deben ser inicializadas.
 Nombre alternativo para un objeto.
 Utilidades más importantes:
 especificación de argumentos.
 especificación de tipos de retorno.
 sobrecarga de operadores.
 Variables de tipo referencia
int i = 1;
int& r = i; // r e i ahora se refieren al // mismo int
int x = r; // x = 1
r = 2;// i = 2
r++; // i se incrementa a 3
 Ningún operador opera sobre una referencia.
 El valor de una referencia no se puede
modificar (siempre se referirá al mismo objeto).
 &r es un apuntador al objeto denotado.
 Los operadores new y delete
 Hasta ahora variables estáticas o automáticas.
 Con new y delete se crean y destruyen
variables según la necesidad del programador.
 Una variable puede traspasar su bloque.
 Se puede crear cualquier tipo de variable con
new y éste retorna un puntero de ese tipo.
 No se necesita conversión de tipo.
 Clases, objetos y métodos
 Las clases se pueden ver como una
generalización de las estructuras.
 Son verdaderos tipos de datos definidos
por el usuario.
 Los objetos son las variables de una
determinada clase.
 Los métodos pueden ser funciones u
operadores.
Estructura de un programa
 En los archivos de cabecera (.h), por lo
general, se declara la clase, con los
prototipos de las funciones.
 En un archivo NombreClase.cpp de
implementan los constructores,
funciones y operadores.
 En un archivo main.cpp se define la
función main.
Ejemplo: complejo.h
 Se declaran los campos miembro privados:
class Complejo
{
private:
double real;
double imag;
 Los usuarios de la clase no podrán acceder
con los operadores '.' y '->'.
 Las funciones miembro sí tienen acceso.
Ejemplo: complejo.h
 Se declaran un conjunto de funciones y
operadores miembro en la sección
pública.
 Las tres primeras son los constructores:
public:
// Constructores
Complejo();
Complejo(double, double im=0.0);
Complejo(const Complejo&);
Ejemplo: complejo.h
 El siguiente grupo de funciones permite
dar valor a los campos:
void setData();
void setReal(double);
 O acceder a ellos:
double getReal(){return real;}
double getImag(){return imag;}
Ejemplo: complejo.h
 A continuación se declara la sobrecarga de
los operadores aritméticos, comparación y
asignación (operadores miembro).
Complejo operator+ (const Complejo&);
 Y luego la sobrecarga del operador de
inserción en el flujo de salida (operador
amigo)
friend ostream& operator<< (ostream& const Complejo&);
Sobrecarga de operadores
// operador miembro + sobrecargado
Complejo Complejo::operator+ (const Complejo
&a)
{
Complejo suma;
suma.real = real + a.real;
suma.imag = imag + a.imag;
return suma;
}
Sobrecarga de operadores
 Los operadores y funciones miembro se
indican con el operador de resolución de
alcance '::' (no así los amigos).
 En una sentencia x + y; // x, y complejos
se utiliza el operador sobrecargado.
 x es el argumento implícito.
 y se pasa explícitamente (como argumento formal
a) .
 Puntero this
 La sobrecarga de '=' retorna (*this) que
representa al argumento implícito.
 Es una variable predefinida para todas las
funciones (u operadores) miembro.
 Contiene la dirección del objeto
correspondiente.
 Forma de referirse al objeto como tal
(argumento implícito).
Constructores
 Se debe dar valor inicial a las variables
miembro. Esto se hace a través de
constructores.
 Se invocan automáticamente al crear un
objeto de una clase.
 Permiten la encapsulación.
 Tienen el mismo nombre que la clase.
 No tienen valor de retorno (ni siquiera
void).
Inicializadores
 Los constructores inicializan variables.
 C++ permite inicializar variables fuera
del cuerpo de una función.
C_Cuenta::C_Cuenta(double unSaldo, double unInteres):
Saldo(unSaldo), Interes(unInteres) // inicializadores
{ } // En este caso el cuerpo del constructor está vacío

 Permiten definir variables miembro

const.
Constructor por defecto
 Es un constructor que no necesita que se le
pasen argumentos para inicializar las
variables. Hay dos opciones:
 No tiene argumentos.
 Tiene argumentos, pero todos ellos tienen
asignado un valor por defecto en la declaración.
 Es necesario para declaraciones de la forma
Complejo z; y Complejo datos[100];
Constructor de oficio
 Lo crea el compilador de C++ si el
programador no define ningún
constructor.
 No tiene argumentos, es un constructor
por defecto (no siempre un constructor
por defecto es un constructor de oficio).
 Suelen ser cómodos, correctos y
suficientes.
Constructor de copia
 Se utiliza cuando se debe crear un objeto
a partir otro objeto de la misma clase.
 Tiene un único argumento que es una
referencia constante a un objeto de la
clase.
 El compilador también define un
constructor de copia de oficio si el
programador no lo hace (no funciona
correctamente con punteros).
 Constructores y operador de
asignación (=).
z2 = z1;
Complejo z2 = z1;
 Se supone que c1 y c2
 Se invoca al constructor
existían previamente.
de copia.
 Se utiliza el operador de
 El constructor de copia
asignación que funciona
por defecto es una copia
como un constructor de
bit a bit.
copia.
 Se debe sobrecargar.  Se debe sobrecargar
'='.
Destructores
 Es llamado cuando el objeto va a dejar
de existir.
 Para un objeto local o automático
definido en un bloque, el destructor es
invocado cuando el programa llega al
final del bloque.
 Los objetos creados con new deben ser
explícitamente destruidos.
Clases y funciones friend
 Las funciones miembro (que acceden a las
variables miembro) sólo pueden ser
miembro de una única clase.
 Una función friend de una clase es una
función que no pertenece a la clase, pero
que tiene permiso para acceder a sus
funciones y variables miembro.
 Una clase friend de otra tiene todas sus
funciones amigas de esa segunda clase.
 Herencia
class ClaseDerivada: public o private ClaseBase
 Un nombre redefinido oculta el nombre heredado.
 Hay algunos elementos de la clase base que no
pueden ser heredados:
 Constructores
 Destructores
 Funciones friend
 Funciones y datos estáticos de la clase
 Operador de asignación (=) sobrecargado
Constructores de clases
derivadas
 Debe llamar al constructor de la clase base.
 Se debe especificar un inicializador base.
 Se puede omitir si la clase base cuenta con
un constructor por defecto.

C_CuentaJoven(const char *unNombre, int laEdad,

double unSaldo=0.0, double unInteres=0.0):
C_Cuenta(unNombre, unSaldo, unInteres)
Herencia múltiple
 Una clase puede heredar de una
(herencia simple) o más clases base
(herencia múltiple).

class CuentaEmpresarial:
public Cuenta, public Empresa
Polimorfismo
Funciones Virtuales
 Son funciones distintas con el mismo
nombre, declaradas virtual en la clase
base (ligadura dinámica).
 Funciones convencionales se invocan de
acuerdo al tipo del objeto (en tiempo de
compilación).
 Con funciones virtuales se resuelve en
tiempo de ejecución el problema de la
asignación.
Funciones virtuales
class A {
A objA;
public:
B objB;
virtual void mostrar();
}
A* ptrA1;
A* ptrA2;
class B: public A {
public:
ptrA1 = &objA;
void mostrar();
ptrA2 = &objB;
}

ptrA2->mostrar();
Funciones virtuales puras
 La función virtual de la clase base debe
declararse a pesar de no ser utilizada.
 En este caso no es necesario definirla.
 Se declara como función virtual pura:
virtual funcion1() const = 0;
 No se pueden definir objetos de esa
clase.
 Se pueden definir punteros a esa clase.
Clases abstractas
 Contienen una o más funciones virtuales
puras.
 Si una clase derivada no define una función
virtual pura, la hereda como pura y por lo
tanto también es abstracta.
 Una clase que define todas las funciones
virtuales es una clase concreta.
 Entrada/Salida
 Stream o flujo: dispositivo que produce o
consume información.
 Flujos estándares:
 cin: entrada estándar (teclado).
 cout: salida estándar (pantalla).
 cerr: salida de mensajes de error (pantalla).
 Las clases istream, ostream e iostream son
clases que heredan de ios.
Manipuladores
 Variables y/o métodos miembro que
controlan el formato.
 Pueden tener argumentos (iomanip) o
no (iostream).
 Sólo afectan al flujo al que se aplican.
 No guardan la configuración anterior
(como sí lo hacen los indicadores).
Manipuladores
 Ejemplos:
 endl: se imprime un ‘\n’ y se vacía el buffer de
salida.
 flush: se vacía el buffer de salida.
 setw(int w): establece la anchura mínima de
campo.
cout << hex << 100;
cout << setw(10) << mat[i][j] << endl;

 El efecto permanece hasta que se cambia

por otro manipulador.
E/S de archivos
 En la biblioteca fstream se definen las
clases ifstream, ofstream y fstream,
que derivan de istream y ostream y a
su vez de la clase ios.
 Ejemplos:
fstream archivo;
archivo.open("datos.dat", ios::in);

ifstream archivo("datos.dat");
Excepciones
 Parte del código puede no ejecutarse
por algún error inesperado.
 Si ocurre una excepción se interrumpe
la normal ejecución del código.
 Se pueden manejar realizando una
acción adecuada para dejar al sistema
en un estado estable.
Excepciones en C++
 Se separa el código para el caso en que
ocurre una situación excepcional y el
que no:
 try: identifica un bloque de código en el
cual puede surgir una excepción.
 throw: causa que se origine una excepción.
 catch: identifica el bloque de código en el
cual la excepción se maneja.
Excepciones en C++
int main(void) {
int counts[] = {34, 54, 0, 27, 0, 10, 0};
int time = 60; // One hour in minutes

for(int i = 0 ; i < sizeof counts /sizeof counts[0] ; i++)

try {
cout << endl << "Hour " << i+1;
if(counts[i] == 0)
throw "Zero count - calculation not possible.";

cout << " minutes per item: "

<< static_cast<double>(time)/counts[i];
} catch(const char aMessage[]) {
cout << endl << aMessage << endl;
}
return 0;
}
Excepciones en C++
 Cuando la excepción es lanzada (throw)
la secuencia de ejecución continúa con
el bloque catch.
 Después de ejecutarse el código del
bloque catch la ejecución continúa con
la siguiente iteración del for.
 El compilador considera los bloques try
y catch como una única unidad.