What's wrong on inheritance template?

Question

Here's my code:

#include <iostream>

struct Plot {
    float test;
    
    Plot() : test(1.0f) {
    }
};

template <class T>
struct PlotTest : Plot {
    T *pModule;
    
    PlotTest(T *module) : Plot(), pModule(module) {

    }
};

template <class T>
struct PlotTestCustom : PlotTest<T> {
    PlotTestCustom(T *module) : PlotTest<T>(module) {
        test = 2.0f;
    }
};

int main()
{

}

But when I compile, it seems that PlotTestCustom can't see the float test; variable (which is on the "main" parent).

Where am I wrong?

I suggest changing the title to something along "Why public base class member cannot be accessed in a template?" — quetzalcoatl, Aug 21 '20 at 07:46

nop666 · Accepted Answer · 2020-08-21T07:51:06.800

3

During name lookup with template, it won't look at the base class (there could be a specialization of PlotTest that does not inherit from Plot for instance).

Thus you will have to give the compiler a hint:

PlotTestCustom(T *module) : PlotTest<T>(module) {
    this->test = 2.0f;
}

It means delay lookup until instantiation by making it a dependent name.

Full example here:

#include <iostream>

struct Plot {
    float test;
    
    Plot() : test(1.0f) {
    }
};

template <class T>
struct PlotTest : Plot {
    T *pModule;
    
    PlotTest(T *module) : Plot(), pModule(module) {
        test = 3.0; // accessible Plot is not a dependent base class
    }
};

// specialization that does not inherit
template<>
struct PlotTest<int> {
};

template <class T>
struct PlotTestCustom : PlotTest<T> {
    PlotTestCustom(T *module) : PlotTest<T>(module) {
        this->test = 2.0f;
    }
};

int main()
{
    double d{};
    int i{};
    PlotTestCustom<double> p1{&d};
    //PlotTestCustom<int> p2{&i}; -> does not compile
}

edited Aug 21 '20 at 07:51

answered Aug 21 '20 at 07:32

nop666

585
2
6

2

But within `PlotTest` I can access to it without `this`. Why? – markzzz Aug 21 '20 at 07:35
"there could be a specialization of PlotTest that does not inherit from Plot for instance" uhm? `PlotTest` will always inherit from `Plot`: `struct PlotTest : Plot` – markzzz Aug 21 '20 at 07:38
@markzzz non dependent name are not lookup in dependent base class but `Plot` is not a dependent base class – nop666 Aug 21 '20 at 07:39
@markzzz see this example: https://godbolt.org/z/csvq9n – 463035818_is_not_an_ai Aug 21 '20 at 07:47
@markzzz add a theoretical `template <> struct PlotTest {};` and that is not true anymore. – Quentin Aug 21 '20 at 07:47
1

@markzzz I updated my answer by the way – nop666 Aug 21 '20 at 07:49
Now is clear! Thanks :) – markzzz Aug 21 '20 at 08:00

nvevg · Answer 2 · 2020-08-21T07:39:18.867

1

test is not a dependent name here, so you have to access it through this pointer thus deferring actual lookup until the template parameter is known

coliru

edited Aug 21 '20 at 07:39

answered Aug 21 '20 at 07:33

nvevg

180
1
9

score 1 · Answer 3 · answered Aug 21 '20 at 07:56

1

You have to give compiler a hint, in what part of your object this member can be found:

template <class T>
struct PlotTestCustom : PlotTest<T> {
    PlotTestCustom(T *module) : PlotTest<T>(module) {
        Plot::test = 2.0f;
    }
};

answered Aug 21 '20 at 07:56

bipll

11,747
1
18
32

What's wrong on inheritance template?

3 Answers3