Question

我对C ++（和堆栈溢出）完全陌生，所以请多多包涵。我正在尝试创建两个模板和一个从两个模板中获取输入的函数。

我试图制作一些与我的代码相似的示例代码，并重现该错误。基本上，我有两个模板Dog和Cat，并且想要创建一个分别包含Dog和Cat实例的运算符函数，但是我真的在如何编写函数头方面苦苦挣扎。在花了很多时间阅读Stack Overflow的帖子之后，我抛出了关键字'template'和'typename'试图使其工作，但是我总是遇到错误。当前错误是

候选模板被忽略：无法推断模板参数“ T”

def square_interpreter():
    keys_in_square = [[l + n for l in 'ABC' for n in '123'],
                      [l + n for l in 'ABC' for n in '456'],
                      [l + n for l in 'ABC' for n in '789'],
                      [l + n for l in 'DEF' for n in '123'],
                      [l + n for l in 'DEF' for n in '456'],
                      [l + n for l in 'DEF' for n in '789'],
                      [l + n for l in 'GHI' for n in '123'],
                      [l + n for l in 'GHI' for n in '456'],
                      [l + n for l in 'GHI' for n in '789']]
    for index in range(9):
        output = []
        for key in keys_in_square[index]:
            output.append(values[key])
        squares.append(output)

我的问题是：我应该如何为template <class T> class Dog { private: int size; public: Dog(int size1) { size = size1; } }; template <class T> class Cat { private: int size; public: Cat(int size1) { size = size1; } }; template <class T> // What to write here? typename Cat<T>::template Cat<T> operator*(typename Dog<T>::template Dog<T> m,typename Cat<T>::template Cat<T> v) { Cat<int> return_cat(1); return return_cat; } int main(int argc, char* argv[]) { Cat<double>::Cat<double> new_cat(2); Dog<double>::Dog<double> new_dog(4); Cat<double>::Cat<double> result = new_dog*new_cat; // ERROR couldn't infer template argument 'T' return 0; }函数定义函数标头，以避免出现任何错误？

Answer 1

我不确定您要对所有作用域运算符做什么。您不需要它们。只需使用适当的类型。我添加了const引用，因为在这种情况下它看起来很合理。并非严格要求它们。

template <class T>
Cat<T> operator*(const Dog<T>& m, const Cat<T>& v)
{
    Cat<T> return_cat(1);
    return return_cat;
}

int main(int argc, char* argv[])
{    
    Cat<double> new_cat(2);    
    Dog<double> new_dog(4);    
    Cat<double> result = new_dog * new_cat;    
    return 0;
}

Answer 2

我不确定您对operator*()的预期用途是什么，但是通常看起来像这样：

template <class T> 
Cat<T> operator*(Dog<T> m, Cat<T> v)

如果模板类相同，则允许猫和狗相乘。

如果它们不相同（即猫和狗的类型不同），那么您将需要这样的东西：

template <class T1, class T2> 
Cat<T2> operator*(Dog<T1> m, Cat<T2> v)

这允许猫和狗具有不同的类型并相乘。

Answer 3

为了稍微简化一点，以便更轻松地“读取”而不是将狗与猫“混合” ：），您可以使用此重载进行播放

template <class T>
class Animal
{
  private:
    T size;
  public:
  Animal(T size1) {
    size = size1;
  }
  T getSize() {
     return size;
}
Animal<T> operator*(Animal<T> animal1)
{
  T a = animal1.getSize();
  T b = this->getSize();
  Animal<T> animal = Animal<T>(a*b);
  return animal;
 }

};

int main（int argc，char * argv []） {

Animal<double> cat(2);
Animal<double> dog(4);
Animal<double> result( dog*cat );
return 0;

}

如何使用不同的模板作为输入定义功能

3 个答案: