Question

我可以像这样创建模板函数：

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
}

但是，我想做的是这样的（所以用户可以指定他们想要的精度）：

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;
}

所以我的问题是，如何将数据类型保存为变量并将其传递给我的模板函数？

Answer 1

你看到的旧方式是

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

更直观的新方法：

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

请注意，这实际上只是在编译时为类型创建一个新名称，并且无法更改。因此，对于运行时决策毫无用处。如果需要在运行时决定，则需要枚举可能的类型，然后使用枚举，以及通过动态多态性进行可能的类型擦除。

简单方法

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");
    }
}

复杂但有力的方式：

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();
}

Answer 2

使用typedef。

typedef int THETYPE;

模板变量

2 个答案: