Template function in class

Question

I don't know what to do. I always get an error by using a simple class and a simple template function. I read all the other solutions but they didn't helped me.

Next to some other classes I have the simple class Data:

class Data{
public:
    template <class T>
    T dat();
    int id;
    union{
        char c;
    int i;
    double d;
    };
};

and the function dat:

template <class T>
T Data::dat(){
    if(id == 1) return i;
    if(id == 2) return d;
    if(id == 3) return c;
}

As you can see, I want to check the id and return int, double or char. Now I've tried to print the value in the main function like this:

Data test;
test.id=1;
test.i = 12;
cout<<test.dat();

But I always get this error message:

Error: Could not find a match for Data::dat<Data::T>() needed in main(int, char**).

Where is the problem??

Thank you

Answer 1

To put it precisely, you want the return type of the function to depend on it's the id field in the object; in other words, dynamically. Templates are resolved at compile time, so they cannot help here. You'll have to return something like boost::variant or boost::any, which supports such dynamic typing.

Answer 2

Use this:

cout<<test.dat<int>();

Answer 3

dat() has no parameters involving T, so the compiler cannot deduce T from the call and it must be provided explicitly, e.g.:

cout << test.dat<int>();

---

Also, bear in mind you must implement dat() in the header file.

Answer 4

I don't know what to do. I always get an error by using a simple class and a simple template function. I read all the other solutions but they didn't helped me.

It seems to me that you want to create a discriminated union.

Your implementation won't work, because the return type of a template function is determined at compilation time (i.e. before you set a value in id and try to call the function.

Solution:

class Data
{
    enum value_type {
        int_val, char_val, double_val
    } discriminator; // private (the user doesn't see this)
                     // this replaces your id

    union{
        char c;
        int i;
        double d;
    } value;

public:
    class wrong_type_error: public std::logic_error
    {
    public:
        wrong_type_error(const std::string& msg): std::logic_error(msg) {}
    };

    explicit Data(const char c)
    : discriminator(Data::char_value)
    , value.c(c)
    {
    }

    explicit Data(const int i)
    : discriminator(Data::int_value)
    , value.i(i)
    {
    }

    explicit Data(const double d)
    : discriminator(Data::double_value)
    , value.d(d)
    {
    }

    // don't put this here: int id;

    // this part can be optimized to simpler (more idiomatic) code
    template<typename T> T get() const; // undefined
    template<> int get() const {
        if(discriminator != Data::int_val)
            throw wrong_type_error("Cannot return a int from Data instance");
        return value.i;
    }
    template<> char get() const {
        if(discriminator != Data::char_val)
            throw wrong_type_error("Cannot return a char from Data instance");
        return value.c;
    }
    template<> double get() const {
        if(discriminator != Data::double_val)
            throw wrong_type_error("Cannot return a double from Data instance");
        return value.d;
    }
};

Client code:

Data test(10.5);
cout<<test.get<double>();

All that said, you should consider using a boost::variant or boost::any instance, depending on your needs.

Answer 5

VS2012 says "error C2783: 'T Data::dat(void)' : could not deduce template argument for 'T'"

You just need to tell the function dat what T is:

cout<<test.dat<int>();

The template type can be deduced if you pass a templated parameter, but it cannmot guess the return type.