Programación en c++

Ander Mijangos
Universidad de Deusto

Octubre de 2010
 Aspectos generales de c++
• Es una ampliación de c para dar soporte a la POO
• El tercer lenguaje de programación más usado
(octubre de 2010)1
• Se usa para SO, SGBD, sistemas de Tiempo Real…
• Case sensitive
• Las variables sólo existen en su ámbito {…}
• Los programas se organizan en dos ficheros:
▫ .h: archivos de cabecera
▫ .cpp: archivos de código fuente (que incluyen el .h)

1 http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html
¡Hola Mundo!
#include <iostream>
using namespace std;

void main()
{
cout << "¡Hola mundo!" << endl;
}
Tipos de datos básicos
• Enteros
▫ (signed/unsigned) (long/short) int
• Char (carácter y mucho más)
▫ (unsigned) char //1 byte
• Coma flotante
▫ float
▫ double //64 bits
• Booleano
▫ bool
Más tipos de datos (I)
• Definidos por el programador
▫ struct
▫ class
▫ enum
▫ union
• Arrays y punteros
▫ []
▫*
Más tipos de datos (II)
• sizeof
▫ sizeof(TIPO);
• typedef
▫ typedef TIPO_ANTIGUO TIPO_NUEVO;
• Constantes
▫ 1, true, 0x01 (hexadecimal), 0.1, „a‟…
• Declaración e inicialización
▫ unsigned int contador;
▫ int a = 5, b = 5, c;
Entrada y salida por consola
• Hay que incluir la STL y especificar el
namespace
▫ #include <iostream>
▫ using namespace std;
• Sentencias:
▫ cout << "Introduzca el precio: ";
▫ cin >> precio;
String
• Es una clase definida en la STL
▫ #include <string>
• Declaración e inicialización:
▫ string nombreUsuario = “Ander”;
• Realmente se trata de una cadena de caracteres
que finaliza en „\0‟
• Algunas funciones miembro:
▫ size();
Preprocesador
• Include • Los archivos de
#include <FICHERO> cabecera se suelen
• Define asegurar ante
#define SIMBOLO inclusiones múltiples:
[VALOR] #ifndef
• Ifdef NOMBRE_DE_FICHERO_H
#if(n)def SIMBOLO #define
… NOMBRE_DE_FICHERO_H
#else …
… #endif
#endif
Comentarios
• De bloque:
▫ /* … */
• De línea:
▫ // …
Type cast
• Convierte un tipo de datos en otro
int i = 1000;
char c = (char)i;
 Nota: con pre, primero se ejecuta el
operador; con post, primero se evalúa

Operadores (I) la expresión y al final se ejecuta el

operador.

• Aritméticos • Aritméticos y de
▫ Binarios asignación
 + ▫ +=
 - ▫ -=
 * ▫ *=
 / ▫ /=
 % (módulo) ▫ %=
▫ Unarios
-
 ++
 --
 Nota: valor != 0 -> true
valor == 0 -> false

Operadores (II)
• Operadores relacionales
▫ ==
▫ !=
▫ <
▫ >
▫ <=
▫ >=
• Operadores booleanos
▫ && (AND)
▫ || (OR)
▫ ! (NOT)
 Precedencia de operadores
:: *&+-!~ &
:: new ^
-> . delete |
[] () &&
() ->* .* ||
++ */% ?:
= *= /= += -= >*gt;=
-- +-
&= ^= |= %= <<=
sizeof << >> ,
++ < > <= >=
-- == !=

(De arriba a bajo y de izquierda a derecha)

