Ich soll ein einfaches Programm schreiben, welches eine Klasse "Katalog" definiert. diese enthält die Attribute Verfasser und Titel.
Desweiteren soll es die Unterklassen "KatalogBuch" und "KatalogPGB" geben, welche die Attribute der Oberklasse "Katalog" erben.

in der Oberklasse soll es eine Methode "Info" geben, welche dann einfach den Titel und den Verfasser ausgibt.

Nun soll ich aber in der Unterklasse "KatalogBuch" die Methode "Info" so verfeinern, dass auch das zusaätzliche Attribut der Unterklasse ("ISBN") ausgegeben wird. Die Attribute "Verfasser" und "Buch" sollen aber weiterhin durch die virtuelle Methode der Klasse "Katalog" gegeben werden.

So weit bin ich nun:

#include <iostream>
using namespace std;

#include <iostream>
using namespace std;

class Katalog //erstellt Klasse Katalog
{
protected:
string Verfasser;
string Titel;
public:

Katalog(string _Verfasser, string _Titel) //Konstruktor
{
Verfasser = _Verfasser;
Titel = _Titel;
}

void Info() //Methode Info
{
cout << Verfasser << endl;
cout << Titel << endl;
}

};

class KatalogPGB : public Katalog //KatalogPGB erbt von Katalog
{
private:
string Koerperschaft;
public:
KatalogPGB (string _Koerperschaft) : Katalog(Verfasser, Titel)
{
Koerperschaft = _Koerperschaft;
}

};

class KatalogBuch : public Katalog //KatalogBuch erbt von Katalog
{

private:
string ISBN;
public:
KatalogBuch(string _ISBN) : Katalog(Verfasser,Titel)
{
ISBN = _ISBN;
}

void Info()
{
cout << Verfasser << endl;
cout << Titel << endl;
}
};

int main () {
KatalogBuch K1("Hans","Hubert","12345");
K1.Info();

return 0;
}

Was mache ich flasch? wie krieg ich es hin dass diese Info Methode in der Unterklasse KatalogBuch läuft?

* Hä? In KatalogPGB überschreibst du die Info Methode nicht mal und in KatalogBuch gibst du genau das Gleiche aus. WTF erwartest du, was da passieren soll?

#include <iostream>
using namespace std;

#include <iostream>
using namespace std;

class Katalog
	{
	protected:
		string Verfasser;
		string Titel;
	public:

		Katalog(string _Verfasser, string _Titel)
		{
			Verfasser = _Verfasser;
			Titel = _Titel;
		}

		virtual void Info()
		{
			cout << Verfasser << endl;
			cout << Titel << endl;
		}

	};

class KatalogPGB : public Katalog
	{
	private:
		string Koerperschaft;
	public:
		KatalogPGB (string _Koerperschaft) : Katalog(Verfasser, Titel)
		{
			Koerperschaft = _Koerperschaft;
		}

	};

class KatalogBuch : public Katalog
	{

	private:
		string ISBN;
	public:
		KatalogBuch(string _ISBN) : Katalog(Verfasser,Titel)
		{
			ISBN = _ISBN;
		}

		void Info() 
		{
			cout<<ISBN<<endl;
		}
	};

int main () {
	KatalogBuch K1("Hans","Hubert","12345");
	K1.Info();

	return 0;
}

#include <iostream>

struct A
{
  int i;
  A() : i(42) {}
  virtual void foo() const
  {
    std::cout << i << '\n';
  }
};

struct B : public A
{
  int j;
  B() : j(77) {}
  virtual void foo() const
  {
    std::cout << i << '\n';
    std::cout << j << '\n';
  }
};

int main()
{
  B b;
  b.foo(); // gibt immer das Richtige aus
  A* a = &b;
  a->foo(); // Huch! Dank virtual wird auch hier foo() von B aufgerufen.
}

Also wir haben jetzt erstmal die virtual void Info überall geändert und ein "const" dahinter geschrieben. Außerdem die Ausgabe in der Klasse KatalogBuch" auch um die Attribute der Oberklasse erweitert. Soweit so gut. Jetzt kommt in der main noch ein fehler (hab ich im Code an der Stelle dazugeschrieben

#include <iostream>
using namespace std;

class Katalog
	{
	protected:
		string Verfasser;
		string Titel;
	public:

		Katalog(string _Verfasser, string _Titel)
		{
			Verfasser = _Verfasser;
			Titel = _Titel;
		}

		virtual void Info() const 
		{
			cout << Verfasser << endl;
			cout << Titel << endl;
		}

	};

