Specialization doesn't contain data that's declared in the primary template

user_3305546 0
Viewed 63
class Base {
public:
    virtual void load() = 0;
};

template<typename T>
class CustomConfig : public Base {
public:
    const T& getData() { return data; }
    T data;
};

template<>
class CustomConfig<std::set<uint32_t>> {
public:
    virtual void load() {
        this->data = {4, 5, 6};
    }
};

I don't know why I got the error:

class CustomConfig<std::set<unsigned int> >' has no member named 'data'

REAL CASE

In fact, I got such an issue: I need a virtual function, but it's return type is not unique, it may be a std::set, a std::vector, std::list or some other types. Then I was thinking the template technique might help. That's why I defined the class template<typename T> class CustomConfig.

I hope this was not a serious XY problem... Obviously I misunderstood how template class works.

templates c++
4 Answers

To provide an alternative to the other answers, which all say you must add your data member, there's another option which is to derive from a template instantiation instead:

class CustomConfigSetOfUInt : public CustomConfig<std::set<uint32_t>> {
public:
    void load() override {
        this->data = {4, 5, 6};
    }
};

If your CustomConfig provides other generalized functionality that would benefit from being done in the class template, then you might prefer this approach. Your design in general is a bit uncomfortable and does seem to have a "relaxed" attitude toward encapsulation either way. You may want to have a deeper think about it.

user_15530900

The specialization is a brand-new class (relative to the primary template), you have to declare the data member for it too (also the inheritting). E.g.

template<>
class CustomConfig<std::set<uint32_t>> : public Base {
public:
    virtual void load() {
        this->data = {4, 5, 6};
    }
    const std::set<uint32_t>& getData() { return data; }
    std::set<uint32_t> data;
};
user_33097900

CustomConfig<std::set<uint32_t>> is a specialization of CustomConfig<T>, ie it replaces CustomConfig<T> when T is std::set<uint32_t>, it does not derive from CustomConfig<T> like you are thinking. As such, it does not inherit any of the members of CustomConfig<T>.

The two are completely separate classes.

user_658630

That specialisation does not inherit from the template class, it is instead used in place of the templated class for a specific data type.

So it gets no data or load(), you have to provide them yourself, such as with:

template<>
class CustomConfig<std::set<uint32_t>> : public Base {
public:
    virtual void load() {
        this->data = {4, 5, 6};
    }
    const std::set<uint32_t> &getData() { return data; }
    std::set<uint32_t> data;
};

In any case, it's often a good idea to steer clear of more "generic" underlying types, as that can be a great assistance in discovering and repairing issues. By that, I mean something like type definitions to make things clearer:

using ConfigIntSet = std::set<uint32_t>; // Use *specific* type.
template<>
class CustomConfig<ConfigIntSet> : public Base {
public:
    virtual void load() {
        this->data = {4, 5, 6};
    }
    ConfigIntSet data;
};
user_148600
Related