default constructor & class pointer, overriding, inheritance problem

Question

#include <iostream>

using namespace std;

class Base {
    int x;
public:
        Base() : x() {}
    Base(int x) : x(x) {}
    virtual void print() const {
        cout << x << endl;
    }
};

on Derived(int x, int y) : x(x), y(y) {}, Compiler said must usd "default constructor", but i'd thought that already made, and wonder why default constructor is needed.


class Derived : public Base {
    int x, y;
public:
    Derived(int x, int y) : x(x), y(y) {}
    void print() const override {
        cout << x << ", " << x << endl;
    }
};



int main() {
// All data members of Base and Derived classes must be declared 
// as private access types
    Base* p1 = new Derived(10, 20);     // (x, y)
    Base* p2 = new Base(5);         // (x) 
    p1->print();            // prints 10, 20
    p1->Base::print();      // prints 10
}

second in this problem,

p1->Base::print();      // prints 10

p1->Base::print() must print 10, but it didn't work. How can I print 10?

please include the complete verbatim error message in the question. do not paraphrase it — 463035818_is_not_an_ai, Dec 06 '22 at 09:12
cannot reproduce. THe code you posted has no errors https://godbolt.org/z/W5K51aMz5 — 463035818_is_not_an_ai, Dec 06 '22 at 09:13
Both snippets work without any error. Refer to a [good c++ book](https://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list). — Jason, Dec 06 '22 at 09:13
Unrelated, but you've forgotten the `virtual` destructor in the base class. Add `virtual ~Base() = default;` — Ted Lyngmo, Dec 06 '22 at 09:14
`p1->Base::print() must print 10, but it didn't work.` because you didnt initialize `Base::x`. Please one question per question — 463035818_is_not_an_ai, Dec 06 '22 at 09:14
If you attempted to get rid of those memory leaks using `delete`, your code exhibits undefined behavior due to the base class not having a virtual destructor. — PaulMcKenzie, Dec 06 '22 at 09:14
ot: Why is there a comment `// prints 10` when it doesnt print 10 ? Sometimes I really dislike comments, they can be so confusion and misleading — 463035818_is_not_an_ai, Dec 06 '22 at 09:15
Take `x` out of the derived class so you don't have two ints called `x` in play - there will be more to fix after that, but it will help. — doctorlove, Dec 06 '22 at 09:15

Ted Lyngmo · Accepted Answer · 2022-12-06T09:58:16.687

Your base class is missing a virtual destructor so trying to delete p1; will cause undefined behavior.
Derived has 2 x member variables. Base::x and Derived::x. You most probably only want one. This also explains why p1->Base::print() doesn't do what you want. Base::x is 0 and Derived::x is 10.
Base::x is private so the print function in Derived should probably rely on Base::print to print it.

Example:

The base class here has a virtual destructor and the print function takes an ostream& so that it can print to any ostream (like std::cout or a file stream):

class Base {
    int x;

public:
    Base() : x() {}
    Base(int x) : x(x) {}
    
    virtual ~Base() = default;

    virtual void print(std::ostream& os = std::cout) const {
        os << x; 
    }
};

Derived here does not add an x member variable, but initializes Base with the x value supplied to its constructor. The print function simply calls the base class print:

class Derived : public Base {
    int y;

public:
    Derived(int x, int y) : Base(x), y(y) {}

    void print(std::ostream& os = std::cout) const override {
        Base::print(os); // calls `print` in the base class
        os << ' ' << y;  // and adds its own output
    }
};

You can also add an operator<< overload to make printing easier. Note that you only need one for the base class. It will call the print function in the most derived class:

std::ostream& operator<<(std::ostream& os, const Base& b) {
    b.print(os);
    return os;
}

The main function then becomes:

int main() {
    Base* p1 = new Derived(10, 20);  // (x, y)
    Base* p2 = new Base(5);          // (x)

    std::cout << *p1 << '\n';   // 10 20
    std::cout << *p2 << '\n';   // 5

    p1->Base::print();          // 10

    delete p1;
    delete p2;
}

Or better, use smart pointers so that you don't forget to delete what you've allocated:

int main() {
    std::unique_ptr<Base> p1 = std::make_unique<Derived>(10, 20);
    std::unique_ptr<Base> p2 = std::make_unique<Base>(5);

    std::cout << *p1 << '\n';   // 10 20
    std::cout << *p2 << '\n';   // 5

    p1->Base::print();          // 10
}

Demo

default constructor & class pointer, overriding, inheritance problem

1 Answers1