Wskaźnik na klasę bazową a komunikat wypisania klasy pochodnej

Question

Witam przychodzę z pytaniem odnośnie dziedziczenia. Czy ktoś może wyjaśnić jak mam rozumieć wskaźnik na klasę bazową? Dlaczego wypisywany jest komunikat klasy bazowej, a nie klasy pochodnej?

#include <iostream>
#include <string>

using namespace std;

/*
* Animal
*/
class Animal {
private:
    string name;
public:
    Animal();
    Animal(string n);
    string getName();
    friend ostream & operator<<(ostream & os, Animal & object);
};

Animal::Animal() : name("Animal") {}
Animal::Animal(string n) : name(n) {}

string Animal::getName() { return name; }

ostream & operator<<(ostream & os, Animal & object) {
    os << "Name: " << object.name << endl;
    return os;
}

/*
* Dog
*/
class Dog : public Animal {
private:
    string type;
public:
    Dog();
    Dog(string n, string t);
    friend ostream & operator<<(ostream & os, Dog & object);
};

Dog::Dog() : Animal("Dog"), type("Normal") {}
Dog::Dog(string n, string t) : Animal(n), type(t) {}

ostream & operator<<(ostream & os, Dog & object) {
    os << "Name: " << object.getName() << endl;
    os << "Type: " << object.type << endl;
    return os;
}

/*
* Main
*/
int main() {

    Animal animal1;
    Dog dog1("Dog", "Special");

    cout << animal1 << endl; // prints default info
    cout << dog1 << endl;    // prints Dog, Special

    // Pointer
    Animal *pointer = &dog1;
    cout << *pointer << endl; // prints Dog (without Special)

    cin.get();
    return 0;
}

 

Answer 1

Ponieważ przeciążenie operatora tutaj nie jest wirtualne. Zrób wirtualną metodę(np. toString()) i w klasie bazowej tylko zadeklaruj przeciążenie operatora który będzie korzystał z tej wirtualnej metody. Tak właśnie działa słowo virtual.

Comments

A czy można zrobić wirtualna funkcje zaprzyjaźniona.  Bo nie wiem jakby to miało wyglądać.

---

Mógłbyś pokazać to na prostym przykładzie, bo nie rozumiem koncepcji. Czy mam stworzyć zupełnie nową metodą i zrobić ją wirtualną czy do operatora<< mam dodać słowo virtual?

---

Pokażę jak wrócę do domu (za około 4h)

---

Dziękuję w takim razie czekam na przykład wyjaśniający :)

---

Korzystając z nudnej lekcji:

class A
{
public:
    virtual void f() const { std::cout << "base"; }
};
class B: public A
{
public:
    virtual void f() const { std::cout << "derived"; }
};

std::ostream& operator<<(std::ostream& os, const A& a )
{
     a.f();
     return os;
}

int main()
{
    B b;
    std::cout << b << std::endl;

    return 0;
}

Źródło: LINK dokładnie ten sam problem co twój.