Control (I)
• if • switch
if (EXPRESION) switch (EXPRESION)
{ {
SENTENCIA(S); case VALOR1:
} SENTENCIAS;
else break;
{ case VALOR2:
SENTENCIA(S); SENTENCIAS;
} break;
case VALOR3:
case VALOR4:
SENTENCIAS;
break;
default:
SENTENCIAS;
}
Control (II)
• Operador condicional ? • for
EXPRESION ? EXPRESION_TRUE for(EXPRESION(ES)_INICIAL(E
: EXPRESION_FALSE S); EXPRESION;
• while EXPRESION(ES)_ITERATIVA(S))
while(EXPRESION) {
{ SENTENCIA(S);
SENTENCIA(S); }
}
• do while • Break: acaba la sentencia
do condicional o repetitiva actual
{ • Continue: salta hasta la
SENTENCIA(S); terminación de la iteración
} actual
while(EXPRESION);
Funciones
• Formato
TIPO_RETORNO IDENTIFICADOR( [PARAMETRO(S)] )
{
[return VALOR;]
}
• Se puede declarar la función antes de
implementarla
• Al llegar a un return la función finaliza
Punteros (I)
• Es un tipo de datos
• Generalmente tiene 32 bits
• Interpretación: representa una dirección de
memoria
• Formato:
▫ int*punteroEntero;
• Indirección (acceso al contenido referenciado):
▫ *punteroEntero= 1000;
• Nunca se asigna directamente un valor a un puntero
• Obtener la dirección de una variable:
▫ &miVariable
Punteros (II)
• El SO reserva memoria:
▫ Al declarar una variable (memoria estática):
 int i;
▫ A petición del programador (memoria dinámica)
 (explicado posteriormente)

• Utilidad de los punteros:

▫ Modificar una variable en una función
 Nota: un array de N elementos

Arrays tiene los elementos de 0 a N-1

• Conjuntos de datos consecutivos

• Declaración (obligatorio que sea un valor constante, si no, ver
memoria dinámica):
int arrayEnteros[20];
• Inicialización:
int arrayEnteros[2] = {5, 9};
int arrayEnteros[] = {5, 9};
• Acceder a los datos del array:
arrayEnteros[0] = 0;
arrayEnteros[1] = 0;
• Conocer el tamaño de un array:
sizeof(arrayEnteros) / sizeof(int);
• Arrays multidimensionales:
intarrayEntero2D[2][3] = {{1, 2, 3}, {1, 2, 3}};
Arrays y punteros
• El identificador de un array es un puntero constante
que apunta a la dirección de memoria del primer
elemento del array.
• Un puntero puede usarse con [], sumando sobre la
dirección inicial bytes según el tipo del puntero.
• Pasar un array como parámetro:
funcion (array, 2);
void funcion1(int array[], int tamanio)
{…}
void funcion2(int* puntero, int tamanio)
{…}
• Sizeof funciona con el array entero, con un puntero
devuelve el tamaño del puntero (32 bits)
Cadenas de caracteres
• Son arrays de tipo char
• const char* cadena = “Hola mundo”;
• En <string.h> hay muchas funciones
• El tipo de datos string encapsula todo esto
Memoria dinámica
• Reservar y liberar memoria:
▫ int* punteroEntero = new int();
▫ delete punteroEntero;
• En el caso de arrays:
▫ int* puntero = new int[10];
▫ delete [] puntero;
• Un new obliga a usar un delete en algún momento.
• Utilidad: evitar perder la información cuando la
variable muere
• Función dinámica: función que devuelve una
dirección de memoria
Estructuras
• Especificación: • Uso con un puntero a la
struct TIPO estructura (->):
{ ESTRUCTURA* pE;
TIPO_0 dato0; pE->TIPO_0;
TIPO_1 dato1;
…
TIPO_NdatoN;
};
• Uso (.):
ESTRUCTURA e;
e.TIPO_0;
POO: Clases
• Declaración:
class Fecha
{
unsigned int anyo;
unsigned int mes;
unsigned int dia;
};

• Una clase tiene:

▫ Datos miembro = atributos
▫ Funciones miembro = métodos

• Clases y objetos
▫ Clase: declaración del tipo de datos
▫ Objeto: variable de dicho tipo de datos (instanciación)
POO: Encapsulación
• Programación Orientada a Objetos
• Consta de:
▫ Clases
▫ Encapsulación

• Encapsulación: determina si se puede acceder a los

