C++11: Simplificando la vida del programador

Transcripción

1 C++11: Simplificando la vida del programador J. Daniel Garcia Universidad Carlos III de Madrid 26 de noviembre de 2013 J. Daniel Garcia 1/99

2 Bienvenido a C Bienvenido a C Un C++ más fácil de aprender y enseñar 3 Un patrón: RAII 4 Un mundo genérico y concurrente 5 Caso práctico 6 Para saber más 7 Y después? J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 2/99

3 Bienvenido a C++11 C++ 1 Bienvenido a C++11 C++ Estándares C++11 J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 3/99

4 Bienvenido a C++11 C++ Qué es C++? Metaprogramción Genérica Orientada a objetos Clases Multiparadigma Programación Jerarquías de clases Goteos de memoria Es C con... Problemas C++ difícil Buffer overflow Demasiado... bajo nivel Un cajón de sastre alto nivel J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 4/99

16 Bienvenido a C++11 C++ Los orígenes Leguajes Específicos de dominio FORTRAN COBOL Correspondencia directa con hardware Ensamblador Abstracción de propósito general Simula Abstracción del hardware C C++ Java C++11 C# J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 5/99

23 Bienvenido a C++11 Estándares 1 Bienvenido a C++11 C++ Estándares C++11 J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 6/99

24 Bienvenido a C++11 Estándares El proceso de normalización 1979: B. Stroustrup comienza a trabajar en C con clases. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 7/99

25 Bienvenido a C++11 Estándares El proceso de normalización 1979: B. Stroustrup comienza a trabajar en C con clases. 1985: Primera versión comercial de C++. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 7/99

26 Bienvenido a C++11 Estándares El proceso de normalización 1979: B. Stroustrup comienza a trabajar en C con clases. 1985: Primera versión comercial de C : Comienza normalización de C++ en ANSI. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 7/99

27 Bienvenido a C++11 Estándares El proceso de normalización 1979: B. Stroustrup comienza a trabajar en C con clases. 1985: Primera versión comercial de C : Comienza normalización de C++ en ANSI. 1998: ISO/IEC 14882:1998. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 7/99

28 Bienvenido a C++11 Estándares El proceso de normalización 1979: B. Stroustrup comienza a trabajar en C con clases. 1985: Primera versión comercial de C : Comienza normalización de C++ en ANSI. 1998: ISO/IEC 14882: : ISO/IEC 14882:2003 Technical Corrigendum. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 7/99

29 Bienvenido a C++11 Estándares El proceso de normalización 1979: B. Stroustrup comienza a trabajar en C con clases. 1985: Primera versión comercial de C : Comienza normalización de C++ en ANSI. 1998: ISO/IEC 14882: : ISO/IEC 14882:2003 Technical Corrigendum. 2006: ISO/IEC 18015:2006 TR on C++ Performance. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 7/99

30 Bienvenido a C++11 Estándares El proceso de normalización 1979: B. Stroustrup comienza a trabajar en C con clases. 1985: Primera versión comercial de C : Comienza normalización de C++ en ANSI. 1998: ISO/IEC 14882: : ISO/IEC 14882:2003 Technical Corrigendum. 2006: ISO/IEC 18015:2006 TR on C++ Performance. 2006: ISO/IEC 19768;2007 TR on C++ Library Extensions. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 7/99

31 Bienvenido a C++11 Estándares El proceso de normalización 1979: B. Stroustrup comienza a trabajar en C con clases. 1985: Primera versión comercial de C : Comienza normalización de C++ en ANSI. 1998: ISO/IEC 14882: : ISO/IEC 14882:2003 Technical Corrigendum. 2006: ISO/IEC 18015:2006 TR on C++ Performance. 2006: ISO/IEC 19768;2007 TR on C++ Library Extensions. 2011: ISO/IEC 14882:2011. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 7/99

32 Bienvenido a C++11 Estándares El proceso de normalización 1979: B. Stroustrup comienza a trabajar en C con clases. 1985: Primera versión comercial de C : Comienza normalización de C++ en ANSI. 1998: ISO/IEC 14882: : ISO/IEC 14882:2003 Technical Corrigendum. 2006: ISO/IEC 18015:2006 TR on C++ Performance. 2006: ISO/IEC 19768;2007 TR on C++ Library Extensions. 2011: ISO/IEC 14882: : ISO/IEC 14882:2014.?? J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 7/99

33 Bienvenido a C++11 Estándares El proceso de normalización 1979: B. Stroustrup comienza a trabajar en C con clases. 1985: Primera versión comercial de C : Comienza normalización de C++ en ANSI. 1998: ISO/IEC 14882: : ISO/IEC 14882:2003 Technical Corrigendum. 2006: ISO/IEC 18015:2006 TR on C++ Performance. 2006: ISO/IEC 19768;2007 TR on C++ Library Extensions. 2011: ISO/IEC 14882: : ISO/IEC 14882:2014.??.: Especificaciones técnicas. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 7/99

34 Bienvenido a C++11 Estándares El proceso de normalización 1979: B. Stroustrup comienza a trabajar en C con clases. 1985: Primera versión comercial de C : Comienza normalización de C++ en ANSI. 1998: ISO/IEC 14882: : ISO/IEC 14882:2003 Technical Corrigendum. 2006: ISO/IEC 18015:2006 TR on C++ Performance. 2006: ISO/IEC 19768;2007 TR on C++ Library Extensions. 2011: ISO/IEC 14882: : ISO/IEC 14882:2014.??.: Especificaciones técnicas. 2017:??. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 7/99

35 Bienvenido a C++11 Estándares Evolución J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 8/99

36 Bienvenido a C++11 Estándares El comité C++ Organización de voluntarios. Representación de industria, academia y usuarios. Sin presupuesto formal. 100 participantes en las últimas reuniones. Dos comités en paralelo. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 9/99

37 Bienvenido a C++11 C Bienvenido a C++11 C++ Estándares C++11 J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 10/99

38 Bienvenido a C++11 C++11 Qué es C++11? J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 11/99

39 Bienvenido a C++11 C++11 Qué es C++11? ISO/IEC 14882:2011. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 11/99

40 Bienvenido a C++11 C++11 Qué es C++11? ISO/IEC 14882:2011. La siguiente versión de C++98/03. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 11/99

41 Bienvenido a C++11 C++11 Qué es C++11? ISO/IEC 14882:2011. La siguiente versión de C++98/03. Un lenguaje programación de abstraccioones ligeras (B. Stroustroup). J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 11/99

42 Bienvenido a C++11 C++11 Qué es C++11? ISO/IEC 14882:2011. La siguiente versión de C++98/03. Un lenguaje programación de abstraccioones ligeras (B. Stroustroup). Cómo es C++11? Contiene muchas mejoras sobre C++98/03. Tiene muchos elementos de compatibilidad. La raíz histórica de algunos llega hasta Evolucionar un lenguaje con miles de millones de línea de código en producción es distinto que diseñar un nuevo lenguaje de programación. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 11/99

43 Bienvenido a C++11 C++11 Qué es C++11? ISO/IEC 14882:2011. La siguiente versión de C++98/03. Un lenguaje programación de abstraccioones ligeras (B. Stroustroup). Cómo es C++11? Contiene muchas mejoras sobre C++98/03. Tiene muchos elementos de compatibilidad. La raíz histórica de algunos llega hasta Evolucionar un lenguaje con miles de millones de línea de código en producción es distinto que diseñar un nuevo lenguaje de programación. Si alguien dice que tiene un lenguaje de programación perfecto: Es un vendedor o no sabe lo que dice. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 11/99

