Assign one class to another in C ++

You are trying to treat an object of the parent class as an object of the child class. This does not work.

Concrete example

Imagine that you have the animal , gato (inheriting from animals) and urocordato classes. A animal has the comer method. A gato also has the miau , serFofo and ignorarDono methods. A urocordato also has methods metamorfose , filtrar and brotamento .

Imagine that for your algorithm you need a animal , let's call that estimacao animal:

animal estimacao;
estimacao = new gato();
// faz trabalho com um animal do tipo gato
estimacao = new urocordato();
// faz trabalho com animal do tipo urocordato

There is no problem with the above algorithm. Now imagine that we have a function that gets a gato as an argument. Let's call this function mimar , its signature is void mimar(gato xano); . See what happens below:

//declaração e objeto do tipo gato, tudo certo
gato xaninho = new gato();
mimar(xaninho);

// declaração de animal, objeto gato; possível atribuir, mas não possível chamar 'mimar'
animal bixo = new gato();
mimar(bixo);

// declaração de gato, objeto urocordato; impossível atribuir
gato xaninho = new urocordato();
mimar(xaninho);

Why this?

When you work with inheritance, you can assume that urocordato and gato can be treated as animals. Class definition speaks just this through inheritance:

• class gato is derived from class animal : means gato is a specific type of animal
• class urocordato is derived from class animal : means urocordato is a specific type of animal

However, you can not treat a% generic% as a animal . When you do gato you are trying to treat a gato xaninho = new urocordato(); any as a animal .

If you could treat a gato any as a animal , you could call the gato method of a miau() (for example, in the urocordato implementation), void mimar(gato xano) s is not are able to do urocordato .

  

UPDATE

Automatic construction

If at some point you declare a class constructor with only a single argument object, you can assign the argument to the variable of that class. Internally, C ++ will automatically create a target class object by calling the appropriate constructor. This has nothing to do with inheritance.

Example without using relation between miau() and gato :

int giid = 0;

class animal {
public:
    int id;
    int iid;
    animal(int _id = 0) {
        cout << "construindo um animal..." << endl;
        id = _id;
        iid = giid++;
    }

};

class gato {
public:
    int id, iid;
    gato(animal a) {
        id = a.id;
        iid = giid++;
        cout << "construtor chamado automaticamente, meaw" << endl;
    }
};

//códigos...
animal a;
gato xano = a; // chama o construtor de gato passando um animal

cout << "instance id do animal " << a.iid << endl;
cout << "instance id do xano " << xano.iid << endl;
//códigos...

See working at ideone .

Exit execution:

  

building an animal ...
  constructor called automatically, meaw
  instance id of animal 0
  instance id of xano 1

I also put together another example that, this yes, made the confusion:

int giid = 0;

class animal {
public:
int id;
int iid;
animal(int _id = 0) {
cout << "construindo um animal..." << endl;
id = _id;
iid = giid++;
}

};

class gato: public animal {
public:
gato(animal a) {
id = a.id;
cout << "construtor chamado automaticamente, meaw" << endl;
}
};

// códigos...
animal a;
gato xano = a;

cout << "instance id do animal " << a.iid << endl;
cout << "instance id do xano " << xano.iid << endl;
// códigos...

See working at ideone

Exit execution:

  

building an animal ...
  building an animal ...
  constructor called automatically, meaw
  instance id of animal 0
  instance id of xano 1

I did not understand the purpose / logic of your code. I think what you want to do is called "downcasting", which is only possible through pointers and references:

#include <iostream>
using namespace std;


class vetor
{
protected:
    int m_x;
    int m_y;

public:
    vetor(int x = 0, int y = 0)
    {
        m_x = x;
        m_y = y;
    }

    void imprime()
    {
        cout << "imprimindo como \'vetor\'";
        cout << "\nx: " << m_x;
        cout << "\ny: " << m_y << "\n\n";
     }
};


class pos : public vetor
{
public:
    pos(int x, int y) : vetor(x, y) {} //chama o construtor da classe base

    void imprime()
    {
        cout << "imprimindo como \'pos\'";
        cout << "\nx: " << m_x;
        cout << "\ny: " << m_y << "\n\n";
    }
};


