c++ - 模板类——几个问题

Question

我需要创建以两个整数作为参数的构造函数。

从那里我需要调用通过引用获取这些整数的方法。在这个方法中，我应该动态地将整数转换为 char* 类型(数字数组)。

在构造函数的末尾，我应该有两个 char* 数组而不是初始整数。

我有点不得不这样做，因为另一个类在结构上做同样的事情。并将它们保存到模板属性中。

---

我是 C++ 语言的新手，但我的第一个猜测是使用模板。我对该主题进行了一些研究，发现它应该有效。

我很想自己编译整个东西，但是在我脑海中实现 C++ 类的困惑产生了相当长的编译错误列表。

---

第一个问题 - 这可以使用模板来完成吗？第二个问题，因为我已经自己写了一些东西:

template <class type> class Addition {
   type num_a;
   type num_b;
   void convert(type, type);
public:
   Addition(type, type);
}

template <class type> Addition::Addition(type a, type b) {
   convert(&a, &b);
   num_a = a;
   num_b = b;
}
template <class type> Addition::convert(type *a, type *b) {
   int temp_a = a, temp_b = b;
   a = char[256], b = char[256];
   // converting
}

这样可以吗，还是我做错了什么？
您对我在 C++ 中实现类的方式有什么建议吗？

为什么我不能用一个值初始化属性，例如:

template <class type> class Addition {
   type outcome = 0;
}

如果在 C++ 中不需要使用 this 关键字，我该怎么做呢？:

template <class type> Addition::Foo(type a, type b) {
   this->a = a; // a = a;
   this->b = b; // b = b;
}

Answer 1

免责声明:我无法判断您是否真的需要您正在做的事情的模板。这取决于您希望 Adddition 类模板使用的不同类型的数量。如果您只将它用于 int，那么这可能会引入不必要的复杂性。您以后总是可以重构(这将是敏捷方法)。

话虽如此，如果要使用模板，通常的约定是为模板参数编写 T，为嵌套的 使用 type类模板中的 typedef。使用 typename 或 class 是个人喜好问题，但 typename 强调了内置类型也可以作为参数传递的事实。但是请注意，对于 template-template parameters，您需要编写

template<template<typename> class U> SomeClass { /* your definition */ };
                            ^^^^^ // <-- NOT typename here 

强调只有类模板可以作为参数传递。

关于您的代码，还有一些其他的挑剔之处可能会导致编译失败(convert() 中缺少返回类型，类定义中缺少分号):

template <typename T> 
class Addition 
{
   static const std::size_t N = 256; // are you sure that 256 is all you'll ever need?
   T num_a;
   T num_b;
   void convert(T const*, T const*); // by T const*, not T*
public:
   Addition(T const&, T const&); // by T const&, not T
}; // <-- make sure to end class definitions with a semi-colon!

template <typename T> 
Addition::Addition(T const& a, T const& b) 
{
   convert(&a, &b);
   num_a = a;
   num_b = b;
}

template <typename T>
void Addition::convert(T const* a, T const* b) // <-- use T const* if you don't modify the parameters
^^^^ // <-- you forgot the return type
{
   int temp_a = a, temp_b = b;
   a = char[N], b = char[N]; <-- hardcoded 256 is bad practice, better to keep that in 1 place only
   // converting
}

在 C++11 中，您甚至可以使用委托(delegate)构造函数(最新的 Visual C++ 支持，当然还有 gcc/Clang)并编写

template <typename T> 
Addition::Addition(T const& a, T const& b) 
:
    Addition(&a, &b) // delegate to the other constructor
{}

template <typename T>
Addition::Addition(T const* a, T const* b) // <-- use T const* if you don't modify the parameters
{
   int temp_a = a, temp_b = b;
   a = char[N], b = char[N]; <-- hardcoded 256 is bad practice, better to keep that in 1 place only
   // converting
}

最后，因为模板定义无论如何都必须在标题中，你甚至可以像这样在类定义中编写所有内容:

template <typename T> 
class Addition 
{
   static const std::size_t N = 256; // are you sure that 256 is all you'll ever need?
   T num_a;
   T num_b;

   Addition(T const*, T const*) // by T const*, not T*
   {
      int temp_a = a, temp_b = b;
      a = char[N], b = char[N]; 
      // converting
   }
public:
   Addition(T const&, T const&) // by T const&, not T
   :
       Addition(&a, &b) // delegate to the other constructor
   {} 
}; // <-- make sure to end class definitions with a semi-colon!

这使您免于繁琐地编写所有成员函数的声明和定义。对于短小精悍的类(无论如何你都应该努力)，这是编写模板的首选方式，但对于非常长的定义，你可能希望将声明和定义分开。

最后，正如@tacp 所解释的，您确实需要使用this->a 来消除类数据成员与函数参数的歧义。出于这个原因，人们通常在编写数据成员时使用尾部下划线或 m_ 前缀。