#include <iostream>

class Affe
{
   public:

        protected:
                int var1;      
};

class Bear : public Affe
{

        public:
                Bear(int var_) : var1(var_) {};
                void foo() {
                        std::cout << var1 << std::endl;       
                };
};

int main()
{
    Bear b = Bear(3);
    b.foo();
}

heißt es dass es keinen feldnamen var1 gibt. Liegt das daran dass Bear noch keinen member abgeleitet hat und über die liste schon versucht wird zu setzen ? Wenn ja - wie kann ich das umgehen?

warum geht das hier

#include <iostream>

class Affe
{
   public:
        Affe(int var_) : var1(var_) {}
        protected:
                int var1;  
                int var2;    
};

class Bear : public Affe
{

        public:
                Bear(int var_) : Affe(var_) {var2 = -2;};
                void foo() {
                        std::cout << var1 << std::endl;       
                        var1 = 3;
                        std::cout << var1 << std::endl;
                        std::cout << var2 << std::endl;
                };
};

int main()
{
    Bear b = Bear(5);
    b.foo();
}

aber das hier nicht?

#include <iostream>

template <class T>
class Affe
{
   public:
        Affe<T>(int var_) : var1(var_) {}
        protected:
                int var1;  
                int var2;    
};

template<class T>
class Bear : public Affe<T>
{

        public:
                Bear<T>(int var_) : Affe<T>(var_) {var2 = -2;};
                void foo() {
                        std::cout << var1 << std::endl;       
                        var1 = 3;
                        std::cout << var1 << std::endl;
                        std::cout << var2 << std::endl;
                };
};

int main()
{
    Bear<int> b = Bear<int>(5);
    b.foo();
}

main.cpp: In constructor »Bear<T>::Bear(int)«:
main.cpp:18: Fehler: »var2« wurde in diesem Gültigkeitsbereich nicht definiert
main.cpp: In member function »void Bear<T>::foo()«:
main.cpp:20: Fehler: »var1« wurde in diesem Gültigkeitsbereich nicht definiert
main.cpp:23: Fehler: »var2« wurde in diesem Gültigkeitsbereich nicht definiert

Affe<T>::var1 = 2;

btw wo ist deine abstakte Basisklasse?

muss ich dann jedesmall den klassennamen::member angehen?

danke für weitere erklärungen

Ich nehme an, der Grund sind Spezialisierungen und ungewollte und -übersichtliche Nebeneffekte. Nimm etwa

typedef double value_t;

template<typename T> struct A {};
template<typename T> struct B : public A<T> {
  value_t x;
};

template<> struct A<int> { typedef int value_t; };

// ...

B<int> b; // b.x bleibt double.

Der Compiler geht davon aus, dass der Autor von B sich darauf verlässt, dass value_t die im globalen Namensraum definierten Eigenschaften besitzt. Wenn eine Überdeckung durch bestimmte Eigenschaften von A gewünscht ist, kann es halt per using-Direktive erklärt werden.

@seldon
Ich meine gelesen zu haben, dass man class anstatt typename vorziehen sollte wenn man weiß, das eine Klasse übergeben wird.

Spielt überhaupt keine Rolle. Sind völlig äquivalent.

template<template<typename> class TT>
struct A { };

nicht als

template<template<typename> typename TT> // Fehler!
struct A { };

schreiben. Ansonsten ist es Geschmackssache, welches Schlüsselwort man benutzt - ich bevorzuge typename, weil es mir klarer erscheint (die Vorlage wird ja durch die Benutzung von "class" nicht auf Klassen beschränkt), aber man könnte mit hinreichend mathematischer Anschauungsweise den Standpunkt vertreten, dass Basistypen auch Klassen (von Objekten) sind.

class zu schreiben, um zu signalisieren, dass man eine Klasse erwartet, scheint mir aber nicht sonderlich sinnvoll - man erwartet ja in so einem Fall nicht irgendeine Klasse, sondern eine Klasse, die bestimmte Anforderungen, die die Vorlage benötigt, erfüllt. Das muss man dann eh sinnvoll dokumentieren.