PDF de programación - Tema 1. Introducción a C++

Introducción a C++.
Asignatura Estructuras de Datos
Curso 2017/2018
ETSISI UPM

C vs. C++
 C es un lenguaje procedural  el elemento central del

son las funciones.
 Cualquier función se puede comunicar con las demás a
(valor o

través de variables globales, parámetros
referencia), y valores de retorno

 C++ es un lenguaje orientado a objetos  el elemento
central son los objetos que contienen datos (variables
miembro) y funciones que permiten manipularlos y
trabajar con ellos.
 La definición de los objetos se realiza a través de clases
 Existen dos ficheros:

 *.h  contiene la definición de la clase
 *.cpp  contiene la definición de las funciones de la clase

2

Tipos de Datos C++

 Tipos básicos:

 Booleano (bool).
 Carácter (char).
 Entero (int).
 Punto flotante (ej. double, long, float).

 Definidos por el usuario (enum).
 A partir de los anteriores, se pueden construir:

 tipo punteros (ej. int *)
 tipo array (ej. char [])
 tipo referencia (ej. double&)
 estructuras y clases.

3

Constantes literales

 bool: true, false
 char: ‘a’,
 string: “hola”
 int: 15, 15u (unsigned), 017 (octal), 0xf (hexadecimal)
 long: 15L
 float: 15.0F
 double: 15.0, 3e2

4

Declaración de variables

 <Tipo> <identificador> (=valor inicial)

char caracter = '.';
int numerito = 9;

 Constantes: palabra const

const int TAM_MAXIMO = 50;

 Identificadores:

 Han de comenzar por carácter alfabético
 Se distingue entre mayúsculas y minúsculas.
 No puede coincidir con una palabra reservada

5

Palabras reservadas

6

Ámbito de variables

 Locales: definidas en su lugar utilización.

 Operador de resolución de ámbito ::

 Ámbito de una variable o constante es el bloque donde se ha declarado.
 Una declaración introduce un nombre dentro de un ámbito, y sólo se

puede usar en este ámbito.
 Globales: definidas fuera del cuerpo de las funciones y están disponibles

para todo el programa.

7

Operadores (I)

Aritméticos
a + b
a - b
a * b
a / b
a % b (módulo)
a++ (post incremento)
++a (pre incremento)
a-- (post decremento)
--a (pre decremento)
Operadores de bits
a & b
a ^ b

a | b
a <<b

Lógicos
a && b (AND)
a || b (OR)
!a (NOT)

Relacionales
a == b (igualdad)
a != b (desigualdad)
a > b (mayor que)
a < b (menor que)
>= (mayor o igual que)
<= (menor o igual que)

~a
a>>b

Manipulan las expresiones bit a bit.
Solo se pueden aplicar a expresiones
enteras

8

Operadores (II)

Asignación
var = exp
var += exp
Equivale a: var = var + exp

=

Todos los operadores binarios
(excepto && y ||) pueden
combinarse con el operador de
asignación (+=, *=, -= …)

Referencia
[] (miembro de array)
. (miembro de clase)
-> (miembro cuando se trabaja con punteros)
&v (dirección de memoria de v)
*p (lo apuntado por p)
:: (ámbito)

Entrada y salida
cin >> var
cout << var

9

Estructura de un programa en C++

#include <iostream>
using namespace std;

int main() {

cout << "Hello World!!!" << endl;
// escribe Hello World!!!

return 0;

}

Ejemplos de directivas:

#include <ctime>
#include <cstdlib>
#include <string>

Directivas de inclusión
Espacios con nombre
Espacio global

Comentarios

10

Concepto de CLASE
Las clases de C++ son una generalización de las estructuras de C
struct Alumno {

int numMatricula;
char nombre[41];

}
Alumno alu1 = {3041, “Antonio”}, alu2 = {2054, “David”};

Operador de resolución

de visibilidad

Alumno.cpp

Alumno.h