44 Bienvenido a C++11 C++11 C++ 98/03 #include <iostream> #include <vector> #include <algorithm> bool es_impar(int x) { return x % 2!= 0; } int main() { using namespace std; int vinit[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; vector<int> v(vinit, vinit + 10); vector <int> w; remove_copy_if(v.begin(), v.end(), back_inserter(w), es_impar); for (typename vector<int>::iterator i=w.begin(); i!=w.end(); ++i) { cout << *i << endl; } return 0; } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 12/99

45 Bienvenido a C++11 C++11 Hola C++11 #include <iostream> #include <vector> #include <algorithm> int main() { using namespace std; vector<int> v { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; vector <int> w; copy_if(v.begin(), v.end(), back_inserter(w), [](int x) { return x % 2 == 0; } ); for (auto x : w) { cout << x << endl; } return 0; } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 13/99

46 Un C++ más fácil de aprender y enseñar 1 Bienvenido a C Un C++ más fácil de aprender y enseñar 3 Un patrón: RAII 4 Un mundo genérico y concurrente 5 Caso práctico 6 Para saber más 7 Y después? J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 14/99

47 Un C++ más fácil de aprender y enseñar Iniciación uniforme 2 Un C++ más fácil de aprender y enseñar Iniciación uniforme Inferencia de tipos Bucles basados en rango Constantes verdaderas Literales definidos por el usuario Números aleatorios J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 15/99

48 Un C++ más fácil de aprender y enseñar Iniciación uniforme Sintaxis de iniciación uniforme Nueva sintaxis unificada para todos los contextos en los que se produce iniciación. Sintaxis derivada de iniciación de agregados. Por qué es importante? Simplificación del lenguaje. Uso en código genérico. int v[] = {1, 2, 3, 4}; vector<int> w {1, 2, 3, 4}; J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 16/99

49 Un C++ más fácil de aprender y enseñar Iniciación uniforme Sintaxis de iniciación uniforme Nueva sintaxis unificada para todos los contextos en los que se produce iniciación. Sintaxis derivada de iniciación de agregados. Por qué es importante? Simplificación del lenguaje. Uso en código genérico. int v[] = {1, 2, 3, 4}; vector<int> w {1, 2, 3, 4}; vector<string> inv { "Jesus", "Luis", "Rafael", "Daniel" }; J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 16/99

50 Un C++ más fácil de aprender y enseñar Iniciación uniforme Sintaxis de iniciación uniforme Nueva sintaxis unificada para todos los contextos en los que se produce iniciación. Sintaxis derivada de iniciación de agregados. Por qué es importante? Simplificación del lenguaje. Uso en código genérico. int v[] = {1, 2, 3, 4}; vector<int> w {1, 2, 3, 4}; vector<string> inv { "Jesus", "Luis", "Rafael", "Daniel" }; thread t1 (); // t1 es una función thread t2 {}; // Constructor vacío J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 16/99

51 Un C++ más fácil de aprender y enseñar Iniciación uniforme Sintaxis de iniciación uniforme Nueva sintaxis unificada para todos los contextos en los que se produce iniciación. Sintaxis derivada de iniciación de agregados. Por qué es importante? Simplificación del lenguaje. Uso en código genérico. int v[] = {1, 2, 3, 4}; vector<int> w {1, 2, 3, 4}; vector<string> inv { "Jesus", "Luis", "Rafael", "Daniel" }; thread t1 (); // t1 es una función thread t2 {}; // Constructor vacío complex<double> z {2.0, 3.5}; // Constructor J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 16/99

52 Un C++ más fácil de aprender y enseñar Iniciación uniforme Sintaxis de iniciación uniforme Nueva sintaxis unificada para todos los contextos en los que se produce iniciación. Sintaxis derivada de iniciación de agregados. Por qué es importante? Simplificación del lenguaje. Uso en código genérico. int v[] = {1, 2, 3, 4}; vector<int> w {1, 2, 3, 4}; vector<string> inv { "Jesus", "Luis", "Rafael", "Daniel" }; thread t1 (); // t1 es una función thread t2 {}; // Constructor vacío complex<double> z {2.0, 3.5}; // Constructor struct punto { double x, y, z; }; punto p {3.0, 2.5, 9.0}; // Iniciación de agregado J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 16/99

53 Un C++ más fácil de aprender y enseñar Iniciación uniforme Iniciación uniforme T{x} produce el mismo valor de T en distintos contextos. T x{v}; T * p = new T{v}; x = T{w}; // Conversión J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 17/99

54 Un C++ más fácil de aprender y enseñar Iniciación uniforme Iniciación uniforme T{x} produce el mismo valor de T en distintos contextos. T x{v}; T * p = new T{v}; x = T{w}; // Conversión void f(t x); f({v}); // Se pasa T{v} J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 17/99

55 Un C++ más fácil de aprender y enseñar Iniciación uniforme Iniciación uniforme T{x} produce el mismo valor de T en distintos contextos. T x{v}; T * p = new T{v}; x = T{w}; // Conversión void f(t x); f({v}); // Se pasa T{v} T g() { return {w}; // Devuelve T{w} } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 17/99

56 Un C++ más fácil de aprender y enseñar Iniciación uniforme Iniciación uniforme T{x} produce el mismo valor de T en distintos contextos. T x{v}; T * p = new T{v}; x = T{w}; // Conversión void f(t x); f({v}); // Se pasa T{v} T g() { return {w}; // Devuelve T{w} } derivada::derivada() : base{v1}, miembro{v2} {/*... */} J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 17/99

57 Un C++ más fácil de aprender y enseñar Inferencia de tipos 2 Un C++ más fácil de aprender y enseñar Iniciación uniforme Inferencia de tipos Bucles basados en rango Constantes verdaderas Literales definidos por el usuario Números aleatorios J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 18/99

58 Un C++ más fácil de aprender y enseñar Inferencia de tipos Especificación auto Deduce el tipo de una variable a partir de su valor inicial. auto x = 2.5; // double auto y = 1.5f; // float El compilador conoce el tipo de la expresión de iniciación. la deducción se realiza en tiempo de compilación. El tipado sigue siendo estático. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 19/99

59 Un C++ más fácil de aprender y enseñar Inferencia de tipos Especificación auto Deduce el tipo de una variable a partir de su valor inicial. auto x = 2.5; // double auto y = 1.5f; // float El compilador conoce el tipo de la expresión de iniciación. la deducción se realiza en tiempo de compilación. El tipado sigue siendo estático. Evita código difícil de mantener. typename C::iterator i = c.begin(); // o const_iterator? auto i = c.begin(); Nota: Implementado por primera vez en Incompatibilidad con C de la época. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 19/99

60 Un C++ más fácil de aprender y enseñar Inferencia de tipos Ejemplo template <class C> void imprime(const C & c) { using namespace std; typedef typename C::const_iterator iterador; for (iterador i=c.begin(); i!=c.end(); ++i) { cout << *i << endl; } } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 20/99

61 Un C++ más fácil de aprender y enseñar Inferencia de tipos Ejemplo template <class C> void imprime(const C & c) { using namespace std; typedef typename C::const_iterator iterador; for (iterador i=c.begin(); i!=c.end(); ++i) { cout << *i << endl; } } template <class C> void imprime(const C & c) { using namespace std; for (auto i=c.begin(); i!=c.end(); ++i) { cout << *i << endl; } } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 20/99

62 Un C++ más fácil de aprender y enseñar Bucles basados en rango 2 Un C++ más fácil de aprender y enseñar Iniciación uniforme Inferencia de tipos Bucles basados en rango Constantes verdaderas Literales definidos por el usuario Números aleatorios J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 21/99

