Template variable

Question

I can create template functions like this:

template<typename T> T trivialA(T in) { return in; }
template<typename T> T trivialB(T in) { return in; }

// Calculation
int main(int argc, char *argv[]) {
    trivialA<int>(1);
    trivialB<int>(2);
    return 0
}

However, what I would like to do, is something like this (so the user can specify the precision they want):

template<typename T> T trivialA(T in){ return in; }
template<typename T> T trivialB(T in){ return in; }

// Calculation
int main(int argc, char *argv[]) {
    type THETYPE = int; //<<<<<<<<<<<<<<< WHAT IS THE CORRECT WAY TO DO THIS?
    trivialA<THETYPE>(1);
    trivialB<THETYPE>(2);
    return 0;
}

So my question is, how can I hold the datatype as a variable and pass it into my template functions?

You cannot hold the datatype as a variable and pass it to template functions. The reason is that templates must be decidable at compiletime, but the variable may be decided at runtime. The decision has to be made at compiletime. — DavidO
– DavidO, Commented Jun 18, 2014 at 16:27

Mooing Duck · Accepted Answer · 2014-06-18 16:52:53Z

The old way that you see everwhere is

typedef int THETYPE;
typedef char*(*func_ptr)(int); //declare func_ptr as a pointer to a `char*(int)` function.

The newer more intuitive way:

using THETYPE = int;
using func_ptr = char*(*)(int);

Note that this effectively just makes a new name for a type at compile time, and cannot be changed. Ergo, useless for runtime decisions. If you need to decide at runtime, you'll need to enumerate the possible types and then use an enumeration, and possible type erasure via dynamic polymorphism.

Simple way

template<class T>
void do_stuff() {
    std::cout << 4;
}
enum use_type_enum {use_int, use_float};
int main() {
    use_type_enum use_type;
    std::cin >> use_type;

    switch(use_type) {
    case use_int: do_stuff<int>(); break;
    case use_float: do_stuff<float>(); break;
    default: throw std::runtime_error("incorrect math type");
    }
}

complex but powerful way:

struct math_type {
    virtual ~math_type() {}
    virtual void print() const =0;
};
template<class T>
struct math_type_instance {
    T var;
    math_type_instance(T v) : var(v) {}
    virtual ~math_type_instance () {}
    virtual void print() const {std::cout << var;}
};
enum use_type_enum {use_int, use_float};

int main() 
    use_type_enum use_type;
    std::unique_ptr<math_type> variable;

    std::cin >> use_type;

    switch(use_type) {
    case use_int: variable = make_unique<math_type_instance<int>>(3); break;
    case use_float: variable = make_unique<math_type_instance<float>>(3); break;
    default: throw std::runtime_error("incorrect math type");
    }

    variable->print();
}

R Sahu · Accepted Answer · 2014-06-18 16:27:40Z

0

Use typedef.

typedef int THETYPE;

answered Jun 18, 2014 at 16:27

R Sahu

207k15 gold badges168 silver badges291 bronze badges

Collectives™ on Stack Overflow

Template variable

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related