Zugriff auf vererbte variablen

Foxx90

Hallo, folgendes Beispiel: (ja ich weiß sinnlos, nur zur Veranschaulichung)

#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

queer_boy

du musst den konstruktor der basisklasse verwenden:

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.

Foxx90

warum sollte man die die sachen die du genannt hast dem compiler überlassen ?
ic hdachte: wenn man einen macht sollte man alle machnen ?

queer_boy

und wenn du keinen der drei brauchst, dann keinen.

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.

*D*Evil

#include <string>

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

    public:
        Building(std::string const& date(""))
            : m_date(date)
        {}

        friend std::ostream& operator << (std::ostream& out, Building const& data)
        { return out << "Erbaut am " << data.m_date; }

    public:
        std::string const& get_date() const { return m_date; }

    };

    class House : public Building
    {
        unsigned int m_walls;

    public:
        House(const unsigned int walls(0), std::string const& date("")) 
            : Building(data), m_walls(walls) 
        {}  

        friend std::ostream& operator<<(std::ostream& Stream, House const & data)
        { return out << "Das Haus hat " << data.m_walls << " Wände und wurde am " << data.m_date << " erbaut!"; } 

    public:
        const unsigned int get_walls() const { return m_walls; }
    };
}; // Buildings

Foxx90

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

asc

Foxx90 schrieb:

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é

Foxx90

Ok alles klar danke

Gruß Chris

.filmor

queer_boy schrieb:

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.

elise

was sollen denn die friends in der klasse?

Foxx90

Dadurch hat er verhindert, die operatoren << >> außerhalb der Klasse zu definieren bzw. deklarieren...

elise

.....

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

na, gut zu wissen.

Foxx90

ging mir auch so...