problem bei vererbung / abstraktem zeugs

StarCraftFeuerteufel

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

class foo2 : virtual public foo<char*>
{
  public:
    void f(const char*& src){};
};

int main()
{
  foo2 g;
};

da bekomme ich folgende fehlermeldung, mit der ich nicht wirklich was anzufangen weiß, weil ich den fehler nicht sehe.

error C2259: 'foo2' : cannot instantiate abstract class
        due to following members:
        'void foo<t>::f(const t &)' : is abstract
        with
        [
            t=char *
        ]
see declaration of 'foo<t>::f'
        with
        [
            t=char *
        ]

vielleicht kann mir jemand helfen, schonmal danke im voraus.

inp

die funktionssignatur erwähnt ein virtual

template <typename T>
class foo_base
{
public:
	virtual void func(T const& par) = 0;
};

class foo : public foo_base<int>
{
public:
	virtual void func(int const& par)
	{ }
};

solltest keine virtual ableitung verwenden, es sei denn es ist absolut notwendig (zb diamanten vererbung)

Helium

inp schrieb:

die funktionssignatur erwähnt ein virtual

template <typename T>
class foo_base
{
public:
	virtual void func(T const& par) = 0;
};

class foo : public foo_base<int>
{
public:
	virtual void func(int const& par)
	{ }
};

Ich würde mal sagen, das bringt absolut rein gar nichts.

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.