Charla C++

Qué es C++
Fernando Farias
fernando.farias@globallogic.com
Fuentes:
➔ Software for infrastructure [Stroustrup] http://www.stroustrup.com/Software-for-infrastructure.
pdf
➔ Going Native 2012 Day 1 Keynote [Stroustrup] http://youtu.be/0iWb_qi2-uI

3 CONFIDENTIAL
Agenda
● Qué es C++
● Estilos de programación
● Qué buscamos
● Código palido
● Plan de acción
● Recursos
● Manejadores
● Moviendo recursos
● Estilo C++
● ¿ Preguntas ?
01

CONFIDENTIAL©2015 GlobalLogic Inc.
Es lo mismo que C !!!
Muy bajo nivel !!!
Lenguaje para
sistemas embebidos
Punteros y fallas de
núcleo
Que es C++
Colección de
características al azar
Lenguaje híbrido
Lenguaje de programación de abstracciones livianas

Que es C++
Realidades:
● Nada sirve para todo - X es lo mejor ? en qué contexto ?
● Hardware - un 50% de overhead se traduce en otra granja de servidores
● Confiabilidad - aplicaciones médicas, aeroespaciales, financieras
● Eficiencia - velocidad de procesado, poder de cómputo
● Time to market - esfuerzo para llegar a feature complete, y sin bugs
● Nivel del desarrollador - junior o senior

6 CONFIDENTIAL
Agenda
● Qué es C++
● Qué buscamos
● Código palido
● Plan de acción
● Recursos
● Manejadores
● Estilo C++
● ¿ Preguntas ?
01

Estilos de programación
● Estilo C - macros, void*, acceso directo a recursos
● Estilo C++85 - classes, interfaces, objetos
● OO - classes, herencia multiple, polimorfismo
● Estilo C++ - Templates, programación genérica
● Estilo C++11 - Metaprogramming, algoritmos y conceptos

8 CONFIDENTIAL
Agenda
● Qué es C++
● Qué buscamos
● Código palido
● Plan de acción
● Recursos
● Manejadores
● Estilo C++
● ¿ Preguntas ?
01

Qué buscamos
● Fácil para humanos y también para herramientas de humanos
● Mantenibilidad, rectitud, exactitud, expresión
● Modularidad, distribuible
● Manejo efectivo de los recursos
● Thread safe, a menos que existan razones para no
● Eficiencia, estructuras de datos compactas
● Portabilidad, a menos que existan razones para no
● Síntesis integrada, que todo trabaje al unísono
● Estándares y guías : estilo

10 CONFIDENTIAL
Agenda
● Qué es C++
● Qué buscamos
● Código pálido
● Plan de acción
● Recursos
● Manejadores
● Estilo C++
● ¿ Preguntas ?
01

Código pálido
// base : memory to be stored
// nmemb : number of elements in memory
// size : number of bytes in an element
// compar : comparison function
void qsort(void *base, size_t nmemb, size_t size, int(*compar)(const void*, const void*));
void f(char* arr, int m, double* darr, int n) {
qsort(arr, m, sizeof(char*), cmpstringp);
qsort(darr, n, sizeof(double), compare_double);
}
Código pálido = Ineficiente, propenso a errores.
● array que no conoce el número de elementos contenidos
● no sabe como comparar double
● no conoce el tamaño de un double
● sistemáticamente descarta información de utilidad
● llamada a función indirecta es ineficiente
● previene optimizaciones como inline
● necesita más código, genera más oportunidades para bugs
● por eficiencia ?! porque es cool ?! nivel de bits !?

12 CONFIDENTIAL
Agenda
● Qué es C++
● Qué buscamos
● Código pálido
● Plan de acción
● Recursos
● Manejadores
● Estilo C++
● ¿ Preguntas ?
01

Plan de Accion
● Mantener las interfaces simples
void sort(Container&)
● Mantener las llamadas simples
vector<string> vs;
sort(vs);
● Performance no se compromete
std::sort es más rápido que qsort por grandes factores
● Validación estática de tipos de datos
● No leaks ( y sin gc )

Plan de Accion
Enfocarse en las interfaces
● sin especificar
void increase_speed(double); // m/s ? km/h ?
rectangle(int, int, int, int); // top-down ? bottom-right ?
● bien especificadas
void increase_speed(Speed);
Rectangle(Point, Point);
● siempre usar interfaces con tipos de datos precisos

15 CONFIDENTIAL
Agenda
● Qué es C++
● Qué buscamos
● Código pálido
● Plan de acción
● Recursos
● Manejadores
● Estilo C++
● ¿ Preguntas ?
01

Recursos
void f(const char* p) {
FILE* f = fopen(p, "r"); // adquisicion de f
// ...
// usando f
// ..
fclose(f); // liberar f
}
● el código que usa f puede ser muy complejo y olvidar de liberar f
● cualquier excepción puede olvidar liberar f
● el manual dice “todo fopen debe tener su fclose”, pero los compiladores no leen
manuales, y muchos programadores tampoco
Uso Ingenuo

Recursos
void f(const char* p) {
FILE* f = 0;
try {
f = fopen(p, "r"); // adquirir
// usar f
} catch(...) {
if (f) fclose(f);
throw;
}
if (f) fclose(f); // release f
}
● más largo
● duplica código
● incluso más propenso a errores
Arreglo Ingenuo

