Question

我对C ++中的模板主题不太了解。为什么在以下玩具示例代码中，我们必须在类之前和每个函数的名称前加template <class T>（这意味着我们为什么需要它？）

是否可以修改代码而不是在任何地方使用template <class T>？

#include <iostream>
#include <vector>
#include <cstdlib>
#include <string>
#include <stdexcept>

using namespace std;

template <class T>
class Stack {   private:
    vector<T> elements;

  public:
    void push(T const &);
    void pop();
    T top();
    bool empty(); };

template <class T>
void Stack<T>::push(T const &elem) {
    elements.push_back(elem); }

template <class T>
void Stack<T>::pop() {
    if (elements.empty()) {
        throw out_of_range("Stack<>::pop(): empty stack");
    } else {
        elements.pop_back();
    }
}

template <class T>
T Stack<T>::top() {
    if (empty()) {
        throw out_of_range("Stack<>::top(): empty stack");
    }
    return elements.back();
}

template <class T>
bool Stack<T>::empty() {
    return elements.empty();
}


int main() {
    try {
        Stack<int> intStack;       // Stack of ints
        Stack<string> stringStack; // Stack of strings

        // Manipulate integer stack
        intStack.push(7);
        cout << intStack.top() << endl;

        // Manipulate string stack
        stringStack.push("hello");
        cout << stringStack.top() << std::endl;
        stringStack.pop();
        stringStack.pop();
    }
    catch (exception const &ex) {
        cerr << "Exception: " << ex.what() << endl;
        return -1;
    }
}

Answer 1

您必须在每个成员定义中包含template <class T>，因为这是成员名称的一部分。

您可以在类模板主体中定义函数，仅适用于template <class T>

的一行

template <class T> 
class Stack {   
  private:
    vector<T> elements;

  public:
    void push(T const &) {
      elements.push_back(elem); }
    void pop() {
      if (elements.empty()) {
          throw out_of_range("Stack<>::pop(): empty stack");
      } else {
          elements.pop_back();
      } }
    T top() {
      if (empty()) {
          throw out_of_range("Stack<>::top(): empty stack");
      }
      return elements.back(); }
    bool empty() {
      return elements.empty(); } };

Answer 2

C ++是一种statically typed语言。

因为这种情况，我想要一个功能来检查两个值的最小值或最大值。

我可以创建如下函数：

jobDate <- as.Date(jobDateFromJobSelectionMarking)

#Subtract and add 6 months from job date (time is in days)
jobDate6mBefore <- as.Date(jobDate-180)
jobDate6mAfter <- as.Date(jobDate+180)

但这只适用于int max(int a, int b) { return (a > b) ? a : b; }类型。如果我需要int或double或uint64_t，我需要创建其他功能：

FooBarClass

为什么在以下玩具示例代码中我们必须在类和每个函数的名称前加上模板？

在C ++中，double max(double a, double b) { return (a > b) ? a : b; } uint64_t max(uint64_t a, uint64_t b) { return (a > b) ? a : b; } FooBarClass max(FooBarClass a, FooBarClass b) { return (a > b) ? a : b; }是一种引入称为"generics"的概念的方法。使用泛型，您不再需要关注自己为每种类型创建函数，类型将从模板函数签名中推断出来。

相反，我可以写下以下内容：

template

在函数签名中包含template < typename T > // the typename or class keywords are synonymous when declaring a template T max(T a, T b) { return (a > b) ? a : b; }表示编译器该函数是＆＃34;泛型＆＃34;功能，必须相应处理。

另一方面，如果你刚才有以下内容：

template < typename T >

编译器希望T max(T a, T b) { return (a > b) ? a : b; }是一个显式类型（如T）。

模板可以同时应用于类或函数：

typedef int T;

您还可以明确定义模板类型，这称为template specialization 鉴于您目前对模板的理解，这超出了本答案的范围。

是否可以修改代码而不是到处使用模板？

是和否。是的，您可以删除template < typename T > class Wrapper { public: Wrapper(const T& val) : _val(val) {} // ... other code template < typename X > operator X() { return static_cast<X>(this->_val); } T operator+(const T& val) { return this->_val + val; } friend std::ostream& operator<<(std::ostream& os, const Wrapper& val) { os << val._val; return os; } private: T _val; }; int main(int argc, char* argv[]) { Wrapper<int> x(42); // template deduction will call Wrapper::operator X() with X being a double double d = x; // template deduction will call Wrapper::operator X() with X being a long long l = x; // this actually calls T operator+(const T& val) with val = 10 and T = int int i = x + 10; std::cout << "x = " << x << std::endl // 42 << "d = " << d << std::endl // 42 << "l = " << l << std::endl // 42 << "i = " << i << std::endl; // 52 return 0; }签名定义，但如上所述，类/函数的签名具有完全不同的含义。

希望清除一点点。如果使用得当，模板在C ++中是一个非常强大的工具。

在声明类和函数时，在C ++中使用模板<class t =“”>

2 个答案: