Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

El lenguaje de pogramación C++

2,192 views

Published on

Diapositivas de la formación de C++ que imparto de vez en cuando. No están totalmente actualizadas, pero cubren hasta C++ 11, las pequeñas mejoras en C++ 14 no están.

Published in: Software
  • Be the first to comment

El lenguaje de pogramación C++

  1. 1. C++ Rodrigo Corral rcorral@plainconcepts.com
  2. 2. Conceptos básicos: Tipos • Tipos fundamentales – Enteros bool: 1 byte, el estandar no especifica tamaño char, unsigned char, signed char: 1 byte, caracteres ASCII short, unsigned short: 2 bytes, >= char, <= int int, unsigned int: 4 bytes, >= short, <= long __intn: 8, 16, 32, 64, or 128 bits según el valor de n, especifico de MS long, unsigned long: 4 bytes, >= int long long: 8 bytes, > long – Flotantes float: 4 bytes, más pequeño flotante double: 8 bytes, >= float long double: == double – Unicode: __wchar_t: nativo o unsigned short
  3. 3. Conceptos básicos: Literales • Cadenas – char[], wchar[] – Literales: char c = “a”; __wchar_t w = L”a”; tchar t =_T(“a”); – Caracteres de escape: n: nueva línea ?: interrogación t: tab horizontal ’: comilla simple v: tab vertical ’’: comilla doble b: backspace ooo: nmero octal r: retorno de carro xhhh: número hex f: pie de formulario 0: null a: alerta : barra
  4. 4. Conceptos básicos: enumeraciones, estructuras y clases * Solo un miembro puede ser usado en un momento dado struct class union * public private public
  5. 5. Conceptos básicos: sentencias de control • if ( expression ) statement [else statement] • switch ( expression ) case constant-expression : statement [default : statement] • while ( expression ) statement • do statement while ( expression ) ;
  6. 6. Conceptos básicos: sentencias de control • for ( init-expression ; cond-expression ; loop- expression) statement • break • continue • return • goto
  7. 7. Gestión de memoria: aéreas • Code Segment: Almacena el código ejecutable del programa • Data Segment: Almacena los datos globales. • Stack Segment: Almacena variables locales, parámetros y variables temporales. void f(int i /*stack*/) { int j = 0; //stack void* pint = new BYTE[1]; //heap!! }
  8. 8. Gestión de memoria: new y delete • new: asigna memoria – std::bad_alloc • delete, delete[]: libera memoria • new sin delete == fuga de memoria!!! • Son sobrecargables, casi siempre innecesario • Llama al destructor
  9. 9. Gestión de memoria: smart pointers • Evitar la complejidad de usar memoria dinámica (o contaje de referencias) • Parece un puntero (patrón proxy, wrapper) • Estándar: auto_ptr, unique_ptr • ¿Qué aporta? – Limpieza e inicialización automáticas – Exception safety – Evitar ‘dangling pointers’: NULL cuando se copia MyClass* p(new MyClass); MyClass* q = p; delete p; p->DoSomething(); // Watch out! p is now dangling! p = NULL; // p is no longer dangling q->DoSomething(); // Ouch! q is still dangling!
  10. 10. Gestión de memoria: smart pointers • Limitaciones: class MyClass { unique_ptr<int> p; // ... }; MyClass x; MyClass y = x; // x.p now has a NULL pointer No se puede usar con contenedores de STL porque manejan los punteros por valor (copia). Workarround: contenedores de punteros. Mejor: Otros tipos de smart pointers: refernce counting, linking, punteros de la librería boost, que veremos más adelante. std::auto_ptr ha muerto, deprecated
  11. 11. Nuevos smart pointer • #include <memory> • std::unique_ptr<> – Elección por defecto – Un solo propietario (eleccipor defecto) • std::shared_ptr<> – Varios propietarios – P.e.: Devolver una copia de un puntero y conservarlo (contenedores). – Contaje de referencias. • std::weak_ptr<> – Evita problemas con referencias cíclicas.
  12. 12. Demo Smart Pointers
  13. 13. OOP: Clases • Clase: Una clase es un contenedor de uno o más datos (variables o propiedades miembro) junto a las operaciones de manipulación de dichos datos (funciones/métodos miembro). • Objeto: instanciación de la clase. • Encapsulación: Solo se manipula el estado de la clase a través de la interfaz definida por sus métodos miembro. • Convención: declaración en .h definición en .cpp class tipo { [acceso:] miembros }
  14. 14. OOP: Clases • Constructores: inicializan el objeto class T { public: T(); T(U u, V v); } • Constructor copia T::T(const T &) { } • Operador asignación T &T::operator=(const T &) { … return *this; }
  15. 15. OOP: Clases • Destructores virtual ~T() • Habituales en clases con miembros que son punteros • Ideales para liberar recursos
  16. 16. OOP: Clases • Métodos – Miembros: public, private, protected – Friend, solo se usa en sobrecarga de operadores – Sobrecarga – Parámetros por defecto
  17. 17. Demo Clase fecha
  18. 18. OOP: Herencia • Herencia – Publica , privada – Simple, múltiple • Redefinición de funciones • Polimorfismo, funciones virtuales • Funciones virtuales puras
  19. 19. Demo Jerarquía de polígonos, áreas y formas
  20. 20. OOP: Miscelanea • Namespaces • typedef type-declaration synonym; typedef struct _POINT { unsigned x; unsigned y; } POINT; permite: POINT p en lugar de struct _POINT p • RTTI – Operador typeid – Clase type_info, no instanciable, no copiable – /GR (Enable Run-Time Type Information)
  21. 21. OOP: Miscelanea • Cast – C style: churras en merinas, error en tiempo de ejecución. No es ‘type safe’. – const_cast: si es const será por algo – dynamic_cast • Solo para tipos polimórficos (al menos un miembro virtual) • Hacia abajo por la jerarquía: en tiempo de ejecución • Hacia arriba por la jerarquía: en tiempo de compilación
  22. 22. OOP: Miscelanea • Cast – static_cast, jerarquías no polimórficas o clases no relacionadas. No fallará en tiempo de ejecución nunca. – reinterpret_cast, si todo lo demás falla. void, no es type safe precisamente. Síntoma de mal diseño. – Estrategia: usar static_cast y ver que dice el compilador.
  23. 23. Demo Miscelanea
  24. 24. OOP: Exception safety • Tratamiento de excepciones: try, catch • Jerarquías de excepciones • Adquisición segura de recursos class CResourceManager { //Constructor adquiere recurso //Destructor adquiere recurso }
  25. 25. OOP: Exception safety • Tres niveles de exception safety – ‘Basic Guarantee’: Si se lanza una excepción, no se fugará ningún recurso, y los objetos permanecerá en un estado destructible y usable, aunque no necesariamente predecible. Es el nivel más débil de ‘exception safety’, y es apropiado cuando el cliente puede lidiar con operaciones fallidas que ya han realizado cambios en el estado del objeto. – ‘Strong Guarantee’: Si se lanza una excepción, el estado del programa permanece sin cambio. Este nivel implica semantica de transaccionalidad, e incluye que las referencias o iteradores dentro de un contenedor serán invalidadas si una operación falla. – ‘Nothrow Guarantee’: La función no emitirá una excepción bajo ninguna circustancia. Ocurre que es imposible implementar las garantias anteriores si ciertas funciones no garantizan que no lanzarán excepciones (p.e. destructores). P.e: ninguna operación de auto_ptr lanza excepción alguna.
  26. 26. OOP: Exception safety • Exception safe copy – Dos pasos: • Primero, proporcionar una función Swap() que no lanza excepciones y que intercambia el estado de los objetos void T::Swap( T& other ) throw() { //intercambiar el estado entre *this y other } • Segundo, implementar el operator=() usando del idioma “crear un temporal e intercambiar": T& T::operator=( const T& other ) { T temp( other ); // realizar la operación // hacer ‘commit’ sin lanzar excepciones Swap( temp ); return *this; }
  27. 27. OOP: Exception safety • Herencia y Exception safety – U implementado en terminos de T si U usa T en su implementación de cualquier manera – Si U esta implementado en terminos de T, la seguridad frente a excepciones de T depende de U class T : private U { // ... }; T& T::operator=( const T& other ) { U::operator=( other ); // ??? return *this; } – Solución: agregación en lugar de herencia.
  28. 28. OOP: Exception safety • Herencia y Exception safety • Solución: agregación en lugar de herencia. class T { // ... private: U* u_; }; T& T::operator=( const T& other ) { U* temp = new U( *other.u_ ); // realizar la copia lateral delete u_; // hacer ‘commit’ de la operación u_ = temp; // usando solo operaciones que no lazan excepciones return *this; }
  29. 29. OOP: Exception safety • Excepciones en constructores // Very Buggy Class class X : Y { T* t_; Z* z_; public: X() try : Y(1) , t_( new T( static_cast<Y*>(this) ) , z_( new Z( static_cast<Y*>(this), t_ ) ) { /*...*/ } catch(...) // Y::Y or T::T or Z::Z or X::X's body has thrown { // Q: should I delete t_ or z_? (note: not legal C++) } };
  30. 30. OOP: Exception safety • Excepciones en constructores – Constructor try-catch, de nula utilidad – NO usar la lista de inicializadores para adquirir recursos – Utilizar try catch en el cuerpo del constructor o destructor para limpiar recursos – Utilizar RAII - Resource Acquisition Is Initialization
  31. 31. OOP: Exception safety • RAII class LogFile { public: // exception classes class FileFailedToOpen { }; class WriteFailure { }; LogFile(const char* fileName) : // initialize data member with the file handle m_file( OpenFile(fileName) ) { // handle errors automatically if( m_file == INVALID_HANDLE ) throw FileFailedToOpen(); } ~LogFile() { CloseFile(m_file); } void write(const char* logLine) { WriteFile( m_file, logLine ); if(error) throw WriteFailure(); } private : FILE_HANDLE m_file; // avoid copying by declaring a private but unimplemented // copy-constructor and assignment operator LogFile (const LogFile&); LogFile& operator= (const LogFile&); };
  32. 32. Excepciones base
  33. 33. Demo Excepciones
  34. 34. Templates • Una clase no genérica class String { //… public: String(); String(const char*); String(const String&); char GetPos(uint i) const; }
  35. 35. Templates • Una clase genérica template<class T> class String { //… public: String(); String(const T*); String(const String&); T GetPos(uint i) const } • Nos pemite hacer: String<char> charString; String<tchar> tcharString; String<wchar> wcharString
  36. 36. Templates • Una clase generada desde un template es un nuevo tipo. • Nada lo diferencia de otro tipos no genéricos. • Aproximación a la implementación: Generalizar una clase concreta. • Instanciación de templates: trabajo del compilador String<char> cs; //El compilador genera el código
  37. 37. Templates • Template parameters – Pueden ser tipos o parámetros ordinarios template<class T, int size> class C { }; – Se puede usar un parámetro de tipo en la definición de otros parámetros template<class T, T default> class C { }; – Equivalencia de tipos typedef char CHAR; String<char> s1; String<CHAR> s2;
  38. 38. Templates • Type checking – Errores de sintaxis: en el momento de compilación del template – Errores relacionados con los parametros tipo: en el momento de la instanciación (firs point of instantation) template<class T> class Vector{ void Dump { for (int i = 0; i < _numElem; ++i) _elem[i].Dump(); }
  39. 39. Templates • Function templates template<class T> void sort(vector<T>&) – Los parámetros se deducen de los tipo de los argumentos template<class T, int i> T& search(buffer<T,i>, int j) typedef ByteBuffer buffer<BYTE, 128>; ByteBuffer b; shearch(b, 64); – No siempre es posible template<class T> T& create(); CPerson c = create<CPerson>();
  40. 40. Templates • Function templates template<class T> void sort(vector<T>&) – Los parámetros se deducen de los tipo de los argumentos template<class T, int i> T& search(buffer<T,i>, int j) typedef ByteBuffer buffer<BYTE, 128>; ByteBuffer b; shearch(b, 64); – No siempre es posible template<class T> T& create(); CPerson c = create<CPerson>(); Habitual para el tipo retornado
  41. 41. Templates • Function templates template<class T> void sort(vector<T>&) – Los parámetros se deducen de los tipo de los argumentos template<class T, int i> T& search(buffer<T,i>, int j) typedef ByteBuffer buffer<BYTE, 128>; ByteBuffer b; shearch(b, 64); – No siempre es posible template<class T> T& create(); CPerson c = create<CPerson>();
  42. 42. Templates • Especialización – Por defecto, una implementación para todos los parámetros Tipo – Nos puede interesar una diferente implementación para ciertos tipos – Evita ‘code bloat’, especialmente usando punteros Vector<int*> vi; Vector<CPerson*> vp; Vector <char *> Solución: especialización para tipos puntero template<> class Vector<int*> { }; //Total template<T> class Vector<T*> { }; //Parcial
  43. 43. Templates • Especialización – También para funciones
  44. 44. Templates • Polimorfismo estático – Clases abstractas – Sobrecarga de operadores – Templates: NO TIENEN vTable!!!
  45. 45. Demo Templates
  46. 46. STL • Librería estándar de C++ basa en Templates. • Proporciona: – Clases útiles (string, streams, etc…) – Contenedores e iteradores – Algoritmos
  47. 47. STL: Contenedores e iteradores HIGH = first element current_element = second element while current_element is within the group of elements if current_element > HIGH, then HIGH = current_element Advance to the next element end while • Pseudo-código válido con independencia: – Del tipo de elementos – De como se almacenen
  48. 48. STL: Contenedores e iteradores vector<int>::iterator current = values.begin(); int high = *current++; while (current != values.end()) { if (*current > high) { high = *current; } current++; }
  49. 49. STL: Contenedores habituales • Secuencias – vector: array, equivalencia vector/array: &foo[0] – list: lista doblemente linkada. – queue: FIFO – deque: estructura similar a un array con eliminación y adición eficiente de elementos en ambos extremos. – stack: LIFO (last in, first out) structure. – priority_queue: cola priorizada. • Asociativos – set: conjunto de elementos únicos. – multiset: conjunto de elementos. – map: diccionario de valores únicos – multimap: diccionario de valores. – Variaciones basadas en hash: búsqueda optimizada en conjuntos muy grandes.
  50. 50. STL: Funciones habituales • Inserción y extracción de elementos: – push_front: Inserta un elemento al principio, no disponible para vectores. – pop_front: Elimina un elemento al principio, no disponible para vectores. – push_back : Inserta un elemento al final. – pop_back: Eliminar un elemento al final. • Otros miembros: – empty: Indica si el contenedor está vacio. – size: Devuelve el número de elementos. – insert: Inserta un elemento en una determinada posición. – erase: Elimina elementos. – clear: Elimina todos los elementos . – resize: Cambia el tamaño del contenedor. – front: Referencia al primer elemento. – back: Referencia al último elemento. • Para las secuencias: [] y at, permite acceso directo a un elemento.
  51. 51. STL: Iteradores • Container<T>::iterator begin(); Container<T >::iterator end(); • Container<T >::const_iterator begin() const; Container<T >::const_iterator end() const; • for each (soporte añadido por el compilador, azúcar sintáctico).
  52. 52. Demo Contenedores e iteradores
  53. 53. STL: Algoritmos • ¡Cientos de algoritmos a nuestra disposición! • Tipos: – Búquedas – Recorridos. – Ordeando. – Elimiación de elementos. • Hacen uso intensivo de iteradores. • También se pueden usar con arrays y con punteros. • Principalmente en <algoritm> y <numeric>.
  54. 54. STL: Algoritmos habituales • for_each: Realiza una operación sobre cada elemento. • find: Busca la primera ocurencia de un valor. • find_if: Busca el primer elemento que cumple cierta condición. • find_first_of: Busca el primer elmento de un contenedor en otro. • adjacent_find: Busca la primera ocurrencia de valores adjacentes iguales. • count: Cuenta las ocurrencias de un valor. • count_if: Cuenta las ocurrencias que cumplen una determinada condición. • accumulate: Suma los elementos de un contenedor. • equal: Compara dos rangos. • max_element: Busca el mayor elemento. • min_element: Busca el menor elemento.
  55. 55. STL: Algoritmos habituales • transform: Aplica una operación de transformación a los elementos de un contenedor. • copy: Copia un contenedor. • replace: Remplaza los elementos del contenedor. • replace_if: Remplaza los elementos que cumplen una condición. • remove: Elimina elementos. • remove_if: Elimina elementos que cumplen una condición. • reverse: Invierte el orden de los elementos. • random_shuffle: Ordena aleatoriamente los elementos. • fill: Llena un contenedor con un determinado valor. • generate: Llena un contenedor con el resultado de una operación.
  56. 56. STL: Algoritmos habituales • sort: Ordena los elementos. • stable_sort: Ordena manteniendo el orden de elementos iguales. • nth_element: Pone el elemento n en el lugar que le corresponde. • binary_search: Busca un valor mediante búsqueda binaria.
  57. 57. Demo Algoritmos y Bind
  58. 58. Expresiones Lambda 1. Clausula de captura 2. Lista de parámetros 3. Especificación de mutabilidad 4. Declaración de excepciones 5. Tipo retornado 6. Cuerpo
  59. 59. Demo Lambdas
  60. 60. Demo OpenMP
  61. 61. Async y futures • std::async(std::launch::async, []{ f(); }); – std::launch::async -> evaluación asíncrona – std::launch::deferred -> evaluación perezosa • std::packaged_task -> envuelve cualquier elemento invocable para poderlo invocar asíncronamente. • std::future -> acceso al resultado de una operación asícrona.
  62. 62. Thread • Representan un nuevo hilo de ejecución. • Se alimentantan de un ‘puntero a función’. • El namespace thread::this_thread permite domir hilos, saber el id, hacer yield…
  63. 63. Sincronización • mutex: Acceso exclusivo. • lock, lock_guard: Bloqueo sobre uno/varios objetos bloqueables. El hilo solo avanza si puede obtener el lock. • Condition variables: comunicación entre hilos.
  64. 64. Demo Threads
  65. 65. Expresiones regulares • #include <regex> • regex_match • regex_search • regex_replace
  66. 66. Demo Expresiones regulares
  67. 67. Novedades C++ 11 • Expresiones constantes constexpr int dame_cinco() {return 5;} int algun_valor[dame_cinco() + 7]; constexpr double aceleracion_de_gravedad = 9.8; constexpr double gravedad_lunar = aceleracion_de_gravedad / 6.0; • Incialización rapida y de listas struct Objeto { float primero; int segundo; }; Objeto escalar = {0.43f, 10}; // Un objeto, con primero=0.43f y segundo=10 Objeto matriz[] = {{13.4f, 3}, {43.28f, 29}, {5.934f, 17}}; // Una matriz con tres objetos std::vector<std::string> v = { "xyzzy", "plugh", "abracadabra" }; std::vector<std::string> v{ "xyzzy", "plugh", "abracadabra" };
  68. 68. Novedades C++ 11 • Inferencia de tipos auto algun_extraño_tipo_llamable = boost::bind(&alguna_funcion, _2, _1, algun_objeto); auto otra_variable = 5; int un_entero; decltype(un_entero) otro_entero = 5; //En tiempo de compilación
  69. 69. Novedades C++ 11 • Llamadas entre constructores class AlgunTipo { int _num; public: AlgunTipo(int num) : numero(num) {} AlgunTipo() : AlgunTipo(42) {} };
  70. 70. Novedades C++ 11 • Herencia de constructores class ClaseBase { public: ClaseBase(int valor); }; class ClaseDerivada : public ClaseBase { public: using ClaseBase::ClaseBase; };
  71. 71. Novedades C++ 11 • Override struct Base { virtual void f(float); }; struct Derivada : Base { virtual void f(int) override; //Error }; • Final -> sellado de herencia struct Base1 final { }; struct Derivada1 : Base1 { }; //Error struct Base2 { virtual void f() final; }; struct Derivada2 : Base2 { void f(); //Error };
  72. 72. Noveades C++ 11 • Constante de puntero nulo char *pc = nullptr; // OK int *pi = nullptr; // OK bool b = nullptr; // OK. b es false. int i = nullptr; // error foo(nullptr); // invoca foo(char *), no foo(int);
  73. 73. Novedades C++ 11 • Nuevos tipos de literales – L"I'm a wchar_t string." – u8"I'm a UTF-8 string." – u“I'm a UTF-16 string." – U"I'm a UTF-32 string.“ • Evitar caracteres de escape – R"(The String Data Stuff " )" – R"delimiter(The String Data Stuff " )delimiter" wchar_t
  74. 74. Referencias • http://en.cppreference.com/w/ • http://www.cplusplus.com/
  75. 75. © 2005 Plain Concepts. All rights reserved. This presentation is for informational purposes only. Plain Concepts makes no warranties, express or implied, in this summary.

×