базовый и производный класс, в базовом объявлена переменная "protected", она недоступна по имени в производном классе! template <class T> воду мутит!

#include <stdio.h>
template <class T>
class otets {
 protected:
  int peremennaya;
};
 
template <class T>
class sinn: public otets<T> {
 void  f ();  
};
 
template <class T>
void sinn<T>::f () {
 otets<T>::peremennaya= 11;
 sinn<T>::peremennaya= 11;
 //peremennaya= 11;
}
 
int main() {
 sinn<int> h;
 printf ("%x\n", &h.otets<int>::peremennaya);
 printf ("%x\n", &h.sinn<int>::peremennaya);
 printf ("%x\n", &h.peremennaya);
 getchar ();
}
{}

peremennaya= 11;

 otets<T>::peremennaya= 11;
 sinn<T>::peremennaya= 11;

otets<T>::peremennaya= 11;
 sinn<T>::peremennaya= 11;
peremennaya= 11;

peremennaya= 11;

template <class T>
void sinn<T>::f () {
 otets<T>::peremennaya= 11;
}

template <class T>
void sinn<T>::f () {
  sinn<T>::peremennaya= 11;
}

#include <stdio.h>
class otets {
 public:
  int peremennaya;
};
 
class sinn: public otets {
 void  f ();  
};
 
void sinn::f () {
 otets::peremennaya= 11;
 sinn::peremennaya= 11;
 peremennaya= 11;
};
 
int main() {
 sinn h;
 printf ("%x\n", &h.otets::peremennaya);
 printf ("%x\n", &h.sinn::peremennaya);
 printf ("%x\n", &h.peremennaya);
 getchar ();
}

// ...
this->peremennay = 11;
// ...

#include <iostream>
 
template <class T> class Base {
protected:
    int foo;
public:
    Base() {
        std::cout << "Base::foo address = " << & this->foo << std::endl;
    }
};
 
template <class T> class Derived : public Base<T> {
public:
    Derived() {
        std::cout << "Derived::foo address = " << & this->foo << std::endl;
    }
 
    void  bar (int value);
};
 
template <class T> void Derived<T>::bar (int value) {
    this->foo = value;
    std::cout << std::endl
        << "Base<T>::foo value " << Base<T>::foo << std::endl
        << "Derived<T>::foo value " << Derived<T>::foo << std::endl
        << "this->foo value " << this->foo << std::endl;
}
 
int main() {
    Derived<int> h;
    h.bar(666);
    return 0;
}

#include <iostream>
 
int foo;
 
template <typename T> class Base {
public:
    int foo;
};
 
template <typename T> class Derived : public Base<T> {
public:
    int get_foo () const {
        return foo;
    }
};
 
int main() {
 
    foo = 666;
 
    Derived<int> h;
    h.foo = 999;
 
    std::cout << h.get_foo() << std::endl;
    return 0;
}

    int get_foo () const {
        return this->foo;
    }