¿Para qué necesito un Constructor? (Sí, novato inside XD).

[dmorill]

Hola

Iniciado por BramSt

@dmorill bien, hasta ahora creo sacar en claro, según lo que dices, si yo no defino un constructor para mi estructura, el compilador de manera "escondida" haría algo parecido a punto p(), ¿cierto?

Para estructuras estoy casi seguro que si pero por si acaso esa pregunta se la paso a un veterano como vangodp jeje. Pero en las clases si que si. Se crea uno por defecto aunque no lo hayas definido.

Iniciado por BramSt

Por otro lado, en tu ejemplo, ¿por qué "punto p" daría error? Quiero decir, ¿no lo debería ver el compilador como una instanciación de la clase (o como se llame crear una variable de tipo "punto"), en vez de como una llamada al constructor?

De no existir el constructor, o si es que existe por efecto si yo no lo defino, creo que esa sintaxis funcionaría perfectamente...

Primero partamos del hecho que el constructor siempre esta allí aunque no lo definas (se crea uno por defecto sin parámetros), cuando tu lo defines, el programa dice "a menos mal que se definió un constructor, ahora voy a usar el que el usuario declaro así me libro de hacer uno" jeje. Por tanto en el ejemplo que te puse, definí un constructor que funciona si y solo si tiene dos parametros (int x, int y), cuando el compilador crea la estructura punto el intenta llamar a tu constructor y como no tiene parámetros explota xd.

Por supuesto, como el otro ejemplo resolviendo ese problema tu puedes tener muchos constructores (eso es como sobrecarga de constructores, no le prestes mucha atención al termino sobrecarga jeje eso viene luego).

Código C++:

struct punto{
    int _x = 0;
    int _y = 8;
    punto();     // OJO te faltaba declararlo acá.
};
 
 
punto::punto(){//¿esto es llamar al constructor por defecto?
    cout << _x << " " << _y << " Llamando al constructor." << endl;
}
int main(){
    punto p;// por qué esto si funciona? no debería ser punto p()?;
    cout << p._x << " " << p._y << " mostrando couts" << endl;
 
    cin.sync();
    cin.get();
 
    return 0;
}
 

Vamos por partes, "punto::punto(){//¿esto es llamar al constructor por defecto?", no esto es implementar (vamos definir) el constructor, que se llamará siempre que se crea una estructura.

"punto p;// por qué esto si funciona? no debería ser punto p()?;"

Para esto tengo que explicarte cuales son las caracteristicas especiales de los constructores, pues son funciones muy importantes y especiales para c++.
* Los constructores no devuelven nada, pero son los únicos que no se les pone void. supongo que para diferenciarlos y por que son los consentidos de c++ xd.
*Los constructores de deben llamar igual que su clase o bien que su estructura. Por eso se llama "punto();" uno por default o bien "punto(int x, int y)" uno con parámetros.
* En teoria no debern hacer otra cosa que no sea poner valores a los atributos (variables sean publicas o no) de las estructuras o clases.
* Son funciones que se llamaran siempre, al crear estructuras o objetos, tu no las llamas. Por eso si funciona "punto p" y no punto p().

Iniciado por BramSt

Y otra cosita, ¿en este ejemplo se usa el operador de ambito (::) .¿Por qué? ¿Por que se está accediendo directamente a un miembro de clase?

Sip, exacto jeje, los constructores son funciones que pertenecen a una estructura o una clase, por tanto se declaran dentro de los mismos y para implementarlos (si se hace fuera) se necesita los dos :: mira este ejemplo, voy a definir el mismo constructor de las formas que conozco, (ojo los constructores que definiré todos hacen lo mismo y sólo debes poner uno de ellos, no los 3 porque te daría error pues ya los has definido antes):

Código C++:

#include <iostream>
using namespace std;
 
struct punto{
    int _x;
    int _y;
    punto(int x, int y);    
//declarandolo aquí dentro de la estructura.
    punto(int x, int y) { _x = x; _y = y; };    
//declarandolo e implementandolo  inline, así se puede definr métodos cortos
    punto(int x, int y) : _x(x), _y(y) {}   
// declarandolo e implementadolo inline, pero éste método es especial para los constructores. En herencia veras que es útil ponerlos así. 
};
//implementandolo aqui fuera de la estrucutra.
punto::punto(int x, int y){     
    _x = x;
    _y = y;
}
 
 
int main(){
    punto p(0, 0);
    cout << p._x << " " << p._y << endl;
 
    cin.sync();
    cin.get();
    return 0;
}
 

Y yo personalmente te recomiendo que sigas siendo curioso y que uses constructores en tus estructuras.


Saludos