PDF de programación - El lenguaje de Programación C++

UNIVERSIDADE DA CORUÑA

El lenguaje de programación C++

Fernando Bellas Permuy

Departamento de Tecnologías de la Información y las Comunicaciones (TIC)

Universidad de A Coruña

http://www.tic.udc.es/~fbellas

[email protected]

Introducción

• C++ extiende el lenguaje de programación C con conceptos de

Orientación a Objetos.

• Es un lenguaje compilado.

• Índice:

• Revisión del lenguaje C.

• Mejoras (no OO) introducidas por C++.

• Clases.

• La herramienta “make” en Unix.

• Herencia.

• Sobrecarga de operadores.

• Plantillas (templates).

• Excepciones.

• La librería estándar de C++.

• Bibliografía.

1

Nociones básicas de C (1)

• Tipos de datos básicos.

Tipo

Indentificador

Ejemplo de valores

Modificadores

Caracteres
Enteros

Reales
Reales (doble pre-
cisión)
“Booleans”

char
int

float
double

int

'a', '9', '#', 10
23, -34, 0

3, 3.0, 3e10
3, 3.0, 3e600

0 (false), != 0 (true)

unsigned
long, short,
unsigned

long

• Operadores aritméticos: =, +, -, %, /, ++, --, y variantes de =

• Variables: locales, globales.

#include <stdio.h>
float e; /* Variable global */
int main ()
{
float v, t; /* Variables locales */
v = 30; /* Velocidad */
t = 5; /* Tiempo */
e = v * t;
printf("Velocidad: %f\nTiempo: %f\n", v, t);
printf("Espacio recorrido: %f\n", e);
return 0;
}

2

Nociones básicas de C (y 2)

• Operadores ++, --, y variantes de =

i = 4;
j = 2 * (i++);
/* i = 5, j = 8 */

i = 4;
j = 2 * (++i);
/* i=5, j = 10 */

i = 4;
i %= 3; /* i = i % 3; */
i += 4; /* i = i + 4; */
/* i = 5 */

• Entrada salida con printf/scanf y similares.

#include <stdio.h>
int main ()
{
float v, t, e;
printf("Velocidad: ");
scanf("%f", &v);
printf("Tiempo: ");
scanf("%f", &t);
e = v * t;
printf("Velocidad: %5.2f; Tiempo: %5.2f; Espacio: %5.2f\n",v,t,e);
return 0;
}

• Caracteres de control en printf, scanf: d, o, x, c, s, f, e, p.

• En C++ hay una alternativa mejor: los streams de entrada/sal-

ida.

3

Control de flujo (1)

• Operadores relacionales: >, >=, <, <=, ==, !=
• Operadores lógicos: &&, ||, !
• if.. else..

if (condición) {
<< sentencias >>
} else {
<< sentencias >>
}
• switch-case-default

switch (exp) {
case A:
<< instrucciones >>
break;
case B:
<< instrucciones >>
break;
...
default:
<< instrucciones por defecto >>
}

switch (letra) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u': printf("Es una vocal\n");
break;
case 'ñ': printf("Nuestra querida ñ\n");
break;
default: printf("Cualquier otro caracter");
}

4

Control de flujo (y 2)

• Bucle while

• Bucle do.. while

• Bucle for

while (condición) {
<< instrucciones >>
}

do {
<< instrucciones >>
} while (condición)

for (inic; cond; incr) {
<< instrucciones >>
}

for (i=1; i<=10; i++) {
printf(“%i\n“, d);
}

Operadores de bit

• & (AND), | (OR), ~ (NOT), ^ (XOR), >> (shift right), << (shift

left).

5

Estructuras de datos estáticas (1)

• Vectores.

int vector[] = {1, 2, 3, 4, 5};
int vector2[5] = {1, 2, 3, 4, 5};
int matriz[10][10];
char matriz3[4][5][6];
int main ()
{
float matriz2[][3] = { {1, 2, 3}, {4, 5, 6} };
int i, j;
for (i=0; i<2; i++) {
for (j=0; j<3; j++) {
printf("%f\n", matriz2[i][j]);
}
}
return 0;
}

