accessing base class members when base is template

Discussion in 'C++' started by flopbucket, Jun 23, 2006.

  1. flopbucket

    flopbucket Guest

    Hi,

    If I have the following:

    template<class T>
    class A
    {
    public:
    int a;
    };

    template<class T>
    class B : public A<T>
    {
    public:
    void test()
    {
    A<T>::a=5;
    }
    };


    I see I need to do A<T>::a=5 in B<T>::test(). With non-template
    inheritance, this isn't needed - can just to a=5.

    I guess there is a good reason for this, unless I am missing something
    silly, but could anyone explain a bit why, or point to further
    reference?

    Thanks
    flopbucket, Jun 23, 2006
    #1
    1. Advertising

  2. flopbucket

    red floyd Guest

    flopbucket wrote:
    > Hi,
    >
    > If I have the following:
    >
    > template<class T>
    > class A
    > {
    > public:
    > int a;
    > };
    >
    > template<class T>
    > class B : public A<T>
    > {
    > public:
    > void test()
    > {
    > A<T>::a=5;
    > }
    > };
    >
    >
    > I see I need to do A<T>::a=5 in B<T>::test(). With non-template
    > inheritance, this isn't needed - can just to a=5.
    >


    You could also use this->a = 5;
    red floyd, Jun 23, 2006
    #2
    1. Advertising

  3. flopbucket wrote:
    > ...
    > template<class T>
    > class A
    > {
    > public:
    > int a;
    > };
    >
    > template<class T>
    > class B : public A<T>
    > {
    > public:
    > void test()
    > {
    > A<T>::a=5;
    > }
    > };
    >
    >
    > I see I need to do A<T>::a=5 in B<T>::test(). With non-template
    > inheritance, this isn't needed - can just to a=5.
    >
    > I guess there is a good reason for this, unless I am missing something
    > silly, but could anyone explain a bit why, or point to further
    > reference?
    > ...


    When it comes to templates, there's a notion of 'dependent name' in C++
    language. Dependent names, as is easy to guess, depend on the
    parameterized (i.e. template) portions of the type. Such names are
    generally resolved at "later" stages when all parameterized portions of
    the type are known. Other (i.e. non-dependent) names are resolved
    immediately.

    When you just say 'a' in your 'test()' method, the name 'a' is treated
    as a non-dependent name. For this reason, the compiler resolves this
    name immediately, without considering the parametrized base class. If
    you have no matching declaration in scope, the compiler will complain
    with an error (that's what you probably get). If you declare a global
    variable (say, 'int a') before the declaration of 'B', the name 'a' in
    'test()' will be treated as if refers to that global 'a', not to the
    'A<T>::a'. That happens, once again, because a simple non-qualified 'a'
    is not considered to be a dependent name.

    If you want to make the compiler to treat 'a' as a dependent name, you
    have to give it a hint. One way to do it is to use a fully qualified
    name 'A<T>::a'. Another way to do it to refer to it as 'this->a'.

    --
    Best regards,
    Andrey Tarasevich
    Andrey Tarasevich, Jun 23, 2006
    #3
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. John Harrison
    Replies:
    18
    Views:
    552
    Pete Becker
    Aug 11, 2003
  2. CoolPint
    Replies:
    8
    Views:
    973
    Jeff Schwab
    Dec 14, 2003
  3. Pete
    Replies:
    4
    Views:
    398
  4. Bhawna
    Replies:
    7
    Views:
    471
    Bhawna
    Aug 26, 2008
  5. Hicham Mouline
    Replies:
    1
    Views:
    590
    Victor Bazarov
    Apr 20, 2009
Loading...

Share This Page