Recursos
class File_handle {
File* p;
public:
File_handle(const char* pp, const char* r) {
p = fopen(pp, r);
if (p==0)
throw File_error{pp, r};
}
~File_handle() {
flose(p);
}
}
void f(string s) {
File_handle fh{s, "r"};
// usar fh
}
● Liberará el recurso pase lo que pase
● Usamos RAII para memoria, locks, archivos, sockets, threads, y todo lo demas.
RAII - Resource Acquisition Is Initialization

19 CONFIDENTIAL
Agenda
● Qué es C++
● Qué buscamos
● Código pálido
● Plan de acción
● Recursos
● Manejadores
● Estilo C++
● ¿ Preguntas ?
01

Manejadores
void f(int n, int x) {
int* p = new Gadget{n}; // look i am a Java programmer !!! :)
// ...
if(x<100) throw std::run_time_error{"Weird!"}; // leak
if(x<200) return; // leak
// ...
delete p; // and i want my garbage collector !!! :(
}
Pregunta 1: ¿ y qué onda si le metemos un garbage collector ?
Respuesta: NO LEAKS !!!
Punteros Locales = poco saludables, inseguros contra excepciones

Manejadores
shared_ptr<Gadget> p { new Gadget{n} }; // manejar el puntero
// ...
if(x<100) throw std::run_time_error{"Weird!"}; // no leak
if(x<200) return; // no leak
// ...
}
● ¿ por qué un shared_ptr si no estamos compartiendo nada ?
Manejadores de Punteros

Manejadores
unique_ptr<Gadget> p { new Gadget{n} }; // manejar el puntero
// ...
// ...
}
● ¿ y por qué usar un puntero ?
Manejadores de Punteros Únicos

Manejadores
Gadget{n}; // crear el objeto
// ...
// ...
}
● Elegante.
● Simple.
● Efectivo.
Manejadores Puros

24 CONFIDENTIAL
Agenda
● Qué es C++
● Qué buscamos
● Código pálido
● Plan de acción
● Recursos
● Manejadores
● Estilo C++
● ¿ Preguntas ?
01

Move Semantics
Matrix* operator+(const Matrix&, const Matrix&);
Matrix &res = *(a+b);
● Poco entendible.
● Horrible al punto de inaceptable.
● … ¿ Quién hace el delete ?
Moviendo grandes datos

Move Semantics
Matrix& operator+(const Matrix&, const Matrix&);
Matrix res = a+b;
● Mucho mas entendible.
● Parece elegante.
● ¿ Quién hace el delete ?
● ¿ Cómo hace el delete ?
● ¿ Cómo se entera que tiene que hacer el delete ?
- segundo intento -

Move Semantics
void operator+(const Matrix&, const Matrix&, Matrix& result);
Matrix res = a+b; // error, la sobrecarga del operador ya no funciona
Matrix res2;
operator+(a,b,res2);
● Entendible pero largo.
● Huele mal.
● Perdimos la opción del operator+.
- tercer intento -

Move Semantics
Matrix operator+(const Matrix&, const Matrix&);
Matrix res = a+b;
● copiando… no.
● mediante un pool de matrices… no
● moviendo la representación interna !!!
- cuarto intento -

Move Semantics
- cuarto intento -
void f(const Matrix& a, const Matrix& b)
Matrix res = a+b;
// usar matriz sumada
}
Matrix operator+(const Matrix& a, const Matrix& b) {
Matrix r;
// realizar la adición
return r;
}
class Matrix {
Representation rep;
Matrix(Matrix &&a) { // move constructor
rep = a.rep; // mover la representacion interna
a.rep = {}; // limpiar la ubicación original
}
}

30 CONFIDENTIAL
Agenda
● Qué es C++
● Qué buscamos
● Código pálido
● Plan de acción
● Recursos
● Manejadores
● Estilo C++
● ¿ Preguntas ?
01

Estilo C++
● Nunca punteros desnudos
○ Son artefactos de nivel de implementación
○ Mantenerlos fuera de las interfaces
○ Preferir smart pointers - mayormente std::unique_ptr y a veces std::shared_ptr
● Nunca new o delete desnudos
○ Son artefactos de nivel de implementación para manejadores de recursos
● Regresar “por valor” usando move semantics
○ Mantenerse alejado de las referencias
● Mantener el alto nivel
○ STL tiene cero overhead y en algunos puntos corre más rápido que C.
● No bajar de nivel… todavía
○ Sobreoptimización puede llevar a bugs, y usualmente no tiene beneficio alguno.
○ Más código, más complejo, lleva a más errores, más difíciles de descifrar.
● Usar herencia solo para conceptos jerárquicos
○ No forzar OO sobre conceptos claramente no OO
○ Ha sido severamente y sistemáticamente abusado y mal usado.
“Cuando solo tienes un martillo, todo parece un clavo”

32 CONFIDENTIAL
Agenda
● Qué es C++
● Qué buscamos
● Código pálido
● Plan de acción
● Recursos
● Manejadores
● Estilo C++
● ¿ Preguntas ?
01

¿ Preguntas ?
… y gracias por participar.
Contacto:
➔ fernando.farias@globallogic.com
Fuentes:
➔ Software for infrastructure [Stroustrup] http://www.stroustrup.com/Software-for-infrastructure.
pdf
➔ Going Native 2012 Day 1 Keynote [Stroustrup] http://youtu.be/0iWb_qi2-uI

Charla C++

Recomendados

Recomendados

Más contenido relacionado

Similar a Charla C++

Similar a Charla C++ (20)

Último

Último (20)

Charla C++