atributos y métodos desde fuera de la clase (programa
principal).
▫ public: son accesibles desde fuera
▫ private: sólo son accesibles desde la clase (o algún método
público que lo manipule -> más control)
• Generalmente: atributos privados y métodos públicos
• Se usan getters y setters para manipular los atributos
POO: Constructores y destructores
• Constructor: método especial que se ejecuta al instanciar un
objeto.
▫ No devuelve nada
▫ Se llama igual que la clase, con () por ser método
▫ Se usa para inicializar los atributos
▫ Hay un constructor por defecto
• Destructor: método especial que se ejecuta al eliminar un
objeto de memoria.
▫ No devuelve nada
▫ Se llama igual que la clase, precedido de ~ y con () por ser método
▫ Se usa para liberar memoria dinámica, cerrar ficheros…
▫ Hay un destructor por defecto
• Pueden encapsularse como privados, pero en general serán
públicos
POO: Sobrecarga
• Dos métodos pueden llamarse igual si cambian:
▫ El número de parámetros
▫ El tipo de los parámetros
• Se puede sobrecargar el constructor
• No tiene sentido sobrecargar el destructor
• Un constructor con parámetros hace que el
constructor por defecto se pierda (obliga a pasar
parámetros en la instanciación)
Constructor de copia y operador de
asignación
• Constructor de copia
▫ Se llama en cuatro casos:
 Al crear un objeto como copia de otro
 ArrayInt ai2 = ai;
 ArrayInt ai2(ai1);
 Al llamar a una función pasándole por valor un objeto
 Al hacer return de un objeto
▫ Cadena (const Cadena& c)
• Operador de asignación
▫ Se llama al hacer una asignación
▫ Cadena& operator= (const cadena& c) return *this
POO: Operador ::
• Generalmente, la clase se declara en un fichero
.h y los métodos se implementan en un .cpp.
• Operador de resolución de ámbito:
▫ Fecha::Fecha()

• Llamada a un método:
▫ objeto.metodo(parámetros);
POO: Puntero this
• En los métodos no se pasa el objeto como parámetro
• El compilador añade automáticamente:
▫ bool esBisiesto(Fecha* const this)
• „This‟ es un puntero al objeto desde el que se llama a
la función.
• Su uso no es obligatorio salvo:
▫ Para distinguir el atributo de otro parámetro llamado
igual (this->atributo)
▫ Para referenciar al objeto en sí
• Para que el objeto referenciado también sea
constante, al final de la cabecera del método se
escribe „const‟
POO: Miembros estáticos
• Atributo estático: cada objeto no tiene su propio
valor para el atributo sino que es compartido.
▫ Para acceder desde el programa principal:
 Fecha::Meses
▫ Se inicializa en el .cpp donde se implementan los
métodos de la clase.
• Método estático: no recibe el objeto por
parámetro (no tiene this).
▫ Para acceder desde el programa principal:
 Fecha::esBisiesto(2006)
Punteros a funciones
• Declaración del puntero:
int (*punteroAIntFuncionIntInt) (int, int);
• Función que se va a referenciar:
int funcion(int, int)
{
}
• Asignación de la dirección:
punteroAIntFuncionIntInt = &funcion; //&
opcional
• Llamada a la función desde el puntero:
funcion(1,3)
punteroAIntFuncionIntInt(1,3); // Hacen lo
mismo
 Referencias
• Permiten modificar una variable en una función
sin tratar con punteros
NORMAL (el valor no CON PUNTEROS: CON REFERENCIAS:
se modifica):
void funcion(int i) void funcion(int* pi) void funcion(int& ri)
{ { {
i= 2; *pi= 2; ri = 2;
} } }
void main() void main() void main()
{ { {
int i = 1; int i = 1; int i = 1;
funcion(i); funcion(&i); funcion(i);
} } }
 Esta presentación está basada en los apuntes tomados
en la asignatura de Laboratorio de Informática I
impartida por Jesús Sanz e Iker Jamardo, en la facultad
de Ingeniería de la Universidad de Deusto.

Esta presentación está publicada bajo la licencia

Creative Commons Reconocimiento – No Comercial 3.0
España
http://creativecommons.org/licenses/by-nc/3.0/es/

Ander Mijangos
Universidad de Deusto
andermijan (arroba) gmail (punto) com
http://www.slideshare.net/andermijan