Beruflich Dokumente
Kultur Dokumente
Qu es C++?
Es un lenguaje de programacin...
De tipado esttico (static typing): Las comprobaciones de
tipos se realizan en tiempo de compilacin, no de ejecucin.
De tipado fuerte (strong typing): Las variables tienen
asociadas un tipo de datos, que define lo que se puede hacer.
De forma libre (free form): La posicin de los caracteres en la
pgina es irrelevante.
Multiparadigma: Soporta ms de un paradigma de
programacin, y la combinacin de los mismos.
Compilado: Es necesario convertirlo al cdigo de la mquina
para poder ejecutarlo.
De propsito general: Puede ser usado para realizar tareas
que no pertenecen a un dominio concreto.
De nivel intermedio: Incorporando caractersticas tanto de
bajo nivel (cercano a la mquina) como de alto nivel (cercano
al ser humano).
Independiente de la plataforma: Write once, compile
anywhere (WOCA)
3 / 136
Procedimental o funcional
Abstraccin de los datos
Orientada a objetos
Programacin genrica o metaprogramacin
5 / 136
La evolucin de C++
Excepciones
Plantillas o templates
1992: HP C++
Herencia mltiple
Clases abstractas
Funciones virtuales
Sobrecarga de operadores
Referencias
Clases. Herencia
STL
Espacios de nombres
2011: C++11
Expresiones lambda
Tipos automticos
Hilos de ejecucin (threading)
6 / 136
7 / 136
Caractersticas de C++
9 / 136
Simples
Booleanos
bool
Enteros (o decimales en coma fija)
char, short, int, long
Enumeraciones
enum
Decimales en coma flotante
float, double, long double
Estructurados
Estructuras de datos: arrays, strings (zero-terminated), union
Definicin de objetos: class, struct
Direcciones
Punteros (*)
Referencias (&)
10 / 136
11 / 136
Punteros
#include <cstdlib>
#include <cstdio>
int main() {
char ch = 'c';
char *chptr = &ch;
int i = 20;
int *intptr = &i;
float f = 1.20000;
float * fptr = &f;
const char * ptr = "I am a string";
printf("\n [%c], [%d], [%f], [%c], [%s]\n",
*chptr, *intptr, *fptr, *ptr, ptr);
return EXIT_SUCCESS;
}
12 / 136
Punteros
#include <cstdlib>
#include <cstdio>
int main() {
char ch = 'c';
char *chptr = &ch;
int i = 20;
int *intptr = &i;
float f = 1.20000;
float * fptr = &f;
const char * ptr = "I am a string";
printf("\n [%c], [%d], [%f], [%c], [%s]\n",
*chptr, *intptr, *fptr, *ptr, ptr);
return EXIT_SUCCESS;
}
13 / 136
Referencias a variables
#include <cstdlib>
#include <cstdio>
void swap(int & i, int & j) {
int tmp = i;
i = j;
j = tmp;
}
int main() {
int x = 0;
int y = 1;
swap(x,y);
printf("x=%d, y=%d\n", x, y);
int & a = x;
int b = x;
a = 5;
b = 7;
printf("x=%d, y=%d, a=%d, b=%d\n", x, y, a, b);
return EXIT_SUCCESS;
}
14 / 136
Referencias a variables
#include <cstdlib>
#include <cstdio>
void swap(int & i, int & j) {
int tmp = i;
i = j;
j = tmp;
}
int main() {
int x = 0;
int y = 1;
swap(x,y);
printf("x=%d, y=%d\n", x, y);
x=1, y=0
int & a = x;
x=5, y=0, a=5,
int b = x;
a = 5;
b = 7;
printf("x=%d, y=%d, a=%d, b=%d\n", x, y, a, b);
return EXIT_SUCCESS;
b=7
15 / 136
Puntero:
Identifican un contenido ubicado en un lugar de la memoria.
Se define aadiendo el carcter '*' a un tipo de dato.
char * pChar; int * pInt; Shape * pShape;
Se usa por convenio el valor NULL (igual a 0L) para no sealar
ninguna direccin significativa.
Referencia:
No es una variable
Es un alias (o nombre alternativo) de un objeto o dato que ya
existe.
Se define aadiendo el carcter '&' a un tipo de dato.
char & rChar; int & rInt; Shape & rShape;
No siempre necesitan ocupar memoria.
No pueden ser NULL.
No pueden ser modificadas.
A menudo son implementados con punteros por parte de los
compiladores, pero no son lo mismo.
16 / 136
Sobrecarga de funciones
17 / 136
Expresiones y operadores
18 / 136
Operadores en C++
19 / 136
Operadores en C++
20 / 136
{
{ return y; }
long double LD; }
long double LD; }
{
{ return z; }
long double LD; }
EspacioA::LD = 1.1;
EspacioA::f(1.1);
EspacioB::LD = 1.0;
EspacioB::f(1.1);
EspacioB::X = 1
EspacioA::Sub1::LD = 3;
EspacioA::Sub2::LD = 4;
EspacioB::Sub1::LD = 5;
//
//
//
//
//
//
//
//
::EspacioA::LD = 1.1;
::EspacioB::LD = 1.0;
22 / 136
// Espacio
// Estructuras
// Clases
// Uniones
...
int func(int x, int y, int z) {
if (x == 0)
goto x;
return (x + y + z);
x:
return (1 + y + z);
// Etiquetas
23 / 136
24 / 136
26 / 136
Pensar en objetos
Pensar en objetos
28 / 136
30 / 136
31 / 136
32 / 136
Clase:
Es la definicin abstracta de un tipo de objeto.
Slo tiene sentido en tiempo de programacin.
Definen el aspecto que tendrn los objetos que se creen
durante la ejecucin del programa.
Son una especie de molde o plantilla.
Definen qu atributos tendrn los objetos, y las cosas que se
pueden hacer con l.
Objeto o instancia:
Suponen la concrecin del concepto de clase en un elemento
concreto con caractersticas determinadas.
Existen durante la ejecucin del programa, e interaccionan
entre ellos. Nacen, viven, se comunican y mueren.
El valor concreto de cada atributo es nico e independiente
para cada objeto..
Los conceptos de clase y objetos son anlogos a los de tipo
de datos y variable: definida una clase, podemos crear objetos
de esa clase.
34 / 136
35 / 136
name
layer
color
alignment
36 / 136
class Shape {
public:
Shape();
~Shape();
void draw();
double x, y;
Implementacin equivalente en C
};
37 /37136
/ 70
Constructores
Destructores
39 / 136
Gestin de recursos
40 / 136
Herencia
Herencia Simple
Herencia Mltiple
41 / 136
Herencia simple
class Shape {
public:
Shape(const char * n) : name(n) { }
const char * getName() const { return name; }
protected:
const char * name;
};
class Rectangle : public Shape {
public:
Rectangle(int h, int w);
inline int getHeight() const { return height; }
inline int getWidth() const { return width; }
private:
int height;
int width;
};
Rectangle::Rectangle(int h, int w) :
Shape("Rectangle"), height(h), width(w) { }
42 / 136
name
layer
class Circle : public Shape {
public:
Circle(int r) : Shape("Circle"), radius(r) { }
inline int getRadius() const { return radius; }
virtual draw(int x, int y);
private:
int radius;
};
color
alignment
radius
43 / 136
Implementacin de la herencia
Implementacin en C++
class Shape {
public:
Shape();
~Shape();
void draw();
double x, y;
Implementacin equivalente en C
};
class Box : public Shape {
public:
Box();
~Box();
double area();
double h, w;
};
44 /44136
/ 70
Herencia mltiple
class Shape {
public:
Shape(const char * n) : name(n) { }
const char * getName() const { return name; }
protected:
const char * name;
};
class Storage {
public:
Storage(int type);
};
class Rectangle : public Shape, public Storage {
public:
Rectangle(int h, int w);
inline int getHeight() const { return height; }
inline int getWidth() const { return width; }
private:
int height;
int width;
};
Rectangle::Rectangle(int h, int w) :
Shape("Rectangle"), Storage(1), height(h), width(w) { }
45 / 136
Herencia mltiple
class Shape {
public:
Shape(const char * n);
inline const char * getName() const { return name; }
inline int getLayer() const { return layer; }
inline char getColor() const { return color; }
void draw(int x, int y);
protected:
const char * name;
int layer;
char color;
};
class Storage {
public:
bool save(int len, const char * buffer);
bool load(int maxlen, char * buffer);
private:
FILE * file;
};
class Circle : public Shape, public Storage {
public:
Circle(int r) : Shape("Circle"), radius(r) { }
inline int getRadius() const { return radius; }
virtual draw(int x, int y);
private:
int radius;
};
name
layer
color
alignment
file
radius
46 / 136
Implementacin equivalente en C
typedef struct ShapeT {
double x, y;
} Shape;
void Shape_new(Shape * this);
void Shape_delete(Shape * this);
void Shape_draw(Shape * this);;
typedef struct StorageT {
FILE * file;
} Storage;
int Storage_save(Storage *this, int len, const
char * buffer);
int Storage_load(Storage *this, int maxlen,
char * buffer);
typedef struct BoxT {
Shape shape;
Storage storage;
double h, w;
} Box;
void Box_new(Box* this);
void Box_delete(Box* this);
double Box_area(Box * this);
47 /47136
/ 70
48 / 136
Shape
Shape
Shape
Shape
Shape
Shape
int main() {
Rectangle r1, r2;
Circle c1, c2, c3;
Triangle t1;
Shape * shapes[] = { &r1, &c1, &t1, &r2, &c2, &c3};
for (int i=0; i<sizeof(shapes)/sizeof(Shape*); ++i) printf("%s\n", shapes[i]>getName());
return EXIT_SUCCESS;
}
49 / 136
Funciones virtuales
#include <cstdlib>
#include <cstdio>
class Shape {
public:
virtual const char * getName() const = 0;
};
class Rectangle : public Shape {
public:
virtual const char * getName() const { return "Rectangle"; }
};
class Circle : public Shape {
public:
virtual const char * getName() const { return "Circle"; }
};
class Triangle : public Shape {
public:
virtual const char * getName() const { return "Triangle"; }
};
int main() {
Rectangle r1, r2;
Circle c1, c2, c3;
Triangle t1;
Shape * shapes[] = { &r1, &c1, &t1, &r2, &c2, &c3};
for (int i=0; i<sizeof(shapes)/sizeof(Shape); ++i) printf("%s\n", shapes[i]->getName());
return EXIT_SUCCESS;
}
50 / 136
Funciones virtuales
#include <cstdlib>
#include <cstdio>
class Shape {
public:
virtual const char * getName() const = 0;
};
class Rectangle : public Shape {
public:
virtual const char * getName() const { return "Rectangle"; }
};
class Circle : public Shape {
public:
virtual const char * getName() const { return "Circle"; }
};
class Triangle : public Shape {
public:
virtual const char * getName() const { return "Triangle"; }
};
Rectangle
Circle
Triangle
Rectangle
Circle
Circle
int main() {
Rectangle r1, r2;
Circle c1, c2, c3;
Triangle t1;
Shape * shapes[] = { &r1, &c1, &t1, &r2, &c2, &c3};
for (int i=0; i<sizeof(shapes)/sizeof(Shape); ++i) printf("%s\n", shapes[i]->getName());
return EXIT_SUCCESS;
}
51 / 136
protected:
const char * name;
int layer;
char color;
};
name
layer
color
alignment
52 / 136
vptr
type_info
name
draw
type_info
draw
layer
color
alignment
vtable
53 / 136
Implementacin equivalente en C
class Virt {
int a, b;
virtual void foo(int);
};
54 /54136
/ 70
vptr
name
layer
color
alignment
file
radius
55 / 136
56 / 136
Herencia virtual
Herencia no virtual
Herencia virtual
57 / 136
58 / 136
59 / 136
El modificador const
int main() {
int var = 1;
const int const_var = 1;
int * pnt_to_var = &var;
const int * pnt_to_const_var = &var;
int * const const_pnt_to_var = &var;
var = 2;
const_var = 2; // ERROR
*pnt_to_var = 2;
*pnt_to_const_var = 2; // ERROR
*const_pnt_to_var = 2;
pnt_to_var = NULL;
pnt_to_const_var = NULL;
const_pnt_to_var = NULL; // ERROR
return EXIT_SUCCESS;
}
61 / 136
Mtodos constantes
class A {
public:
A() : state(0) {
}
void setState(int new_state) {
state = new_state;
}
int getState() const {
return state;
}
private:
int state;
};
int main() {
A a;
a.setState(5);
a.getState();
const A b;
b.setState(5); // Error
b.getState();
return EXIT_SUCCESS;
}
62 / 136
63 / 136
64 / 136
Mtodos constantes
class A {
public:
A() : pointer(NULL) {
}
A(const A & other) : pointer(other.pointer) {
}
void setPointer(int * new_pointer) {
pointer = new_pointer;
}
void setPointer(int & new_pointer) {
pointer = &new_pointer;
}
int * getPointer() {
return pointer;
}
const int * getPointer() const {
return pointer;
}
private:
int * pointer;
};
int main() {
int val;
A a;
a.setPointer(&val);
a.setPointer(val);
a.getPointer();
*a.getPointer() = 5;
const A b = a;
b.setPointer(&val); // Error
b.setPointer(val); // Error
b.getPointer();
*b.getPointer() = 5; // Error
return EXIT_SUCCESS;
}
65 / 136
66 / 136
68 / 136
69 / 136
La clase agregada tiene una relacin dbil con la clase que contiene la
agregacin. La destruccin de un objeto de la clase contenedora no implica
la destruccin de los objetos que estn agregados por el mismo.
Ejemplo: Yo tengo una relacin con mis amigos, pero no les poseo.
70 / 136
71 / 136
72 / 136
73 / 136
74 / 136
public IDrivable {
void SpeedUp(int value) { ... }
void Brake(int value) { ... }
void Turn(int value) { ... }
int NumDoors;
};
75 / 136
76 / 136
Fuente: http://design-patterns-with-uml.blogspot.com.ar/search/label/Abstract%20Factory%20Pattern
79 / 136
Fuente: http://design-patterns-with-uml.blogspot.com.ar/search/label/Abstract%20Factory%20Pattern
80 / 136
81 / 136
Usando composicin
82 / 136
Fuente: http://design-patterns-with-uml.blogspot.com.ar/search/label/Decorator%20Pattern
83 / 136
Fuente: http://design-patterns-with-uml.blogspot.com.ar/search/label/Decorator%20Pattern
84 / 136
Fuente: http://design-patterns-with-uml.blogspot.com.ar/search/label/Facade%20Pattern
85 / 136
Fuente: http://design-patterns-with-uml.blogspot.com.ar/search/label/Facade%20Pattern
86 / 136
Fuente: http://design-patterns-with-uml.blogspot.com.ar/search/label/Iterator%20Pattern
87 / 136
Fuente: http://design-patterns-with-uml.blogspot.com.ar/search/label/Iterator%20Pattern
88 / 136
89 / 136
Fuente: http://design-patterns-with-uml.blogspot.com.ar/search/label/Observer%20Pattern
90 / 136
Fuente: http://design-patterns-with-uml.blogspot.com.ar/search/label/Singleton%20Pattern
91 / 136
Fuente: http://design-patterns-with-uml.blogspot.com.ar/search/label/Singleton%20Pattern
92 / 136
Fuente: http://design-patterns-with-uml.blogspot.com.ar/search/label/State%20Pattern
93 / 136
Fuente: http://design-patterns-with-uml.blogspot.com.ar/search/label/State%20Pattern
94 / 136
95 / 136
Fuente: http://design-patterns-with-uml.blogspot.com.ar/search/label/Strategy%20Pattern
96 / 136
97 / 136
Fuente: http://design-patterns-with-uml.blogspot.com.ar/search/label/Template%20Pattern
98 / 136
La Programacin Genrica
La Programacin Genrica
101 / 136
Templates: Singleton
template<typename T>
class Singleton {
public:
Singleton(T & instance) {
sfpInstance = &instance;
}
~Singleton() {
sfpInstance = 0L;
}
static T & getInstance()
return *sfpInstance;
}
private:
static T * sfpInstance;
};
template<typename T> T * Singleton<T>::sfpInstance(0L);
102 / 136
104 / 136
if (SameType<SomeThirdPartyType, int>::result)
{
// ... codigo optimizado, asumiendo que el tipo es un entero
}
else
{
// ... codigo defensivo que no hace ninguna suposicion sobre el tipo
105 / 136
TMP: Recursin
template <unsigned n>
struct factorial
{
enum { value = n * factorial<n-1>::value };
};
template <>
struct factorial<0>
{
enum { value = 1 };
};
int main() {
// Como los calculos se realizan en tiempo de compilacion,
// se puede usar para cosas como el tamao de los arrays
int array[ factorial<7>::value ];
}
106 / 136
107 / 136
108 / 136
109 / 136
110 / 136
112 / 136
113 / 136
114 / 136
115 / 136
116 / 136
117 / 136
118 / 136
119 / 136
public IDrivable {
void SpeedUp(int value) { ... }
void Brake(int value) { ... }
void Turn(int value) { ... }
int NumDoors;
};
IDrivable auto = new Car();
Car.SpeedUp(15);
120 / 136
121 / 136
int main ()
{
// continuation which displays argument
// when called
struct disp_cont: public continuation {
virtual void operator() (unsigned n) const {
std::cout << n << std::endl;
};
} dc;
// continuation which multiplies argument by 2
// and displays it when called
struct mult_cont: public continuation {
virtual void operator() (unsigned n) const {
std::cout << n * 2 << std::endl;
};
} mc;
fact_cps(4, dc); // prints 24
fact_cps(5, mc); // prints 240
return 0;
}
Factorial Functor
Fuente: http://stackoverflow.com/questions/1981400/functional-programming-in-c
124 / 136
Espacios de nombres
Sobrecarga de funciones
Caractersticas de C++ con un coste adicional bajo:
Inicializacin/Conversin/Terminacin de variables
Herencia mltiple
126 / 136
Los compiladores tienen cierta libertad para elegir el tamao de los tipos
de datos comunes
La direccin de retorno.
129 / 136
130 / 136
131 / 136
Tipos de normas
Tipo: Programacin Defensiva
Descripcin: Cuanto ms protegido est el software ante situaciones inesperadas, por
improbables que sean, mejor. Esto mejora adems la mantenibilidad del software.
Ejemplo: sentencias switch (6-4-3), no modificacin de contadores en los bucles for (6-53), no dar acceso a variables internas (9-3-2), tener en cuenta los errores (0-3-2)
Consejo: Sea moderadamente flexible, pero justifique bien las excepciones.
132 / 136
Preguntar es gratis!
Algunos enlaces
http://c.conclase.net/curso/
http://es.cppreference.com/w/cpp
http://www.mindview.net/Books/TICPP/ThinkingInCPP2e.html
http://arco.esi.uclm.es/~david.villa/pensar_en_C++/
https://bitbucket.org/crysol_org/pensarenc/overview
http://www.learncpp.com/cpp-tutorial/
http://www.cplusplus.com/doc/tutorial/
http://www.zator.com/Cpp/
http://www.youtube.com/playlist?list=PL4A486BBFC5AD733B
http://mazyod.com/category/software-engineering/
http://www.cdsonline1.co.uk/EmailImages/mae/MAE09_speaker_presentations/MAE2009.ppt
http://assembly.ynh.io/ ( https://github.com/ynh/cpp-to-assembly )
http://msdn.microsoft.com/en-us/magazine/jj553512.aspx
http://www.open-std.org/jtc1/sc22/wg21/docs/ESC_San_Jose_98_401_paper.pdf
http://design-patterns-with-uml.blogspot.com.ar
http://en.wikipedia.org/wiki/Software_design_patterns
http://www.eventhelix.com/realtimemantra/patterns/
135 / 136