#include <string>
using namespace std;
#ifndef ALUMNO_H_
#define ALUMNO_H_
class Alumno {
public:

Variables
miembro

int numMatricula;
string nombre;
Alumno(int num,string nom);
~Alumno();

};
#endif /* ALUMNO_H_ */

• Constructor
• Destructor
• Otras funciones miembro

}

Alumno a1 (3041, "Antonio");
Alumno a2 (2054, "David");
cout << "nombre del primer alumno " << a1.nombre << endl;
cout << "nombre del segundo alumno " << a2.nombre <<endl;

11

#include "Alumno.h"
#include <iostream>
using namespace std;
//constructor
Alumno::Alumno(int num, string nom){

numMatricula = num;
nombre = nom;

}
//destructor
Alumno::~Alumno() {
}

Prueba.cpp

#include "Alumno.h"
#include <iostream>
using namespace std;
int main(void){
//se crean objetos de la clase alumno

Memoria Dinámica
 Datos estáticos: su tamaño y forma es constante

durante la ejecución de un programa y se determinan
en tiempo de compilación. Ej. arrays
int numbers[5];
int numbersprima[] = {10,20,30};
for (int n=0; n<3; n++)
cout << numbersprima[n] << ", ";
cout << endl;

 Datos dinámicos: su tamaño y forma puede ser variable

a lo largo de un programa, se crean y destruyen en
tiempo de ejecución  se asigna memoria según se va
necesitando. Ej. punteros

12

Memoria Dinámica
 PUNTERO: nos permite referenciar datos dinámicos.

Es una dirección de memoria
 Variable apuntadora
 Variable apuntada (anónima o referenciada)

Declaración de punteros:

typedef int * PtrInt;
PtrInt mypointer;

O bien, directamente

int * mypointer;

13

Memoria Dinámica
 PUNTERO
Gestión de memoria dinámica:

#include <iostream>
using namespace std;
int main () {

int * mypointer;
//reserva de memoria de forma dinámica
mypointer = new int;
//inicialización
*mypointer = 10;
cout << “mypointer is " << *mypointer << '\n';
//se libera memoria
delete mypointer;

}

 Tras la declaración del puntero
posición de memoria

indefinida

mypointer

(memoria estática)

basura

basura

 Tras el NEW
mypointer
0xdir

memoria dinámica

basura

 Tras la asignación
mypointer
0xdir

memoria dinámica

10

14

Memoria Dinámica

 PUNTEROS
Gestión de memoria dinámica :

#include "Alumno.h"
#include <iostream>
using namespace std;

//constructor
[…]
//destructor
[…]

#include "Alumno.h"
#include <iostream>
using namespace std;
int main(void){

Alumno.cpp

Prueba.cpp

 Tras la declaración del
puntero antes del NEW

pAlumno
basura

posición de memoria

indefinida

basura

 Tras el NEW y la inicialización

(opcional) del objeto Alumno
posición de memoria

Alumno *pAlumno;
//reserva memoria de forma dinámica y creación objeto Alumno
pAlumno = new Alumno(1111, "Pepe");
cout << "matricula alumno " << pAlumno->numMatricula << endl;
cout << “nombre alumno " << pAlumno->nombre << endl;

pAlumno

0xdir

//se libera memoria
delete pAlumno;
}

dinámica

:Alumno
Nombre = Pepe

numMatricula = 1111

15

Memoria Dinámica
 PUNTERO
Operaciones con punteros:

#include <iostream>
using namespace std;
int main () {

int myvar;
int * mypointer;
mypointer = &myvar;
*mypointer = 10;
cout << "myvar is " << myvar << '\n';

}

memoria estática

0x 28FEE0(16

10 (10

0x 28FED0
0x 28FED4
0x 28FED8
0x 28FEDC
0x 28FEE0
…

mypointer

myvar

Operador de dirección
(address-of operator)

Operador de indirección
(dereference operator)

16

Memoria Dinámica
 PUNTERO
Operaciones con punteros:

está

Suponiendo que mypointer
en la
dirección de memoria 0x28FED8, es posible
comprobar que el contenido de mypointer es
la
0x28FEE0
de memoria
(dirección de la variable myvar).

dirección

Debug con Eclipse

El contenido de la variable myvar es
0x0A000000 que en decimal es 10.

17

Memoria Dinámica
 PUNTEROS

Operaciones con punteros:

Alumno.cpp

p1

Prueba.cpp

Alumno1
numMatricula = 3041
nombre = Antonio

#include "Alumno.h"
#include <iostream>
using namespace std;

#include "Alumno.h"
#include <iostream>
using namespace std;
//constructor
Alumno::Alumno(int num, string nom){

numMatricula = num;
nombre = nom;

}
//destructor
Alumno::~Alumno() {
}

• p1 es la dirección de un objeto alumno

• *p1 es un objeto alumno

• (*p1).nombre es una variable miembro

• p1->nombre es una variable miembro

int main(void){
//se crean objetos de la clase alumno
Alumno a1 (3041, "Antonio");
Alumno a2 (2054, "David");
cout << "nombre del primer alumno " << a1.nombre << endl;
cout << "nombre del segundo alumno " << a2.nombre << endl;

Alumno *p1, *p2;
p1 = &a1;
p2 = &a2;
cout << "matricula primer alumno " << p1->numMatricula << endl;
cout << "matricula segundo alumno " << p2->numMatricula << endl;
18

}

Parámetros por Referencia
 Tipos no punteros

#include <iostream>
using namespace std;
void duplicate (int &a, int &b, int &c);
int main(void){
int x=1, y=3, z=7;
duplicate (x, y, z);
cout << "x=" << x << ", y=" << y << ", z=" << z << endl;
}
void duplicate (int &a, int &b, int &c) {
a*=2;
b*=2;
c*=2;

}

19

Parámetros por Referencia
 Tipos punteros

void cambiarValorObjetoApuntado(Alumno *p, Alumno *newp);
int main(void){
//se crean objetos de la clase alumno
Alumno a1 (3041, "Antonio");
Alumno a2 (2054, "David");
Alumno *pAlumno1, *pAlumno2;
pAlumno1 = &a1; pAlumno2 = &a2;
cout << "matricula primer alumno " << pAlumno1->numMatricula << endl;
cout << "matricula segundo alumno " << pAlumno2->numMatricula << endl;
cambiarValorObjetoApuntado(pAlumno1, pAlumno2);
cout << "matricula primer alumno " << pAlumno1->numMatricula << endl;
}
//se pasa por valor (una copia) la dirección de memoria a la que apunta p
//se pasa por referencia el objeto apuntado
void cambiarValorObjetoApuntado(Alumno *p, Alumno *newp){
p->numMatricula = 0;
p = newp; //No surte efecto. El valor de la dirección NO se modifica
}

pAlumno1

p

pAlumno2

pnew

p

pAlumno1

Alumno1
3041
3041
Antonio
Antonio

Alumno2

2054
David

Alumno1

0

Antonio

20

Parámetros por Referencia
 Tipos punteros

void cambiarDireccionObjetoApuntado(Alumno *&p, Alumno *newp);
int main(void){
//se crean objetos de la clase alumno
Alumno a1 (3041, "Antonio");
Alumno a2 (2054, "David");
Alumno *pAlumno1, *pAlumno2;
pAlumno1 = &a1; pAlumno2 = &a2;
cout << "matricula primer alumno " << pAlumno1->numMatricula << endl;
cout << "matricula segundo alumno " << pAlumno2->numMatricula << endl;
cambiarDireccionObjetoApuntado(pAlumno1, pAlumno2);
cout << "matricula primer alumno " << pAlumno1->numMatricula << endl;
}
//se pasa por referencia la dirección de memoria a la que apunta p
void cambiarDireccionObjetoApuntado(Alumno *&p, Alumno *newp){
p = newp; //Sí surte efecto. El valor de la dirección se modifica
}

p/pAlu