problem bei vererbung / abstraktem zeugs

StarCraftFeuerteufel

a) was ist diamanten vererbung?
b) warum muss man das virtual da mitschleifen, denn bei

class foo3 : virtual public foo<int>
{
  public:
    void f(const int& src){};
};

int main()
{
  foo3 g;
  return 0;
};

meckert er nicht rum.

Braunstein

Das virtual in der Funktionssignatur ist nicht das Problem sondern eher die Position des const in der Parameterliste.
Warum weiß ich aber auch nicht.
Das hier geht

template<class t>
class footest
{
  public:
    virtual void f(t const& src) = 0;
};

class footest2 : public footest<char*>
{
  public:
    void f(char* const& src){};
};

Das hier nicht

template<class t>
class footest
{
  public:
    virtual void f(const t& src) = 0;
};

class footest2 : public footest<char*>
{
  public:
    void f(const char*& src){};
};

*D*Evil

b) muss man nicht?! Hmm scheint nicht direkt über "char*" zu gehen ... wenn du keinen Pointer nimmst, geht es.

template<typename T>
class foo
{
public:
	virtual void f(const T&) = 0;
};

class bar : public foo<char>
{
public:
	void f(const char&)
	{}
};
int main()
{
	bar g;
}

...

Helium

FreakyBKA schrieb:

a) was ist diamanten vererbung?

Er meint eine Diamantstruktur in deiner Hierarchie:

B und C erben beide von A, D erbt sowohl von B, als auch von C. D erbt indirekt zweimal von A. hier ist virtual nötig.

b) warum muss man das virtual da mitschleifen, denn bei

Muss man nicht, ist bullshit.

StarCraftFeuerteufel

hab nochmal bissl rumprobiert, der scheint generell damit probleme zu haben wenn man pointer nimmt, also foo<TYPE*>.
warum genau geht das mit pointern nicht?

Helium

FreakyBKA schrieb:

hab nochmal bissl rumprobiert, der scheint generell damit probleme zu haben wenn man pointer nimmt, also foo<TYPE*>.

Nein. Du machst

"const Type * &" was flasch ist

richtig wäre

"Type * const &"

Also konkret:

void f(char* const & src){}

StarCraftFeuerteufel

das ist mir ja ganz neu, dass man das so schreibt :-o
diese schreibweise hab ich bis jetzt noch nirgends gesehen.

Helium

FreakyBKA schrieb:

das ist mir ja ganz neu, dass man das so schreibt :-o

"const Foo *" ist das selbe, wie "Foo const *" Also ein veränderbarer Zeiger auf ein konstantes Foo.
"Foo * const" ist aber ein konstanter Zeiger auf ein veränderbares Foo.

Wenn du also von "foo<const char *>" ableiten würdest, müsstest du "const char * const &" in deiner Funktion verwenden.

inp

a)diamantenvererbung

class base
{
 int member;
};

class left : public base
{
};

class right : public base
{
};

class top : public left, public right
{
 void f()
 { 
  member = 10; //ambiguity, welches member ? left::member ? right::member ?
  left::member = 10; //ok
  right::member = 10; //ok
 }
}

class top2 : virtual public left, public right
{
 void f()
 {
  member = 10; //ok, virtual public left erzwingt das left::member das einzige existente member ist.
 }
}

im prinzip der klassische fall von diamanten vererbung
top benötigt im prinzip nur eine kopie von "base" hat aber 2
top2 löst as mit virtual vererbung.

hast recht (schleifs immer mit, gewohnheit..hehe)

StarCraftFeuerteufel

diamantvererbung ist mir schon klar, kannte den begriff dafür nur nicht.
das mit den * const& hab ich jetzt glaub ich verstanden.