class KatalogPGB : public Katalog
	{
	private:
		string Koerperschaft;
	public:
		KatalogPGB (string _Koerperschaft) : Katalog(Verfasser, Titel)
		{
			Koerperschaft = _Koerperschaft;
		}

	};

class KatalogBuch : public Katalog
	{

	private:
		string ISBN;
	public:
		KatalogBuch(string _ISBN) : Katalog(Verfasser,Titel)
		{
			ISBN = _ISBN;
		}

		virtual void Info()const {
			cout<<Verfasser<<endl;
			cout<<Titel<<endl;
	    	cout<<ISBN<<endl;
		}

	};

int main () {
	KatalogBuch K1("Hans","Hubert","12345");   //ERROR: no matching function for call to 'KatalogBuch::KatalogBuch (const char[5],const char [7], const char [6]'
	Katalog* a= &K1;
	a->Info();

	return 0;
}

#include <iostream>

struct A
{
  int i;
  A(int i) : i(i) {}
  virtual void foo() const
  {
    std::cout << i << '\n';
  }
};

struct B : public A
{
  int j;
  B(int i, int j) : A(i), j(j) {}
  virtual void foo() const
  {
    std::cout << i << '\n';
    std::cout << j << '\n';
  }
};

int main()
{
  B b(42, 77);
  b.foo(); // gibt immer das Richtige aus
  A* a = &b;
  a->foo(); // Huch! Dank virtual wird auch hier foo() von B aufgerufen.
}

void Info()
        {
            Katalog::Info();
            cout<<ISBN<<endl;
        }

Die Info-Funktio soll nach der Aufgabenstellung wohl eher so aussehen:

Stimmt, nur mir vitual und const.

manni66 schrieb:

Die Info-Funktio soll nach der Aufgabenstellung wohl eher so aussehen:

Stimmt, nur mir vitual und const.

const: wenn die Basis const ist ja, sonst nein
virtual: muss nur in der Basis vorhanden sein, in der abgeleiteten Klasse dient es der Übsersichtlichkeit

soweit bin ich nun und ich hoffe die "uglynames" sind nun auch weniger ugly^^

#include <iostream>
using namespace std;

class Katalog
	{
	protected:
		string Verfasser;
		string Titel;
	public:

		Katalog(string pVerfasser, string pTitel)
		{
			Verfasser = pVerfasser;
			Titel = pTitel;
		}

		virtual void Info() const 
		{
			cout << Verfasser << endl;
			cout << Titel << endl;
		}

	};

class KatalogPGB : public Katalog
	{
	private:
		string Koerperschaft;
	public:
		KatalogPGB (string pKoerperschaft) : Katalog(Verfasser, Titel)
		{

			Koerperschaft = pKoerperschaft;
		}

	};

class KatalogBuch : public Katalog
	{

	private:
		string ISBN;
	public:
		KatalogBuch(string pISBN) : Katalog(Verfasser,Titel)
		{

			ISBN = pISBN;
		}

	virtual void Info() {

			Katalog::Info();
	    	cout<<ISBN<<endl;
		}

	};

int main () {
	Katalog A1("Hans", "Hubert");
	KatalogBuch K1("12345");

	K1.Info();

	/*Katalog* a= &K1; 
    a->Info(); */

	return 0;
}

#include <iostream>
#include <string>
using namespace std;

class Katalog
{
	string Verfasser;
	string Titel;
	public:
	Katalog(string Verfasser, string Titel)
		: Verfasser(Verfasser)
		, Titel(Titel)
	{}

	virtual void Info() const
	{
		cout << "Verfasser: " << Verfasser << '\n';
		cout << "Titel: " << Titel << '\n';
	}
};

class KatalogPGB : public Katalog
{
	string Koerperschaft;
public:
	KatalogPGB(string Verfasser, string Titel, string Koerperschaft)
		: Katalog(Verfasser, Titel)
		, Koerperschaft(Koerperschaft)
	{}

	virtual void Info() const
	{
		Katalog::Info();
		cout << "Koerperschaft: " << Koerperschaft << '\n';
	}
};

class KatalogBuch : public Katalog
{
	string ISBN;
public:
	KatalogBuch(string Verfasser, string Titel, string ISBN)
		: Katalog(Verfasser, Titel)
		, ISBN(ISBN)
	{}

	virtual void Info() const
	{
		Katalog::Info();
		cout << "ISBN: " << ISBN << '\n';
	}
};

int main()
{
	KatalogBuch K1("Hans", "Hubert", "12345");  
	Katalog* a= &K1;
	a->Info();
}

Aaaaallerdings:

gebe ich in der main nun folgendes ein:

