Anfängerfrage zur Vererbung

Hei!

Ich lese zur Zeit ein Buch über C++ und bin gerade im Kapitel über Vererbung.
Es wird gerade erklärt, wie man eine Elementfunktion der Basisklasse redefiniert.
Dort heißt es:

Es ist ein häufiger Fehler, dass man das Schlüsselwort const vergisst.
Das Schlüsselwort const gehört zur Signatur. Lässt man es weg, ändert man die Signatur und verbirgt damit die Methode, statt sie - wie eigentlich beabsichtigt - zu redefinieren.

Weil ich das ganze nicht vollständig verstanden habe, tippte ich den dazugehörigen Beispielcode mal ab und hab da ein wenig dran rumgespielt, hier der originale Code:

#include <iostream>

class Mammal
{
	public:
		void Move() const
		{
			std::cout << "Mammal Move..." << std::endl; 
		}
		void Move(int distance) const
		{
			std::cout << "Mammal Move... " << distance << " Steps!" << std::endl;
		}
	protected:
		int m_age;
		int m_weight;
};

class Dog: public Mammal
{
	public: 
	void Move() const
	{
		std::cout << "Dog Move..." << std::endl;
	}
};

int main(void)
{
	Mammal bigAnimal;
	Dog fido;
	bigAnimal.Move();
	bigAnimal.Move(23);
	fido.Move();
	fido.Mammal::Move(2);
	getchar();
	return 0;
}

Weiter unten im Buch steht noch:

Verbergen sie keine Funktion der Basisklasse, indem sie die Signatur der Funktion ändern

Was ich jetzt nicht verstehe: Wenn ich das const in der Redefinition in Dog weglasse, funktioniert trotzdem alles. Ich wüßte nicht, welche Funktion ich verbergen würde?
Kann mir bitte jemand auf die Sprünge helfen?
Oder liegt das an meinem Compiler, das der das da nicht so eng sieht?
Ich verwende den GNU GCC.

ZuK

In deinem Beispiel tritt dieser Effekt nicht auf.
Versuche einmal diesen code und dann lass das const bei Dog::move weg. Denke dann wird dir einiges klarer.

#include <iostream> 

class Mammal 
{ 
    public: 
        virtual void Move() const 
        { 
            std::cout << "Mammal Move..." << std::endl; 
        } 
        void Move(int distance) const 
        { 
            std::cout << "Mammal Move... " << distance << " Steps!" << std::endl; 
        } 
    protected: 
        int m_age; 
        int m_weight; 
}; 

class Dog: public Mammal 
{ 
    public: 
    virtual void Move() const
    { 
        std::cout << "Dog Move..." << std::endl; 
    } 
}; 

int main(void) 
{ 
    Mammal * bigAnimal = new Mammal; 
    Mammal * fido = new Dog; 
    bigAnimal->Move(); 
    fido->Move(23); 
    fido->Move(); 
    fido->Mammal::Move(2); 
    delete bigAnimal;
    delete fido;
    getchar(); 
    return 0; 
}

Kurt

void Move() const
    {
        std::cout << "Const Dog Move..." << std::endl;
    }

void Move()
    {
        std::cout << "Dog Move..." << std::endl;
    }

Implementiere mal beides und dann rufe die Funktion Move einmal bei einem konstanten Objekt auf und bei einem nicht konstanten ...

ich hätte da auch eine Frage...kenn mich noch ned so gut aus mit c++ :

was bringt das "std::" vor dem "cout" ?

ist vielleicht ne blöde frage aber ich hab echt keine ahnung ...

miller_m

http://tutorial.schornboeck.net/namespace.htm