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.

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)

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.

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

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

meckert er nicht rum.

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){};
};

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;
}

...

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.

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){}

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.

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.

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