int main () {

	KatalogBuch K1("hubert","hans","12345");
	KatalogBuch k2("Emma","Peter","43214");
	Katalog* a= &K1; 
    a->Info();
	Katalog* b=&k2;
	b->Info();

	return 0;

Kriegen wir zwar Vor und Nachnamen, allerdings nicht die ISBN Nummern

Edit: hat sich erledigt. Klappt.

Eine Frage bleibt: wieso muss ich bei jedem Konstruktor der Unterklassen die alten parameter erneut hineinschreiben. Was hat das dann noch mit Vererbng zu tun? Weil wir doch über ":Katalog(Verfasser, Titel)" diese Parameter weitergeben?!

#include <iostream>

class Katalog
{
private:
    std::string verfasser, titel;
public:
    Katalog(const std::string& v, const std::string& t)
    : verfasser(v), titel(t) {}
    std::string VerfasserName() const { return verfasser; }
    std::string TitelName() const { return titel; }
    virtual std::string InfoString() const = 0; //Rein virtuell!
};

std::string Katalog::InfoString() const //Rein virtuelle Methoden muessen
{                                       //ausserhalb der Klasse definiert werden.
    return verfasser + ": \"" + titel + "\"";
}

class KatalogBuch : public Katalog
{
private:
    std::string isbn;
public:
    KatalogBuch(const std::string& v, const std::string& t,
                const std::string& i)
    : Katalog(v, t), isbn(i) {}
    std::string Isbn() const { return isbn; }
    virtual std::string InfoString() const
    {
        return Katalog::InfoString() + " ISBN: " + isbn;
    }
};

class KatalogPGB : public Katalog
{
private:
    std::string koerperschaft;
public:
    KatalogPGB(const std::string& v, const std::string& t,
               const std::string& k)
    : Katalog(v, t), koerperschaft(k) {}
    std::string Koerperschaft() const { return koerperschaft; }
    virtual std::string InfoString() const
    {
        return Katalog::InfoString() + " Koerperschaft: " + koerperschaft;
    }
};

int main()
{
    KatalogBuch k("Ich", "Irgendwas", "1234");
    std::cout << k.InfoString();
    return 0;
}

Geht doch alles.

Edit: Sowas blödes, da war noch jemand scharf drauf ne Lösung zu machen. Kommt davon, wenn man sich so viel Zeit lässt und denkt, dass hier keiner Hausaufgaben für andere macht
Egal, haste gleich 2 Lösungen. Viel Spaß damit.

Eine Frage bleibt: wieso muss ich bei jedem Konstruktor der Unterklassen die alten parameter erneut hineinschreiben. Was hat das dann noch mit Vererbng zu tun? Weil wir doch über ":Katalog(Verfasser, Titel)" diese Parameter weitergeben?!

Ist halt so. Die Basis wird normalerweise automatisch initialisiert, dafür muss aber ein Defaultkonstruktor verfügbar sein. Ist hier aber nicht der Fall, weshalb du die Basis selber intialisieren musst.

Eine Frage bleibt: wieso muss ich bei jedem Konstruktor der Unterklassen die alten parameter erneut hineinschreiben. Was hat das dann noch mit Vererbng zu tun? Weil wir doch über ":Katalog(Verfasser, Titel)" diese Parameter weitergeben?!

Die Antwort innerhalb der Sprache ist: Weil es nicht anders geht. Jede Funktion ist eigenständig und bekommt genau die Parameter, die sie erwartet.
Die Meta-Antwort ist: Die Parameter von den geerbten Typen zu übernehmen würde Funktionen nicht nur inkonsistent machen, sondern auch so etwas verhindern:

struct A { A(int i); };
struct B : public A { B() : A(42) {} };

RuggedC schrieb:

Eine Frage bleibt: wieso muss ich bei jedem Konstruktor der Unterklassen die alten parameter erneut hineinschreiben. Was hat das dann noch mit Vererbng zu tun? Weil wir doch über ":Katalog(Verfasser, Titel)" diese Parameter weitergeben?!

Ist halt so. Die Basis wird normalerweise automatisch initialisiert, dafür muss aber ein Defaultkonstruktor verfügbar sein. Ist hier aber nicht der Fall, weshalb du die Basis selber intialisieren musst.

Ich hab mir das jetzt so gedacht, dass er an der stelle

public: 
		KatalogBuch(string Verfasser, string Titel, string ISBN) 
        : Katalog(Verfasser, Titel) 
        , ISBN(ISBN)

einen "string Verfasser" und einen "string Titel" initialisiert, der dann aber quasi die "Werte" bzw den Inhalt aus der oberklasse erbt.