<p>In visual C++, I can do things like this:</p>

<pre><code>template &lt;class T&gt;
class A{
protected:
    T i;
};

template &lt;class T&gt;
class B : public A&lt;T&gt;{
    T geti() {return i;}
};
</code></pre>

<p>If I try to compile this in g++, I get an error.  I have to do this:</p>

<pre><code>template &lt;class T&gt;
class B : public A&lt;T&gt;{
    T geti() {return A&lt;T&gt;::i;}
};
</code></pre>

<p>Am I not supposed to do the former in standard C++?  Or is something misconfigured with gcc that's giving me errors?</p>

This used to be allowed, but changed in
gcc 3.4
.
In a template definition, unqualified names will no longer find members of a dependent base (as specified by [temp.dep]/3 in the C++ standard). For example,
```
```
template <typename T> struct B {
      int m;
      int n;
      int f ();
      int g ();
    };
    int n;
    int g ();
    template <typename T> struct C : B<T> {
      void h ()
      {
        m = 0; // error
        f ();  // error
        n = 0; // ::n is modified
        g ();  // ::g is called
      }
    };
```
```
You must make the names dependent, e.g. by prefixing them with this->. Here is the corrected definition of C::h,
```
```
template <typename T> void C<T>::h ()
    {
      this->m = 0;
      this->f ();
      this->n = 0
      this->g ();
    }
```
```