int main()
{
    vetor vet(10, 20);
    vet.imprime();

    pos* ps = static_cast<pos*>(&vet);
    ps->imprime();

    return 0;
}

However, using a pointer / reference from a derived class to a base object is not a good programming practice, because it will only work if the base and derived class layout are the same as leaving your program with a logic confusing, breaking the class hierarchy. And it also would not work if you were using virtual functions.

The right thing is for you to create an abstract base class and use it to refer to derivative objects, using the "is one" logic, which @Jefferson Quesado explained:

#include <iostream>
#include <memory>
using namespace std;


class Poligono //classe abstrata
{
public:
    virtual void desenha() = 0; //função virtual pura
    virtual ~Poligono() {} //destrutor é declarado virtual para que seja chamado quando objeto 
     //filho for destruído
};


class Triangulo : public Poligono
{
public:
    void desenha() override //implementa função virtual
    {
        cout << "Desenha triangulo.\n";
    }
};


class Retangulo : public Poligono
{
public:
    void desenha() override
    {
        cout << "Desenha retangulo.\n";
    }
};


void FacaAlgumaCoisa(Poligono& pol)
{
    pol.desenha();
}


int main()
{
    unique_ptr<Poligono> pol; //ponteiro da classe base abstrata

    pol = make_unique<Triangulo>(); //usa pol como triângulo
    pol->desenha();

    pol = make_unique<Retangulo>(); //destroi triângulo e usa pol como retângulo
    pol->desenha();

    //usa uma função para obter o mesmo efeito acima
    FacaAlgumaCoisa(Retangulo());
    FacaAlgumaCoisa(Triangulo());

    return 0;
}

About the copy constructor, it is the constructor that you define to determine the behavior of your class when it is assigned:

class Pessoa
{
    string nome;
    int idade;

public:
    //construtor pra inicializar
    Pessoa(const string& nome, int idade)
    {
        this->nome = nome;
        this->idade = idade;
    }

    //construtor de cópia
    Pessoa(const Pessoa& p)
    {
        cout << p.nome << " esta sendo copiado(a)!\n";
        nome = p.nome; //se os objetos fore do mesmo tipo, vc pode acessar os membro privados
        idade = p.idade;
    }
};

Using the class:

Pessoa p1("John", 30);
Pessoa p2 = p1; //chama o construtor de cópia
Pessoa p3(p1); //faz a mesma coisa que a linha acima

You can also use the copy constructor of a class to receive another type of object (just like you did, so your code worked when you assigned two classes of different types), but unless I'm wrong, you'll need to dial the class as "friend" of the other object with the keyword friend , if the two classes have no relation. And another detail is that if you do not declare the copy constructor, the compiler will declare one for the same type implicitly, and its default behavior is to call the assignment operator on all members of your class.

EDIT:

Responding to other questions:

1 - In case of your code, you do not need to declare as friend because the derived class has access to the protected fields of the base class. And no, the compiler generates the copy constructor implicitly in all classes so you do not declare it and implement it. When you call the copy constructor, obviously the default constructor of the base class is also called. I recommend that you create a base class and a derivative and run tests marking all constructors with std::cout to better understand the operation:

struct Base
{
    Base()
    {
        cout << "base created!\n";
    }

    Base(const Base& b)
    {
        cout << "copy constructor base\n";
    }
};

struct Child : Base
{
    Child()
    {
        cout << "child created!\n";
    }

    Child(const Child& c)
    {
        cout << "copy constructor child\n";
    }
};

2 - "Downcasting" is when you try to use a derived class as if it were a base class, which is the opposite of the second example I showed. The base class should be used as a pointer / reference, since the derivatives inherit all the characteristics of the base, and the opposite does not occur. And yes, "vector" should be abstract, but in that case it works because it is identical to the "pos" class. And dynamic_cast serves the same purpose as a static_cast normal, the difference is that this cast checks at runtime if the conversion is valid and returns a null pointer if it is invalid, and only works with classes with methods marked as virtual . In the first example of my post, if you tried to mark the "print" method as virtual, and replace static_cast with dynamic_cast , the conversion would fail for reasons I've already mentioned (and also because virtual functions work differently than common methods). Search for class hierarchy and polymorphism to better understand these concepts.