[C con Clase] Duda sobre clases

[Miguel Alejandro Jimenez Ramirez]

Bueno pues aca estoy yo otra vez con mis dudas , esta vez es sobre un
operador en especial el operador :

reinterpret_cast < type-id > ( expression ).


Por lo que entiendo este operador hace un casting y lo que hace es que
transforma la expresion en el

tipo deseado.


Ahora bien , comprendido esto tengo el siguiente programa:


#include <iostream>

class A
{
public:
    A() : m_i(0) { }

protected:
    int m_i;
};

class B
{
public:
    B() : m_d(0.0) { }

protected:
    double m_d;
};

class C
    : public A
    , public B
{
public:
    C() : m_c('a') { }

private:
    char m_c;
};

int main()
{
    C d;
    A *b1 = &d;
    B *b2 = &d;

    const int a = (reinterpret_cast<char*>(b1) ==
reinterpret_cast<char*>(&d)) ? 1 : 2;
    const int b = (b2 == &d) ? 3 : 4;
    const int c = (reinterpret_cast<char*>(b1) ==
reinterpret_cast<char*>(b2)) ? 5 : 6;
    std::cout << a << b << c << std::endl;
getchar();
    return 0;
}

Al ejecutarlo vamos a tener 136.

El primer numero 1 , entiendo bien por que existe , ya que la condicion:
reinterpret_cast<char*>(b1) == reinterpret_cast<char*>(&d)
es verdadera , lo cual es logico ya que hacemos un casting de b1 y
convertimos su contenido en un apuntador a char , dentro de b1 vamos a
tener la referencia a d pero a lo que esta apuntando b1 es el contenido de
d ,si creamos una funcion para ver su contenido  creeria que es 'c' que es
valor dado en la clase c.

El 3 , se da por que el contendido de b2 es la referencia a la cual esta
apuntando es decir la referencia d.

pero el tercero , la verdad no se por qu es falso , ya que si b1 esta
apuntando a d y b2 esta apuntando a d , y los dos son padres de la clase c
, no seria como llamar al mismo objeto desde diferentes clases?, bueno no
se si estoy bien en mi apreciacion epro me gustaria aclarar esta duda y
ademas saber si mis afirmaciones son correctas.

Gracias or su ayuda , cordialmente.


2013/5/20 Miguel Alejandro Jimenez Ramirez <cerberbero en gmail.com>

> Muchas gracias por la ayiuda , la verdad son de una pagina:
> http://www.interqiew.com/tests?type=cpp
> Estoy preparandome para pruebas de trabajo ya que quiero trabajar como
> desarrollador de sistemas embebidos.
>
> Si tienes mas informacion sobre este tema estaria muy agradecido. Y pues
> seguire con las preguntas , si tengo dudas las enviare. Gracias nuevamente
>
>
> 2013/5/20 Salvador Pozo <salvador en conclase.net>
>
>> Hola:
>>
>> Antes de nada, que sepas que no molestas en nada con tus preguntas.
>> Pregunta todo lo que quieras.
>>
>> MAj> Buneo creo que lo entendi , es que no habia visto que en la parte
>> privada
>> MAj> de la clase derivada los objetos eran del tipo de la clase A.
>>
>> Yo también he tardado un rato en verlo. :)
>>
>> MAj> Lo que tendria que aclarar seria el orden aver si lo que digo es
>> cohereente.
>> MAj> Al declarar el objeto b de tipo de la clase derivada B y enviando
>> como
>> MAj> parametro 5. Claro esta todo en corchetes para que el comilador
>> entienda
>> MAj> que lo que vamos a imprimir esta en los destructores.
>>
>> No importa tanto el orden en que se crean como en el que se destruyen los
>> objetos.
>>
>> Efectivamente, podemos suponer que primero se crean los datos
>> correspondientes a la clase base A, de la que se deriva la clase B. Como no
>> es necesario especificar un constructor de la clase base, puesto que tiene
>> uno con un parámetro con un valor por defecto, esa invocación al
>> constructor de la clase base no aparece en el constructor de B. (Espero no
>> haber cometido errores en este párrafo). :)
>>
>> El constructor de B podría quedar de este modo (por lo que se refiere a
>> este ejemplo, al menos):
>>
>>     B(int n) : A(2), m_x(m_i + 1) , m_a(n) {}
>>
>> El orden en que se crean los objetos es el mismo en que aparecen las
>> llamadas a los constructores.
>>
>> Puedes probar a cambiar el orden, y verás que el orden permanece, pero
>> obtendrás mensajes de aviso diciendo que el orden de construcción no es el
>> mismo en que lo has escrito.
>>
>> Una vez construido el objeto B, los datos miembro tienen los valores
>> siguientes:
>>
>> m_i (de la clase base) = 2
>> m_x = 3
>> m_a = 5
>>
>> Ahora vamos a los destructores.
>>
>> Cuando se invoca al destructor de B, primero se muestra el valor de m_i,
>> ya que lo primero que hay es un cout << m_i, es decir, "2".
>>
>> Luego se decrementa m_i, que pasa a valer 1.
>>
>> Hasta aquí no hemos destruido nada todavía.
>>
>> Ahora es cuando se destruyen los miembros de b, primero m_x, y se muestra
>> el valor "3", luego m_a, y se muestra el valor "5".
>>
>> Finalmente, se destruye la clase base A de B, y se muestra m_i, que ahora
>> vale "1".
>>
>> El poner la sentencia:
>>     { B b(5); }
>>
>> Entre corchetes es para que el bloque se ejecute, es decir, el objeto b
>> se crea y al finalizar el bloque (entre corchetes), se destruye.
>>
>> Una pregunta: ¿de dónde sacas estos programas? Son geniales. :)
>>
>>
>> --
>> Salvador Pozo (Administrador)
>> mailto:salvador en conclase.net
>> _______________________________________________
>> Lista de correo Cconclase Cconclase en listas.conclase.net
>> http://listas.conclase.net/mailman/listinfo/cconclase_listas.conclase.net
>> Bajas: http://listas.conclase.net/index.php?gid=2&mnu=FAQ
>>
>
>
>
> --
> MIGUEL ALEJANDRO JIMENEZ R.
>



-- 
MIGUEL ALEJANDRO JIMENEZ R.
------------ próxima parte ------------
Se ha borrado un adjunto en formato HTML...
URL: <http://listas.conclase.net/pipermail/cconclase_listas.conclase.net/attachments/20130521/b498d54f/attachment.html>