63 Un C++ más fácil de aprender y enseñar Bucles basados en rango Bucles sobre secuencias Iteración simplificada sobre una secuencia tipo STL. Secuencias definidas por begin() y end(). template <class C> void imprime(const C & c) { for (auto x : c) { std::cout << x << std::endl; } } Iteración con referencias. template <typename C> void eleva(c & c) { for (auto & x : c) { x = x * x; } } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 22/99

64 Un C++ más fácil de aprender y enseñar Bucles basados en rango Arrays y listas de iniciación Se puede iterar sobre un array. int v[] = {1, 2, 4, 8}; for (auto x : v) { cout << x << endl; } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 23/99

65 Un C++ más fácil de aprender y enseñar Bucles basados en rango Arrays y listas de iniciación Se puede iterar sobre un array. int v[] = {1, 2, 4, 8}; for (auto x : v) { cout << x << endl; } Se puede iterar sobre una lista de iniciación. for (auto x : {1.0, 2.0, 4.0}) { cout << x << endl; } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 23/99

66 Un C++ más fácil de aprender y enseñar Bucles basados en rango Arrays y listas de iniciación Se puede iterar sobre un array. int v[] = {1, 2, 4, 8}; for (auto x : v) { cout << x << endl; } Se puede iterar sobre una lista de iniciación. for (auto x : {1.0, 2.0, 4.0}) { cout << x << endl; } Aplicable a cualquier tipo que cumpla con el concepto de rango. Expresiones x.begin() y x.end() válidas, o Expresiones begin(x) y end(x) válidas. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 23/99

67 Un C++ más fácil de aprender y enseñar Constantes verdaderas 2 Un C++ más fácil de aprender y enseñar Iniciación uniforme Inferencia de tipos Bucles basados en rango Constantes verdaderas Literales definidos por el usuario Números aleatorios J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 24/99

68 Un C++ más fácil de aprender y enseñar Constantes verdaderas Expresiones constantes Tipos de constantes: Valores (inmutables) que no pueden modificarse const. Expresiones evaluadas en tiempo de compilación constexpr. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 25/99

69 Un C++ más fácil de aprender y enseñar Constantes verdaderas Expresiones constantes Tipos de constantes: Valores (inmutables) que no pueden modificarse const. Expresiones evaluadas en tiempo de compilación constexpr. Por qué constexpr? Facilidad de comprensión del código. Evitar modificaciones. Necesidad en algunos contextos. Tamaños de arrays, argumentos de plantillas, etiquetas case. Objetos en memoria ROM. Iniciación en tiempo de compilación libre de carreras de datos. Mejora de rendimiento. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 25/99

70 Un C++ más fácil de aprender y enseñar Constantes verdaderas Valores y funciones Valores conocidos en tiempo de compilación constexpr int tam = 42; int v[tam]; J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 26/99

71 Un C++ más fácil de aprender y enseñar Constantes verdaderas Valores y funciones Valores conocidos en tiempo de compilación constexpr int tam = 42; int v[tam]; Funciones constantes: Se pueden evaluar en tiempo de compilación,... J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 26/99

72 Un C++ más fácil de aprender y enseñar Constantes verdaderas Valores y funciones Valores conocidos en tiempo de compilación constexpr int tam = 42; int v[tam]; Funciones constantes: Se pueden evaluar en tiempo de compilación,... Si se pasan argumentos conocidos en tiempo de compilación. constexpr int suma(int x, int y) { return x+y; } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 26/99

73 Un C++ más fácil de aprender y enseñar Constantes verdaderas Valores y funciones Valores conocidos en tiempo de compilación constexpr int tam = 42; int v[tam]; Funciones constantes: Se pueden evaluar en tiempo de compilación,... Si se pasan argumentos conocidos en tiempo de compilación. constexpr int suma(int x, int y) { return x+y; } //... int a=2, b=3; int z1 = suma(a,b); // Tiempo de ejecución J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 26/99

74 Un C++ más fácil de aprender y enseñar Constantes verdaderas Valores y funciones Valores conocidos en tiempo de compilación constexpr int tam = 42; int v[tam]; Funciones constantes: Se pueden evaluar en tiempo de compilación,... Si se pasan argumentos conocidos en tiempo de compilación. constexpr int suma(int x, int y) { return x+y; } //... int a=2, b=3; int z1 = suma(a,b); // Tiempo de ejecución int z2 = suma(2,3); // Tiempo de compilación o ejecución J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 26/99

75 Un C++ más fácil de aprender y enseñar Constantes verdaderas Valores y funciones Valores conocidos en tiempo de compilación constexpr int tam = 42; int v[tam]; Funciones constantes: Se pueden evaluar en tiempo de compilación,... Si se pasan argumentos conocidos en tiempo de compilación. constexpr int suma(int x, int y) { return x+y; } //... int a=2, b=3; int z1 = suma(a,b); // Tiempo de ejecución int z2 = suma(2,3); // Tiempo de compilación o ejecución constexpr int z3 = suma(2,3); // Tiempo de compilación J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 26/99

76 Un C++ más fácil de aprender y enseñar Constantes verdaderas Valores y funciones Valores conocidos en tiempo de compilación constexpr int tam = 42; int v[tam]; Funciones constantes: Se pueden evaluar en tiempo de compilación,... Si se pasan argumentos conocidos en tiempo de compilación. constexpr int suma(int x, int y) { return x+y; } //... int a=2, b=3; int z1 = suma(a,b); // Tiempo de ejecución int z2 = suma(2,3); // Tiempo de compilación o ejecución constexpr int z3 = suma(2,3); // Tiempo de compilación constexpr int z4 = suma(a,b); // Error: a y b no constantes J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 26/99

77 Un C++ más fácil de aprender y enseñar Constantes verdaderas Tipos literales Tipos con un constructor constexpr. Cuerpo del constructor vacío. Todos los miembros iniciados por expresiones potencialmente constantes. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 27/99

78 Un C++ más fácil de aprender y enseñar Constantes verdaderas Tipos literales Tipos con un constructor constexpr. Cuerpo del constructor vacío. Todos los miembros iniciados por expresiones potencialmente constantes. struct punto { double x, y; constexpr punto(double px, double py) : x{px}, y{py} {} }; J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 27/99

79 Un C++ más fácil de aprender y enseñar Constantes verdaderas Tipos literales Tipos con un constructor constexpr. Cuerpo del constructor vacío. Todos los miembros iniciados por expresiones potencialmente constantes. struct punto { double x, y; constexpr punto(double px, double py) : x{px}, y{py} {} }; constexpr punto p1{1.0, 2.5}; constexpr double x1 = p1.x; constexpr punto v[] = { punto{1.0,1.5}, punto{2.5,7.3}, punto{0,0} }; J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 27/99

80 Un C++ más fácil de aprender y enseñar Literales definidos por el usuario 2 Un C++ más fácil de aprender y enseñar Iniciación uniforme Inferencia de tipos Bucles basados en rango Constantes verdaderas Literales definidos por el usuario Números aleatorios J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 28/99

81 Un C++ más fácil de aprender y enseñar Literales definidos por el usuario Extensión de la idea de literal Literales de tipos predefinidos y sufijos: auto x1 = 125UL; // unsigned long auto x2 = 3.14f; // flaot auto x3 = "Hola"; // const char * Literales definidos por el usuario: auto x1 = 2.7i; // complex<double>{0, 2.7} auto x2 = "Hola"s // std::string auto x3 = 2h + 20min + 15s; // duration Literales y reducción de errores: velocidad v = 100m / 9s; aceleracion a = v / 4s; aceleracion a2 = v; // Error J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 29/99

