#include <iostream>

namespace Buildings
{
    class Building
    {
    protected:
        std::string _date;

    public:
        Building(void)
        {}

        Building(std::string const date) :
          _date(date)
        {}

        Building(Building const & same_building) :
          _date(same_building._date)
        {}

        virtual ~Building()
        {}
    };

    class House : public Building
    {
    private:
        int _waende;

    public:
        House() : 
          _waende(0)
        {
        }   

        House(int const waende, std::string const date) : 
          _waende(waende)
        { 
            this->_date = date;
        }

        House(House const & same_house) :
          _waende(same_house._waende)
        {                  
            this->_date = same_house._date;
        }

        ~House()
        { 
        }

        House & operator=(House const & same_house)
        {      
            this->_date = same_house._date;
            this->_waende = same_house._waende;
            return *this;  
        }

        int get(void) const
        {
            return this->_waende;    
        }

        std::string getdate(void) const
        {
            return this->_date;            
        }
    };

    std::ostream& operator<<(std::ostream& Stream, House const & house)
    {
        return Stream << "Das Haus hat " << house.get() << " Waende und ist am " << house.getdate() << " gebaut worden!";           
    }
};

int main(void)
{
    Buildings::House WhiteHouse;
    Buildings::House TmpHouse(10, "21.4.1955");

    WhiteHouse = TmpHouse;

    std::cout << WhiteHouse << std::endl;

    system("PAUSE");
    return 0;
}

Wenn ich im Copy-Ctor vererbte Variablen mit einem Wert setzen will, kann man die iwie in der Initialisierungsliste definieren ? Bei mir gibst nen Compile-Fehler wenn ich folgendes versuche:

House(int const waende, std::string const date) : 
          _waende(waende), _date(date) //_date ist vererbt
        { 
        }

Klar man kann es auch einfach in die gescheiften Klammern schreiben, aber muss ja nicht sein wenns auch anders geht...

Gruß Chris

House(int const waende, std::string const date) :
          Building(date), _waende(waende) //_date ist vererbt
        {
        }

überlege dir auch, ob du nich die implementation der copy-ctoren, von operator= und von ~House deinem compiler überlassen willst.

generell gilt ist es schlecht, namen mit underscores beginnen zu lassen (besser gar nicht erst damit anfangen) und elementvariablen von klassen protected zu halten, ist auch kein guter stil.

/PS: beachte bei der elementinitialisierungsliste außerdem die einhaltung der reihenfolge: basisklassen und datenmember in der reihenfolge ihrer deklaration.

btw., es geht hier um den kopierkonstruktor, den (kopier-)zuweisungsoperator und den destruktor.

in diesem fall, machen die compiler-generierten versionen genau das, was du willst.

diese doppelte "public" in der Klassen Definition ist nur fürs Aussehen oder ?

Du kannst prinzipiell vor jeden Bestandteil erneut die Sichtbarkeit festlegen, daher macht dies nichts aus (Manche Codegeneratoren machen dies z.B.).

cu André

Gruß Chris

generell gilt ist es schlecht, namen mit underscores beginnen zu lassen (besser gar nicht erst damit anfangen) und elementvariablen von klassen protected zu halten, ist auch kein guter stil.

Ansichtssache. So lange man sich nicht im globalen Namensraum rumtreibt und der zweite Buchstabe kein Großbuchstabe ist erlaubt der Standard das. Ich finds hübscher als mPups.

ps: wir habens probiert nach vielen fehlern.. es geht.. hmm

na, gut zu wissen.