• Registros o Estructuras.

struct nombre {
Tipo1 campo1;
Tipo2 campo2;
...
TipoN campoN;
} variable;

• Uniones.

union Ejemplo {
char caracter;
int entero;
};

struct TipoPunto {
int x;
int y;
} punto;

punto.x = 1;
punto.y = 2;

struct FiguraColoreada {
int color;
int tipoFigura;
union {
struct Esfera e;
struct Segmento s;
} figura;
}

6

Estructuras de datos estáticas (y 2)

• Tipos definidos por el usuario (typedef).

typedef unsigned char TipoByte;
typedef struct {
int x;
int y;
} TipoPunto;

• Enumeraciones.

enum Dia { Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo};

7

Punteros (1)

• Un puntero es una variable cuyo contenido es una dirección

de memoria.

• Operadores: &, *, ->
• Ejemplos:

int x;
int* px;
x = 1;
px = &x;
*px = 2; /* x = 2 */

TipoPunto* pPunto;
pPunto->x = 1;
pPunto->y = 2;

• Punteros y matrices.

int i;
int v[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int* p;
for (i=0; i<10; i++) {
printf("%d\n", v[i]);
}
for (i=0, p=v; i<10; i++, p++) {
printf("%d\n", *p);
}
for (p=v; p != &(v[10]); p++) {
printf("%d\n", *p);
}

8

Punteros (y 2)

• Cadenas de caracteres: Vectores de caracteres terminados en 0

('\0').

#include <stdio.h>
char* mensaje = "hola";
int main ()
{
char cadena[10];
char* p = cadena;
unsigned int longitud = 0;
puts(mensaje);
scanf("%9s", cadena);
while (*p != 0) {
longitud++;
p++;
}
printf("Longitud: %d\n", longitud);
return 0;
}

9

Funciones

• Un ejemplo.

int Suma (int x, int y)
{
return x+y;
}
• Paso de parámetros.

void Swap (int* a, int* b)
{
int temporal;
temporal = *a;
*a = *b;
*b = temporal;
}
int main ()
{
int x = 4;
int y = 5;
Swap(&x, &y);
/* x = 5, y = 4 */
}

• La función main()

int main (int argc, char* argv[], char* env[])
{
int i;
for (i = 0; i < argc; i++) puts(argv[i]);
for (i = 0; env[i]; i++) puts(env[i]);
return 0;
}

10

Ejercicio

#ifndef _Pila_
#define _Pila_
/* Tipos. */
typedef enum {Pila_OK, Pila_Error}
Pila_CodigoRetorno;
typedef struct Pila_Nodo {
int fElemento;
struct Pila_Nodo* fAnterior;
} Pila_Nodo;
typedef struct {
Pila_Nodo* fCima;
} Pila;
/* Funciones. */
Pila* Pila_Crear ();
Pila_CodigoRetorno Pila_Introducir (Pila* pila,
int elemento);
Pila_CodigoRetorno Pila_Sacar (Pila* pila,
int* elemento);
int Pila_EsVacia (Pila* pila);
void Pila_Destruir (Pila* pila);
#endif

11

Mejoras (no OO) introducidas por C++ (1)

• Referencias.

int val = 10;
int& ref = val;
int& ref2; // Error !

void Swap (int& x, int& y) {
int tmp = x;
x = y;
y = tmp;
}
int main () {
int x = 5; int y = 7;
Swap(x, y);
return 0;
}

• Comentario de línea: //
• Constantes y declaraciones de variables.

const int LONGITUD = 4; // En C antiguo => #define LONGITUD 4
void f ()
{
int x;
x = 23;
cout << x << endl;
int y = 1;
cout << y << endl;
}

• Tipos enumerados.

enum Color {rojo = 0, amarillo = 8, azul = 16};

12

Mejoras (no OO) introducidas por C++ (2)

• Sobrecarga de funciones (y operadores).

void print (int entero);
void print (const char* cadena);
void print (double real);
print(2);
print("hola");
print(1.0);
• Argumentos por defecto.

void print (int valor, int base=10);
void f()
{
print(31);
print(31, 10);
print(31, 16);
}

• Asignación de memoria dinámica => operadores new y

delete.

int* x = new int(2);
int* y = new int[10];
delete x;
delete []y;

• Los prototipos de función son obligatorios.
• Se puede hacer inlining de funciones.

inline void f (int i) { cout << i << endl; }

13

Mejoras (no OO) introducidas por C++ (y 3)

• Tipo bool.

• Posibles valores true (1) y false (0).

• Namespaces.

// Fichero de especificación.
namespace Libreria {
typedef enum {uno, dos, tres} Tipo;
double Funcion (const char* str);

}

// Fichero de implementación.
double Libreria::Funcion (const char* str) { /* ... */ }

// Uso.
double d = Libreria::Funcion(unaCadena);

using namespace Libreria;
using namespace Libreria::Funcion;

14

Clases (1)

• Ejemplo:

class Fecha {
public:
void Establecer (unsigned int dia, unsigned mes,
unsigned int anho);
void Obtener (unsigned int& dia, unsigned int& mes,
unsigned int& anho) const;
void Imprimir ();
private:
unsigned int fDia, fMes, fAnho;
};

void Fecha::Obtener (unsigned int& dia, unsigned int& mes,
unsigned int& anho)
{
dia = fDia; mes = fMes; anho = fAnho;
}

• Especificadores de acceso: private (por defecto), public y

protected.

• Constructores: constructor por defecto, constructor copia y

constructores adicionales.

class Fecha {
// ...
public:
Fecha (unsigned int dia, unsigned int mes,
unsigned int anho);
Fecha (const char* cadena);
Fecha (); // Constructor por defecto.
Fecha (const Fecha& fecha); // Constructor copia.
};

15

Clases (2)

• ... continuación del ejemplo.
Fecha miCumple(19, 4, 1998);
Fecha miCumple2("19 Abril 1998");
Fecha miCumple3; // Constructor por defecto.
Fecha* miCumple4 = new Fecha(19, 4, 1998);
Fecha miCumple5 = miCumple2; // Inicialización (c. copia).
Fecha miCumple6;
miCumple6 = miCumple5; // Es una asignación.

void f (Fecha fecha);
f(miCumple);

void f(const Fecha& fecha);
f(miCumple);

• Destructor: ÑombreDeLaClase()

class X {
public:
// ...
~X ();
};

{
X x;
X* x2 = new X;
X* x3 = new X[10];
delete x2;
delete []x3;
}

16

Clases (3)

• Puntero this.

class X {
public:
// ...
void Metodo (int i) { this-> i = i; }
private:
int i;
};

• Miembros static.

#include <iostream>
using namespace std;
class Ejemplo {
public:
// ...
Ejemplo () { cuenta++; }
static int Cuantos () { return cuenta; }
private:
static int cuenta;
// ...
};
int Ejemplo::cuenta = 0;
int main ()
{
Ejemplo e1, e2;
cout << Ejemplo::Cuantos() << endl; // 2
return 0;
}

17

Clases (y 4)

• Clases utilidad (utility classes): todos los métodos/atributos

son static.

class LibreriaMatematica {
public:
static float Seno (float angulo);
static float Coseno (float angulo);
static float Tangente (float angulo);
// ...
};

float resultado = LibreriaMatematica::Seno(12.1);

• Las clases utilidad evitan el uso de funciones globales.

• Especificador const en métodos.
• Funciones, métodos y clases amigas.

class Ejemplo {
// ...
private:
int i;
friend void FuncionAmiga (Ejemplo& e