82 Un C++ más fácil de aprender y enseñar Literales definidos por el usuario Operador literal Transforma un literal a un valor de un tipo. Nuevo operador sobrecargable operator""sufijo. constexpr complex<double> operator"" _i(long double ival) { return {0,double(ival)}; } complex<double> x {2.0, 1.0}; complex<double> y = 3.0_i; J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 30/99

83 Un C++ más fácil de aprender y enseñar Literales definidos por el usuario Operador literal Transforma un literal a un valor de un tipo. Nuevo operador sobrecargable operator""sufijo. constexpr complex<double> operator"" _i(long double ival) { return {0,double(ival)}; } complex<double> x {2.0, 1.0}; complex<double> y = 3.0_i; No se puede: Redefinir sufijos predefinidos del lenguaje (ul, f,... ). Modificar reglas léxicas de literales. Definir sufijos que no comienzar por subrayado (reservados). J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 30/99

84 Un C++ más fácil de aprender y enseñar Números aleatorios 2 Un C++ más fácil de aprender y enseñar Iniciación uniforme Inferencia de tipos Bucles basados en rango Constantes verdaderas Literales definidos por el usuario Números aleatorios J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 31/99

85 Un C++ más fácil de aprender y enseñar Números aleatorios Estructura Generador uniforme de números aleatorios: Cualquier objeto función que devuelve números enteros sin signo dentro de un rango con probabilidad uniforme. Es un concepto. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 32/99

86 Un C++ más fácil de aprender y enseñar Números aleatorios Estructura Generador uniforme de números aleatorios: Cualquier objeto función que devuelve números enteros sin signo dentro de un rango con probabilidad uniforme. Es un concepto. Motor de números aleatorios: Un generador uniforme que puede crearse por defecto o con una semilla. default_random_engine, mersenne_twister_engine,... J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 32/99

87 Un C++ más fácil de aprender y enseñar Números aleatorios Estructura Generador uniforme de números aleatorios: Cualquier objeto función que devuelve números enteros sin signo dentro de un rango con probabilidad uniforme. Es un concepto. Motor de números aleatorios: Un generador uniforme que puede crearse por defecto o con una semilla. default_random_engine, mersenne_twister_engine,... Adaptador de motor de números aleatorios: Motor que realiza transformaciones sobre otros motores. discard_block_engine,... Alias: mt19937_64, ranlux48,... J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 32/99

88 Un C++ más fácil de aprender y enseñar Números aleatorios Estructura Generador uniforme de números aleatorios: Cualquier objeto función que devuelve números enteros sin signo dentro de un rango con probabilidad uniforme. Es un concepto. Motor de números aleatorios: Un generador uniforme que puede crearse por defecto o con una semilla. default_random_engine, mersenne_twister_engine,... Adaptador de motor de números aleatorios: Motor que realiza transformaciones sobre otros motores. discard_block_engine,... Alias: mt19937_64, ranlux48,... Distribuicón de números aleatorios: Genera números de acuerdo con una función de densidad a partir de un motor. bernoulli_distribution, poisson_distribution,... J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 32/99

89 Un C++ más fácil de aprender y enseñar Números aleatorios Uso de números aleatorios #include <iostream> #include <random> int main() { using namespace std; default_random_engine e1; mt19937_64 e2; knuth_b e3; normal_distribution<double> dist{1.0, 0.5}; for (int i=0; i<10; ++i) { cout << dist(e1) << "\t" << dist(e2) << "\t" << dist(e3) << endl; } return 0; } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 33/99

90 Un patrón: RAII 1 Bienvenido a C Un C++ más fácil de aprender y enseñar 3 Un patrón: RAII 4 Un mundo genérico y concurrente 5 Caso práctico 6 Para saber más 7 Y después? J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 34/99

91 Un patrón: RAII Valores y recursos 3 Un patrón: RAII Valores y recursos Gestión de recursos Semántica de movimiento J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 35/99

92 Un patrón: RAII Valores y recursos Tipos de objetos Qué es un objeto en C++? J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 36/99

93 Un patrón: RAII Valores y recursos Tipos de objetos Qué es un objeto en C++? Una región de almacenamiento (uno o más bytes). J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 36/99

94 Un patrón: RAII Valores y recursos Tipos de objetos Qué es un objeto en C++? Una región de almacenamiento (uno o más bytes). Tipos de objetos. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 36/99

95 Un patrón: RAII Valores y recursos Tipos de objetos Qué es un objeto en C++? Una región de almacenamiento (uno o más bytes). Tipos de objetos. Valores: int, double, complex<double>,... J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 36/99

96 Un patrón: RAII Valores y recursos Tipos de objetos Qué es un objeto en C++? Una región de almacenamiento (uno o más bytes). Tipos de objetos. Valores: int, double, complex<double>,... Referencias a recursos: string, vector<string>, thread,... J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 36/99

97 Un patrón: RAII Valores y recursos Tipos de objetos Qué es un objeto en C++? Una región de almacenamiento (uno o más bytes). Tipos de objetos. Valores: int, double, complex<double>,... Referencias a recursos: string, vector<string>, thread,... valor referencia valor J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 36/99

98 Un patrón: RAII Valores y recursos Tipos de objetos Qué es un objeto en C++? Una región de almacenamiento (uno o más bytes). Tipos de objetos. Valores: int, double, complex<double>,... Referencias a recursos: string, vector<string>, thread,... valor referencia valor Objetos más complejos generados por concatenación: Homogénea: arrays. Heterogénea: clases. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 36/99

99 Un patrón: RAII Valores y recursos Tipos de objetos Qué es un objeto en C++? Una región de almacenamiento (uno o más bytes). Tipos de objetos. Valores: int, double, complex<double>,... Referencias a recursos: string, vector<string>, thread,... valor referencia valor Objetos más complejos generados por concatenación: Homogénea: arrays. Heterogénea: clases. Si entiendes int y vector entiendes C++. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 36/99

100 Un patrón: RAII Valores y recursos Tipos de objetos Qué es un objeto en C++? Una región de almacenamiento (uno o más bytes). Tipos de objetos. Valores: int, double, complex<double>,... Referencias a recursos: string, vector<string>, thread,... valor referencia valor Objetos más complejos generados por concatenación: Homogénea: arrays. Heterogénea: clases. Si entiendes int y vector entiendes C++. El resto son (1400 páginas de) detalles. Bjarne Stroustrup. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 36/99

101 Un patrón: RAII Gestión de recursos 3 Un patrón: RAII Valores y recursos Gestión de recursos Semántica de movimiento J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 37/99

