Trampas en c ++
Upcoming SlideShare
Loading in...5
×
 

Trampas en c ++

on

  • 659 views

 

Statistics

Views

Total Views
659
Views on SlideShare
534
Embed Views
125

Actions

Likes
0
Downloads
1
Comments
0

20 Embeds 125

http://dtq4.blogspot.com 47
http://dtq4.blogspot.de 16
http://www.dtq4.com 13
http://www.dsm4.es 9
http://dtq4.blogspot.fr 8
http://dtq4.blogspot.com.br 6
http://dtq4.blogspot.co.at 3
http://dtq4.blogspot.ca 3
http://dtq4.blogspot.hu 3
http://dtq4.blogspot.nl 2
http://dtq4.blogspot.ru 2
http://dtq4.blogspot.kr 2
http://dtq4.blogspot.co.nz 2
http://dtq4.blogspot.com.ar 2
http://dtq4.blogspot.sg 2
http://dtq4.blogspot.co.uk 1
http://dtq4.blogspot.com.au 1
http://dtq4.blogspot.no 1
http://dtq4.blogspot.com.es 1
http://dtq4.blogspot.gr 1
More...

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Trampas en c ++ Trampas en c ++ Presentation Transcript

  • Desayunos Técnicos Trampas en C++
  • Desayunos Técnicos Trampas en C++ "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do, it blows away your whole leg." Bjarne Stroustrup ¿Qué es C++?
    • C++ es un lenguaje de programación diseñado a mediados de los 80 por Bjarne Stroustrup.
    • Lenguaje de programación muy popular, solo por detrás de Java y C.
    • El código que compila en C++ no tiene por qué ser correcto.
  • Desayunos Técnicos Trampas en C++ ¿Trampas en C++?
    • C++ esconde una gran cantidad de trampas, es complejo y a menudo los errores se encuentran muy escondidos.
    • El desayuno técnico propondrá a los participantes un juego en grupos para descubrir algunas trampas de C++.
    • Se plantea una trampa en C++, a continuación se presentan una serie de respuestas posibles en modo ‘múltiple elección’.
      • Opción1
      • Opción2
      • Opción3
      • Opción4
    • Bjarne Stroustrup nos ilustra con aclaraciones correctas y fallos típicos
    • Opción correcta Nº2: Explicación al problema
    • Moraleja: Fallos típicos ante este tipo de problema.
  • Desayunos Técnicos Trampas en C++ TR1 – Nivel 1 void main() {    char *s = "hola!";    s[0] = 'm';    printf ("%sn", s); } ¿Cuál será la salida del programa? 1) Error de compilación. 2) hola! 3) Error de ejecución. 4) mola!
  • Desayunos Técnicos Trampas en C++ TR1 – Nivel 1
    • Bjarne Stroustrup nos ilustra con aclaraciones correctas y fallos típicos
    • Opción correcta Nº3: La variable local “s” es un puntero, no un string. El compilador utiliza “hola” como un string constante, lo aloca en memoria read-only.
    • Moraleja: Utilizar “char s[]” en vez de “char *s”.
    3!
  • Desayunos Técnicos Trampas en C++ TR2 – Nivel 1 class A1 { virtual ~A1() { printf ("A1,"); } }; class A2 { ~A2() { printf ("A2,");} }; class B1 : public A1 { ~B1() { printf ("B1,");} }; class B2 : public A2 { ~B2() { printf ("B2,");} }; B1* b1 = new B1(); delete b1; B2* b2 = new B2(); delete b2; A1* ab1 = new B1(); delete ab1; A2* ab2 = new B2(); delete ab2; ¿Cuál será la salida del programa? 1) B1, B2, A1, A2, 2) B1, A1, B2, A2, B1, A1, B2, A2, 3) B1, A1, B2, A2, B1, A1, A2, 4) B1, A1, B2, A2, A1, A2,
  • Desayunos Técnicos Trampas en C++ TR2 – Nivel 1
    • Bjarne Stroustrup nos ilustra con aclaraciones correctas y fallos típicos
    • Opción correcta Nº3: Solo si el destructor es virtual destruir a través de un puntero clase base destruirá los miembros de la clase derivada.
    • Moraleja: Si una clase está pensada para derivar de ella deberá tener, al menos, un destructor virtual.
    3!
  • Desayunos Técnicos Trampas en C++ TR3 – Nivel 1 struct MyStruct { int array[4]; int n1; int n2; }; int main () {  MyStruct str; str.n1 = 10; str.n2 = 20;  str.array[3] = 3; str.array[5] = 5; printf ("%dn",str.n1); printf ("%dn",str.n2); printf ("%dn",str.array[3]); printf ("%dn",str.array[5]); } ¿Cuál será la salida del programa? 1) Error de compilación 2) 10, 5, 3, 5 3) Error en tiempo de ejecución 4) 10, 20, 3, 5 5) 10, 20, 3, Basura (variable sin inicializar)
  • Desayunos Técnicos Trampas en C++ TR3 – Nivel 1
    • Bjarne Stroustrup nos ilustra con aclaraciones correctas y fallos típicos
    • Opción correcta Nº2: Utilizar índices de arrays es como utilizar punteros. Se accede a “lo que toque” en esa memoria.
    • Moraleja: Nadie (compilador, runtime) pone límites a los array. Mucho cuidado al utilizarlos.
    2!
  • Desayunos Técnicos Trampas en C++ TR4 – Nivel 1 void main () { int *array = getArray (); printf (“%dn",array[0]); algoritmo (); printf ("%dn",array[0]); } int * getArray () { int a[3] = {1, 2, 3}; printf("%dn", a[0]); return a; } void algoritmo () { int datos[10] = {11,12,13,14,15,16,17,18,19,20}; int n = datos[2] + datos[3] * datos[7]; printf ("blah blah blah n"); } ¿Cuál será la salida de este programa? 1) 1, ‘INDEFINIDO’, blah blah blah, ‘INDEFINIDO’ 2) 1, ‘INDEFINIDO’, blah blah blah, 1 3) Error en tiempo de ejecución 4) 1, 1, blah blah blah, 1 5) 1, 1, blah blah blah, ‘INDEFINIDO’
  • Desayunos Técnicos Trampas en C++ TR4 – Nivel 1
    • Bjarne Stroustrup nos ilustra con aclaraciones correctas y fallos típicos
    • Opción correcta Nº5: Los valores quedan en un principio en memoria, pero los puede sobrescribir alguna otra función que utilice esa región del stack.
    • Moraleja: Nunca devolver punteros o arrays locales.
    5!
  • Desayunos Técnicos Trampas en C++ TR5 – Nivel 1 ¿Cuál será la salida del programa? 1) 1, 1, 1, 1, 1, 1 2) 0, 0, 0, 0, 0, 0 3) 0, 0, 1, 1, 0, 0 4) 0, 0, 1, 1, 1, 1 struct Point {  int x, y; }; struct Data { Point point; Point *ppoint; int array[2]; }; void main() { Point p = {0,0}; Data d1,d2; d1.point.x = 0; d1.point.y = 0; d1.ppoint = &p; d1.array[0] = 0; d1.array[1] = 0; d2 = d1; d1.point.x = 1; d1.point.y = 1; p.x = 1; p.y = 1; d1.array[0] = 1; d1.array[1] = 1; printf ("%dt %dn", d2.point.x, d2.point.y); printf ("%dt %dn", d2.ppoint->x,d2.ppoint->y); printf ("%dt %dn", d2.array[0],d2.array[1]); }
  • Desayunos Técnicos Trampas en C++ TR5 – Nivel 1
    • Bjarne Stroustrup nos ilustra con aclaraciones correctas y fallos típicos
    • Opción correcta Nº3: Aunque la variable de un array sea equivalente a un puntero, aquí su memoria está reservada dentro del struct, por lo que se copian los contenidos físicamente.
    • Moraleja:
      • La copia de un struct hace un “shallow copy”, exactamente igual al operador de copia por defecto de las clases.
      • La copia equivale a un “memcopy”, exceptuando el “alignment” de los miembros del struct
    3!
  • Desayunos Técnicos Trampas en C++ TR6 – Nivel 1 class A { private : static int m_refCount; int m_objNumber; public : A() { m_objNumber = ++m_refCount; } ~A() { printf (&quot;n %dn&quot;, m_objNumber); } }; int A::m_refCount = 0; ¿Cuál será la salida del programa? 1) n 1, n 2, n 3, n 4 2) n 1, n 2 3) n 1, n 2, n 1, n 2 y se queda memoria alocada 4) n 1, n 2 y se queda memoria alocada void main() { std::list<A> listaObjetos; std::list<A*> listaPunteros; listaObjetos. push_back (A()); listaObjetos. push_back (A()); listaPunteros. push_back ( new A()); listaPunteros. push_back ( new A()); }
  • Desayunos Técnicos Trampas en C++ TR6 – Nivel 1
    • Bjarne Stroustrup nos ilustra con aclaraciones correctas y fallos típicos
    • Opción correcta Nº3: Los objetos a los que apuntan los punteros en una lista no se desalocan automáticamente.
    • Moraleja: Las listas de objetos son seguras pero tienen el precio de la copia, mientras que las listas de punteros son más eficientes pero no son seguras.
    3!
  • Desayunos Técnicos Trampas en C++ TR7 – Nivel 2 ///// func.h extern &quot;C&quot; void setNumber ( int n); ///// func.c (Compilado en C) extern int number = 5; void setNumber ( int n) {number = n;} //// main.cpp (Compilado en C++) #include &quot;func.h&quot; extern int number = 1; void main () { printf (&quot;%dn&quot;, number); setNumber (6); printf (&quot;%dn&quot;, number); number = 2; printf (&quot;%dn&quot;, number); }
    • ¿Cuál será la salida del programa?
    • 1, 1, 2
    • 5, 6, 2
    • 5, 6, 6
    • 1, 6, 2
    • Error del linker
    • ‘ INDEFINIDO’ (1 ó 5), 6, 2
  • Desayunos Técnicos Trampas en C++ TR7 – Nivel 2
    • Bjarne Stroustrup nos ilustra con aclaraciones correctas y fallos típicos
    • Opción correcta Nº1: C y C++ son lenguajes diferentes, no comparten la nomenclatura de los símbolos.
    • Moraleja: Si se van a compartir variables globales, utilizar “extern “C”” para que C++ sepa que la variable va a tener un símbolo de C.
    1!
  • Desayunos Técnicos Trampas en C++ TR8 – Nivel 2 ///// globalvec.h #include <vector> extern std::vector< int > globalVector; //// globalvec.cpp #include &quot;globalvec.h“ std::vector< int > globalVector; ///// main.cpp #include &quot;globalvec.h“ class Clase { public : Clase() { globalVector. push_back (0); printf (&quot;Constructor Clasen&quot;);} }; Clase globalObj; int main() { printf (&quot;Hello World!n&quot;); return 0; } ¿Cuál será la salida del programa? 1) Hello Word! 2) Contructor Clase Hello World! 3) Cascará 4) 50%-50% entre 2 y 3. Depende de tu compilador y de tu suerte.
  • Desayunos Técnicos Trampas en C++ TR8 – Nivel 2
    • Bjarne Stroustrup nos ilustra con aclaraciones correctas y fallos típicos
    • Opción correcta Nº4: El compilador no tiene forma de saber cual de los objetos estáticos debe crear antes, Static Initialization Order Fiasco.
    • Moraleja: No hacer objetos estáticos dependientes entre si.
    4!