102 Un patrón: RAII Gestión de recursos Gestores de recursos Un recurso debe ser siempre propiedad de un gestor. El gestor representa una abstracción bien definida (vector, cadena, fichero, cerrojo,... ). El constructor adquiere el recurso. El destructor lo libera. class mi_vector { public: mi_vector(initializer_list<double> il); ~mi_vector(); //... private: double * v; int tam; }; void f() { mi_vector w{0.5, 2.7, 3.14}; //... } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 38/99

103 Un patrón: RAII Gestión de recursos Gestión de los recursos Los constructores realizan la adquisición del recurso. mi_vector::mi_vector(initializer_list<double> il) : v{new double[il.size()]}, // Adquiere memoria sin iniciar tam{il.size()} { // Inicia copiando std::uninitialized_copy(il.begin(), il.end(), v.begin()); } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 39/99

104 Un patrón: RAII Gestión de recursos Gestión de los recursos Los constructores realizan la adquisición del recurso. mi_vector::mi_vector(initializer_list<double> il) : v{new double[il.size()]}, // Adquiere memoria sin iniciar tam{il.size()} { // Inicia copiando std::uninitialized_copy(il.begin(), il.end(), v.begin()); } Los destructores realizan la liberación del recurso. mi_vector::~mi_vector() { delete []v; // Libera memoria } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 39/99

105 Un patrón: RAII Gestión de recursos Recursos y errores Un error se puede producir (casi) en cualquier punto. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 40/99

106 Un patrón: RAII Gestión de recursos Recursos y errores Un error se puede producir (casi) en cualquier punto. Objetivo: evitar los goteos de recursos. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 40/99

107 Un patrón: RAII Gestión de recursos Recursos y errores Un error se puede producir (casi) en cualquier punto. Objetivo: evitar los goteos de recursos. Principios: J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 40/99

108 Un patrón: RAII Gestión de recursos Recursos y errores Un error se puede producir (casi) en cualquier punto. Objetivo: evitar los goteos de recursos. Principios: Un recurso es cualquier cosa que se adquire/libera (no solamente memoria). J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 40/99

109 Un patrón: RAII Gestión de recursos Recursos y errores Un error se puede producir (casi) en cualquier punto. Objetivo: evitar los goteos de recursos. Principios: Un recurso es cualquier cosa que se adquire/libera (no solamente memoria). Un recurso debería tener siempre un propietario. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 40/99

110 Un patrón: RAII Gestión de recursos Recursos y errores Un error se puede producir (casi) en cualquier punto. Objetivo: evitar los goteos de recursos. Principios: Un recurso es cualquier cosa que se adquire/libera (no solamente memoria). Un recurso debería tener siempre un propietario. Colocar los gestores de recursos en alcances. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 40/99

111 Un patrón: RAII Gestión de recursos Recursos y errores Un error se puede producir (casi) en cualquier punto. Objetivo: evitar los goteos de recursos. Principios: Un recurso es cualquier cosa que se adquire/libera (no solamente memoria). Un recurso debería tener siempre un propietario. Colocar los gestores de recursos en alcances. Patrón RAII: Resource Allocation Is Initialization. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 40/99

112 Un patrón: RAII Gestión de recursos Recursos y errores Un error se puede producir (casi) en cualquier punto. Objetivo: evitar los goteos de recursos. Principios: Un recurso es cualquier cosa que se adquire/libera (no solamente memoria). Un recurso debería tener siempre un propietario. Colocar los gestores de recursos en alcances. Patrón RAII: Resource Allocation Is Initialization. El recurso se adquiere en la construcción del gestor. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 40/99

113 Un patrón: RAII Gestión de recursos Recursos y errores Un error se puede producir (casi) en cualquier punto. Objetivo: evitar los goteos de recursos. Principios: Un recurso es cualquier cosa que se adquire/libera (no solamente memoria). Un recurso debería tener siempre un propietario. Colocar los gestores de recursos en alcances. Patrón RAII: Resource Allocation Is Initialization. El recurso se adquiere en la construcción del gestor. El recurso se libera en la destrucción del gestor. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 40/99

114 Un patrón: RAII Gestión de recursos Recursos y errores Un error se puede producir (casi) en cualquier punto. Objetivo: evitar los goteos de recursos. Principios: Un recurso es cualquier cosa que se adquire/libera (no solamente memoria). Un recurso debería tener siempre un propietario. Colocar los gestores de recursos en alcances. Patrón RAII: Resource Allocation Is Initialization. El recurso se adquiere en la construcción del gestor. El recurso se libera en la destrucción del gestor. Se lanza una excepción si hay problemas de construcción/adquisición. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 40/99

115 Un patrón: RAII Gestión de recursos Recursos y errores Un error se puede producir (casi) en cualquier punto. Objetivo: evitar los goteos de recursos. Principios: Un recurso es cualquier cosa que se adquire/libera (no solamente memoria). Un recurso debería tener siempre un propietario. Colocar los gestores de recursos en alcances. Patrón RAII: Resource Allocation Is Initialization. El recurso se adquiere en la construcción del gestor. El recurso se libera en la destrucción del gestor. Se lanza una excepción si hay problemas de construcción/adquisición. No lanzar nunca una excepción si se tiene un recurso no gestionado. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 40/99

116 Un patrón: RAII Gestión de recursos Gestión segura de recursos RAII aplicable a distintos tipos de recursos: Memoria: string, vector,... Flujos: fstream,... Hilos: thread,... Cerrojos: unique_lock,... Sockets,... std::mutex m; cola c; void f(peticion p) { std::lock_guard l{m}; // Adquiere el mutex c.pon(p); } // Libera el mutex J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 41/99

117 Un patrón: RAII Gestión de recursos Punteros y goteos de recursos Es fácil generar goteos al usar memoria dinámica directamente. void f(string & s, int a, int b) { matriz * pm = new matriz{a,b}; g(pm); // #1 if (s == "") return; // #2 if (a!=b) throw runtime_error{"no es cuadrada"}; // #3 string tmp = s; // #4 h(tmp, pm); // #5 delete pm; // Olvido? (sobre todo si vienes de Java, C#,...) } Sospecha del código que usa directamente new y delete. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 42/99

118 Un patrón: RAII Gestión de recursos Solución Todos los problemas en ingeniera del software se pueden resolver con nivel adicional de indirección. J. Daniel Garcia 43/99

119 Un patrón: RAII Gestión de recursos Solución Todos los problemas en ingeniera del software se pueden resolver con nivel adicional de indirección. Excepto el problema de demasiados niveles de indirección. David Wheeler ( ) J. Daniel Garcia 43/99

120 Un patrón: RAII Gestión de recursos Solución Todos los problemas en ingeniera del software se pueden resolver con nivel adicional de indirección. Excepto el problema de demasiados niveles de indirección. David Wheeler ( ) Aplicado en la biblioteca estándar mediante smart pointers. shared_ptr. weak_ptr. unique_ptr. J. Daniel Garcia 43/99

121 Un patrón: RAII Gestión de recursos Punteros, goteos y punteros inteligentes Es fácil evitar goteos de memoria con punteros inteligentes. void f(string & s, int a, int b) { shared_ptr<matriz> pm { new matriz{a,b} }; g(pm); // #1 if (s == "") return; // #2 if (a!=b) throw runtime_error{"no es cuadrada"}; // #3 string tmp = s; // #4 h(tmp, pm); // #5 } // Liberación J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 44/99

122 Un patrón: RAII Gestión de recursos Punteros, goteos y punteros inteligentes Es fácil evitar goteos de memoria con punteros inteligentes. void f(string & s, int a, int b) { shared_ptr<matriz> pm { new matriz{a,b} }; g(pm); // #1 if (s == "") return; // #2 if (a!=b) throw runtime_error{"no es cuadrada"}; // #3 string tmp = s; // #4 h(tmp, pm); // #5 } // Liberación Cuando el último shared_ptr se destruye, se libera la memoria. Usa contador de referencias. Alternativa: unique_ptr si no hace falta contador de referencias. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 44/99

123 Un patrón: RAII Gestión de recursos Punteros inteligentes sin new No hay razones reales para usar directamente new. void f(string & s, int a, int b) { auto pm = make_shared<matriz>(a,b); g(pm); // #1 if (s == "") return; // #2 if (a!=b) throw runtime_error{"no es cuadrada"}; // #3 string tmp = s; // #4 h(tmp, pm); // #5 } // Liberación J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 45/99

124 Un patrón: RAII Gestión de recursos Punteros inteligentes sin new No hay razones reales para usar directamente new. void f(string & s, int a, int b) { auto pm = make_shared<matriz>(a,b); g(pm); // #1 if (s == "") return; // #2 if (a!=b) throw runtime_error{"no es cuadrada"}; // #3 string tmp = s; // #4 h(tmp, pm); // #5 } // Liberación Pequeño beneficio extra de rendimiento con shared_ptr. La jerarquía de memoria importa! J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 45/99

125 Un patrón: RAII Gestión de recursos Alternativa a punteros En muchos casos una variable local es una alternativa mejor que un puntero (smart o no). Se evita la sobrecarga de la gestión de memoria dinámica. Es más barato acceder a la pila que al almacén libre. void f(string & s, int a, int b) { matriz m{a,b}; g(m); // #1 if (s == "") return; // #2 if (a!=b) throw runtime_error{"no es cuadrada"}; // #3 string tmp = s; // #4 h(tmp, m); // #5 } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 46/99

126 Un patrón: RAII Semántica de movimiento 3 Un patrón: RAII Valores y recursos Gestión de recursos Semántica de movimiento J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 47/99

127 Un patrón: RAII Semántica de movimiento Transferencia de recursos Problema: Devolver un objeto grande generado por una función. J. Daniel Garcia 48/99

128 Un patrón: RAII Semántica de movimiento Transferencia de recursos Problema: Devolver un objeto grande generado por una función. Soluciones: 1 Devolver un puntero a un objeto asingado en memoria dinámica. 2 Devolver una referencia a un objeto asignado en memoria dinámica. 3 Pasar una referencia a la variable resultado. 4 Devolver una copia del resultado. 5 Mover el resultado. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 48/99

129 Un patrón: RAII Semántica de movimiento Devolver punteros vector<string> * concat(const vector<string> & l1, const vector<string> & l2) { vector<string> * r = new vector<string>; for (auto x : l1) { r->push_back(x); } for (auto x : l2) { r->push_back(x); } return r; } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 49/99

130 Un patrón: RAII Semántica de movimiento Devolver punteros vector<string> * concat(const vector<string> & l1, const vector<string> & l2) { vector<string> * r = new vector<string>; for (auto x : l1) { r->push_back(x); } for (auto x : l2) { r->push_back(x); } return r; } La memoria se reserva en un contexto y debe liberarse en otro. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 49/99

131 Un patrón: RAII Semántica de movimiento Devolver punteros void f() { vector<string> a{"hola", "Mundo"}; vector<string> b{"a", "b", "c"}; vector<string> & c = *concat(a,b); delete &c; } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 50/99

132 Un patrón: RAII Semántica de movimiento Devolver punteros void f() { vector<string> a{"hola", "Mundo"}; vector<string> b{"a", "b", "c"}; vector<string> & c = *concat(a,b); delete &c; } Sintaxis irregular. Es fácil olvidar la liberación. Conducente a goteos de memoria. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 50/99

133 Un patrón: RAII Semántica de movimiento Devolver referencias vector<string> & concat(const vector<string> & l1, const vector<string> & l2) { vector<string> * r = new vector<string>; for (auto x : l1) { r->push_back(x); } for (auto x : l2) { r->push_back(x); } return *r; } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 51/99

134 Un patrón: RAII Semántica de movimiento Devolver referencias vector<string> & concat(const vector<string> & l1, const vector<string> & l2) { vector<string> * r = new vector<string>; for (auto x : l1) { r->push_back(x); } for (auto x : l2) { r->push_back(x); } return *r; } Se oculta sintácticamente el puntero. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 51/99

135 Un patrón: RAII Semántica de movimiento Devolver referencias void f() { vector<string> a{"hola", "Mundo"}; vector<string> b{"a", "b", "c"}; vector<string> & c = concat(a,b); delete &c; } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 52/99

136 Un patrón: RAII Semántica de movimiento Devolver referencias void f() { vector<string> a{"hola", "Mundo"}; vector<string> b{"a", "b", "c"}; vector<string> & c = concat(a,b); delete &c; } Sintaxis más regular irregular. Es fácil olvidar la liberación. Conducente a goteos de memoria. Fácil cometer otros errores. vector<string> c = concat(a,b); J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 52/99

137 Un patrón: RAII Semántica de movimiento Pasar referencia al resultado void concat(const vector<string> & l1, const vector<string> & l2, vector<string> & r) { for (auto x : l1) { r.push_back(x); } for (auto x : l2) { r.push_back(x); } } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 53/99

138 Un patrón: RAII Semántica de movimiento Pasar referencia al resultado void concat(const vector<string> & l1, const vector<string> & l2, vector<string> & r) { for (auto x : l1) { r.push_back(x); } for (auto x : l2) { r.push_back(x); } } Se evita el uso de memoria dinámica. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 53/99

139 Un patrón: RAII Semántica de movimiento Devolver referencias void f() { vector<string> a{"hola", "Mundo"}; vector<string> b{"a", "b", "c"}; vector<string> c; concat(a,b,c); } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 54/99

140 Un patrón: RAII Semántica de movimiento Devolver referencias void f() { vector<string> a{"hola", "Mundo"}; vector<string> b{"a", "b", "c"}; vector<string> c; concat(a,b,c); } Sintaxis poco natural. Difícil ver cual es el resultado. Qué ocurre si la variable resultado ya contiene valores? Complicado de integrar con sobrecarga de operadores. operator+(a,b,c); // Imposible usar notación infija J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 54/99

141 Un patrón: RAII Semántica de movimiento Devolver una copia vector<string> concat(const vector<string> & l1, const vector<string> & l2) { vector<string> r; typedef typename vector<string>::const_iterator iterador; for (iterador i=l1.begin(); i!=l1.end(); ++i) { r.push_back(*i); } for (iterador i=l2.begin(); i!=l2.end(); ++i) { r.push_back(*i); } return r; } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 55/99

142 Un patrón: RAII Semántica de movimiento Devolver una copia vector<string> concat(const vector<string> & l1, const vector<string> & l2) { vector<string> r; typedef typename vector<string>::const_iterator iterador; for (iterador i=l1.begin(); i!=l1.end(); ++i) { r.push_back(*i); } for (iterador i=l2.begin(); i!=l2.end(); ++i) { r.push_back(*i); } return r; } Sintaxis más natural. Se produce copia del resultado. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 55/99

143 Un patrón: RAII Semántica de movimiento Devolver una copia void f() { vector<string> a; a.push_back("hola"); a.push_back("mundo"); vector<string> b; b.push_back("a"); b.push_back("b"); b.push_back("c"); vector<string> c = concat(a,b); } La copia puede ser muy costosa. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 56/99

144 Un patrón: RAII Semántica de movimiento Movimiento vector<string> concat(const vector<string> & l1, const vector<string> & l2); Semántica de movimiento. Se mueve el resultado devuelto a la variable asignada. vector<string> c = concat(a,b); Soportado por: Constructor de movimiento. Operador de asignación de movimiento. Biblioteca estándar: La gran mayoría de los tipos incluyen semántica de movimiento. Efecto positivo de recompilar aplicaciones existentes. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 57/99

145 Un mundo genérico y concurrente 1 Bienvenido a C Un C++ más fácil de aprender y enseñar 3 Un patrón: RAII 4 Un mundo genérico y concurrente 5 Caso práctico 6 Para saber más 7 Y después? J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 58/99

146 Un mundo genérico y concurrente Expresiones lambda 4 Un mundo genérico y concurrente Expresiones lambda Alias de plantillas Concurrencia en C++11 Hilos Tareas asíncronas J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 59/99

147 Un mundo genérico y concurrente Expresiones lambda Objetos función simplificados C++98/03: class menor_abs { bool operator()(int x, int y) { return abs(x) < abs(y); } }; //... vector<int> v = { 100, -1, 40, -70 }; sort(v.begin(), v.end(), menor_abs()); J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 60/99

148 Un mundo genérico y concurrente Expresiones lambda Objetos función simplificados C++98/03: class menor_abs { bool operator()(int x, int y) { return abs(x) < abs(y); } }; //... vector<int> v = { 100, -1, 40, -70 }; sort(v.begin(), v.end(), menor_abs()); Una expresión lambda Es un mecanismo para especificar un objeto función. Permite pasar una función simple a otro contexto. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 60/99

149 Un mundo genérico y concurrente Expresiones lambda Objetos función simplificados C++98/03: class menor_abs { bool operator()(int x, int y) { return abs(x) < abs(y); } }; //... vector<int> v = { 100, -1, 40, -70 }; sort(v.begin(), v.end(), menor_abs()); Una expresión lambda Es un mecanismo para especificar un objeto función. Permite pasar una función simple a otro contexto. C++11: vector<int> v = { 100, -1, 40, -70 }; //... sort(v.begin(), v.end(), [](int x, int y) { return abs(x) < abs(y); }); J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 60/99

150 Un mundo genérico y concurrente Expresiones lambda Otros usos Acceso a valores de alcance externo: void imprime_rango(std::vector<int> & v, int minv, int maxv ) { std::for_each(v.begin(), v.end(), [minv,maxv](int x) { if (x > maxv) return; if (x < minv) return; cout << x << endl; }); } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 61/99

151 Un mundo genérico y concurrente Expresiones lambda Otros usos Acceso a valores de alcance externo: void imprime_rango(std::vector<int> & v, int minv, int maxv ) { std::for_each(v.begin(), v.end(), [minv,maxv](int x) { if (x > maxv) return; if (x < minv) return; cout << x << endl; }); } Reutilización de lambdas. void f(vector<int> & v1, vector<int> & v2) { auto c = [](int x, int y) { return x < y; } sort(v1.begin(), v1.end(), c); sort(v2.begin(), v2.end(), c); } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 61/99

152 Un mundo genérico y concurrente Alias de plantillas 4 Un mundo genérico y concurrente Expresiones lambda Alias de plantillas Concurrencia en C++11 Hilos Tareas asíncronas J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 62/99

153 Un mundo genérico y concurrente Alias de plantillas Motivación Problema: Poder definir plantillas con algunos parámetros asignados y otros sin asignar. Dado mi_allocator<t> definir un tipo mi_vector que lo usa. Pero typedef no es genérico. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 63/99

154 Un mundo genérico y concurrente Alias de plantillas Motivación Problema: Poder definir plantillas con algunos parámetros asignados y otros sin asignar. Dado mi_allocator<t> definir un tipo mi_vector que lo usa. Pero typedef no es genérico. Problema: Imposibilidad de deducir argumentos de plantilla que son tipos anidados de plantillas. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 63/99

155 Un mundo genérico y concurrente Alias de plantillas Motivación Problema: Poder definir plantillas con algunos parámetros asignados y otros sin asignar. Dado mi_allocator<t> definir un tipo mi_vector que lo usa. Pero typedef no es genérico. Problema: Imposibilidad de deducir argumentos de plantilla que son tipos anidados de plantillas. Solución: Sintaxis general de alias de tipos. Se puede usar para plantillas y para tipos concretos. Se reutiliza palabra reservada using. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 63/99

156 Un mundo genérico y concurrente Alias de plantillas Alias template <class T> using mi_vector = std::vector<t, mi_allocator<t>>; mi_vector<int> v1; mi_vector<double> v2; template <class T> void f(mi_vector<t> & v) { /*...*/ } int main() { using numero = int; mi_vector<numero> v(42); f(v); } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 64/99

157 Un mundo genérico y concurrente Concurrencia en C Un mundo genérico y concurrente Expresiones lambda Alias de plantillas Concurrencia en C++11 Hilos Tareas asíncronas J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 65/99

158 Un mundo genérico y concurrente Concurrencia en C++11 Por qué un modelo de concurrencia? C++11 ofrece un modelo de concurrencia propio. Cualquier implementación que cumple con el estándar debe proporcionarlo. Resuelve problemas inherentes a PThreads. Portabilidad de código concurrente: Windows, POSIX,... Implicaciones: Modificaciones en el lenguaje. Modificaciones en la biblioteca estándar. Influencia sobre C11 (ISO/IEC 9899:2011). Nota: No incluye un modelo estándar de paralelismo. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 66/99

159 Un mundo genérico y concurrente Concurrencia en C++11 Qué ofrece C++11? Un modelo de memoria propio. Soporte portable para programación libre de cerrojos. Tipos atómicos. Operaciones de muy bajo nivel. Programación fuertemente tipada con hilos y cerrojos. Un modelo simplificado de alta abstracción. Conjunto de abstracciones. thread. mutex. lock. packaged_task. future. async. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 67/99

160 Un mundo genérico y concurrente Hilos 4 Un mundo genérico y concurrente Expresiones lambda Alias de plantillas Concurrencia en C++11 Hilos Tareas asíncronas J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 68/99

161 Un mundo genérico y concurrente Hilos Lanzamiento de hilos Clase std::thread gestor del recurso hilo. void f1(); void f2(); struct f3 { void operator()(); }; void g() { thread t1{f1}; // Ejecuta f1() en un hilo thread t2{[] {f2();}}; // Ejecuta lambda en un hilo thread t3{f3()}; // Ejecuta f3::operator()() en un hilo t1.join(); // Espera a t1 t2.join(); // Espera a t2 t3.join(); // Espera a t3 } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 69/99

162 Un mundo genérico y concurrente Hilos Paso de argumentos Paso de arguemntos sin necesidad de casts. void f1(int x, double y); struct f2 { f2(int px) : x{px} {} void operator()(); int x; }; void g() { thread t1{f1, 2, 3.5}; // Lanza hilo con f1(2,3.5); thread t2{[] { f1(2,3.5); }}; // Lanza hilo con lambda thread t3{f2{42}}; // Lanza hilo con f2{42}.operator()() t1.join(); t2.join(); t3.join(); } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 70/99

163 Un mundo genérico y concurrente Tareas asíncronas 4 Un mundo genérico y concurrente Expresiones lambda Alias de plantillas Concurrencia en C++11 Hilos Tareas asíncronas J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 71/99

164 Un mundo genérico y concurrente Tareas asíncronas Una tarea asíncrona permite el lanzamiento simple de ejecución de una tarea. En otro hilo de ejecución. Como una tarea diferida. Un futuro es un objeto que permite que un hilo pueda devolver un valor a la sección de código que lo invocó. int main() { std::future<int> r = std::async(tarea, 1, 10); hacer_otra_cosa(); std::cout << r.get() << std::endl; return 0; } J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 72/99

165 Caso práctico 1 Bienvenido a C Un C++ más fácil de aprender y enseñar 3 Un patrón: RAII 4 Un mundo genérico y concurrente 5 Caso práctico 6 Para saber más 7 Y después? J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 73/99

166 Caso práctico Problema 5 Caso práctico Problema Resultados J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 74/99

167 Caso práctico Problema Why Code in C Anymore? why-code-in-c-anymore/ Performance. The computer benchmarks hosted on Alioth, for example, show that C++ (running on 32-bit Linux) runs the series of tests 27 % slower than C. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 75/99

168 Caso práctico Problema Why Code in C Anymore? why-code-in-c-anymore/ Performance. The computer benchmarks hosted on Alioth, for example, show that C++ (running on 32-bit Linux) runs the series of tests 27 % slower than C. De verdad? J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 75/99

169 Caso práctico Problema Asunciones y objetivos Asunciones: C++ es más lento que C. La abstracción siempre conlleva una penalización de rendimiento. El mejor rendimiento se obtiene con optimizaciones de bajo nivel. Distintos enfoques requieren distintas versiones de código. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 76/99

170 Caso práctico Problema Asunciones y objetivos Asunciones: C++ es más lento que C. La abstracción siempre conlleva una penalización de rendimiento. El mejor rendimiento se obtiene con optimizaciones de bajo nivel. Distintos enfoques requieren distintas versiones de código. Objetivos: 1 Explorar la penalización de rendimiento derivada de la abstracción. 2 Explorar capacidades de C Framework de experimentación para optimizaciones. 4 Código fuente agnóstico sobre paralelismo. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 76/99

171 Caso práctico Problema Fluidanimate Parte del benchmark PARSEC (Univ. Princeton). Desarrollado originalmente por Intel. Simulación de fluidos no comprimibles. Simula interacciones entre partículas a lo largo del tiempo. Versiones: Serie, PThreads, Intel TBB. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 77/99

172 Caso práctico Problema Fluidanimate Parte del benchmark PARSEC (Univ. Princeton). Desarrollado originalmente por Intel. Simulación de fluidos no comprimibles. Simula interacciones entre partículas a lo largo del tiempo. Versiones: Serie, PThreads, Intel TBB. Carcterísticas: Mucho uso de preprocesador. Uso extensivo de variables globales como optimización. Uso de memory pool ad-hoc. Algunos problemas de portabilidad y comportamiento no definido. Funciones con altísima complejidad ciclomática. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 77/99

173 Caso práctico Problema Principios Refactorización. J. Daniel Garcia 78/99

174 Caso práctico Problema Principios Refactorización. Rendimiento. J. Daniel Garcia 78/99

175 Caso práctico Problema Principios Refactorización. Rendimiento. Mantenibilidad. J. Daniel Garcia 78/99

176 Caso práctico Problema Principios Refactorización. Rendimiento. Mantenibilidad. El paralelismo debería estar tan oculto como sea posible. J. Daniel Garcia 78/99

177 Caso práctico Problema Principios Refactorización. Rendimiento. Mantenibilidad. El paralelismo debería estar tan oculto como sea posible. El código de aplicación debería concentrarse en el dominio del problema. J. Daniel Garcia 78/99

178 Caso práctico Problema Principios Refactorización. Rendimiento. Mantenibilidad. El paralelismo debería estar tan oculto como sea posible. El código de aplicación debería concentrarse en el dominio del problema. YAPL (Yet Another Parallel Library). J. Daniel Garcia 78/99

179 Caso práctico Problema Principios Refactorización. Rendimiento. Mantenibilidad. El paralelismo debería estar tan oculto como sea posible. El código de aplicación debería concentrarse en el dominio del problema. YAPL (Yet Another Parallel Library). El código de aplicación debería ser idéntico en modos secuencial y paralelo. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 78/99

180 Caso práctico Problema Principios Refactorización. Rendimiento. Mantenibilidad. El paralelismo debería estar tan oculto como sea posible. El código de aplicación debería concentrarse en el dominio del problema. YAPL (Yet Another Parallel Library). El código de aplicación debería ser idéntico en modos secuencial y paralelo. Se debería separar la abstracción de contenedor (ej. lista) del la estructura que la implementa (una lista enlazada de nodos, un vector, un deque,...). J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 78/99

181 Caso práctico Problema Principios Refactorización. Rendimiento. Mantenibilidad. El paralelismo debería estar tan oculto como sea posible. El código de aplicación debería concentrarse en el dominio del problema. YAPL (Yet Another Parallel Library). El código de aplicación debería ser idéntico en modos secuencial y paralelo. Se debería separar la abstracción de contenedor (ej. lista) del la estructura que la implementa (una lista enlazada de nodos, un vector, un deque,...). Adios a los iteradores! J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 78/99

182 Caso práctico Problema Principios Refactorización. Rendimiento. Mantenibilidad. El paralelismo debería estar tan oculto como sea posible. El código de aplicación debería concentrarse en el dominio del problema. YAPL (Yet Another Parallel Library). El código de aplicación debería ser idéntico en modos secuencial y paralelo. Se debería separar la abstracción de contenedor (ej. lista) del la estructura que la implementa (una lista enlazada de nodos, un vector, un deque,...). Adios a los iteradores! Muchas políticas son potencialmente posibles. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 78/99

183 Caso práctico Resultados 5 Caso práctico Problema Resultados J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 79/99

184 Caso práctico Resultados Métricas de código Metric Original Refactored Lines Effective LOC Logical LOC Functions Max Cyclomatic Complexity 33 8 Average Cycolomatic Complexity Classes 6 16 Max Cyclomatic Complexity Average Cyclomatic Complexity J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 80/99

185 Caso práctico Resultados Ejecución secuencial: Tiempo por iteración Normalized Execution time (us) 10 5,7 10 5, ,6 10 5, ,000 1,500 2,000 Iterations original refactored J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 81/99

186 Caso práctico Resultados Refactored code speedup 1,18 1,16 Speedup 1,14 1,12 1,1 1, ,000 1,500 2,000 Iterations J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 82/99

187 Caso práctico Resultados Execution time per iteration (4 cores, 8 threads) Normalized Execution time (us) 10 5,3 10 5,2 original refactored Iterations J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 83/99

188 Caso práctico Resultados Refactored speedup (4 cores, 8 threads) 1,55 Speedup 1,5 1, Iterations J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 84/99

189 Caso práctico Resultados Global execution time vs threads (500 iterations, 4 cores) Execution time (us) 10 8,4 10 8, original refactored J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 85/99

190 Caso práctico Resultados Counters (sequential version) Counter Original Refactored Ratio instructions cache-references cache-misses branch-instructions branch-misses L1-dcache-loads L1-dcache-load-misses L1-dcache-stores L1-dcache-store-misses L1-icache-loads L1-icache-load-misses LLC-loads LLC-load-misses LLC-stores LLC-store-misses J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 86/99

191 Caso práctico Resultados Conclusiones Resultados: Código más compacto y menos complejo. Ligero incremento de rendimiento en versiones secuenciales. Importante incremento de rendimiento en versiones paralelas. Generación de código más compacto y menor número de bifuraciones. Mejor comportamiento en utilización de memoria caché. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 87/99

192 Caso práctico Resultados Conclusiones Resultados: Código más compacto y menos complejo. Ligero incremento de rendimiento en versiones secuenciales. Importante incremento de rendimiento en versiones paralelas. Generación de código más compacto y menor número de bifuraciones. Mejor comportamiento en utilización de memoria caché. Trabajo en curso: Improving performance and maintainability through refactoring in C++11. J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 87/99

193 Para saber más 1 Bienvenido a C Un C++ más fácil de aprender y enseñar 3 Un patrón: RAII 4 Un mundo genérico y concurrente 5 Caso práctico 6 Para saber más 7 Y después? J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 88/99

194 Para saber más Referencias 6 Para saber más Referencias C++11 para desarrolladores C++ J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 89/99

195 Para saber más Referencias Libros J. Daniel Garcia 90/99

196 Para saber más Referencias J. Daniel Garcia 91/99