1

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

从那里我需要调用通过引用获取这些整数的方法。在这个方法中，我应该动态地将整数转换为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++ 中使用这个关键字，我该怎么做这样的事情？：

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

2 回答 2

2

免责声明：我无法判断您是否真的需要模板来完成您的工作。这取决于您希望 Adddition 类模板使用的不同类型的数量。如果您只将它用于int，那么这可能会引入不必要的复杂性。您总是可以稍后重构（这将是敏捷方法）。

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

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 中，您甚至可以使用委托构造函数（由最新的 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_前缀编写数据成员。

于 2013-04-13T16:12:56.013 回答
1

对于你后面的问题：

template <class type> class Addition {
  //type outcome = 0; 
  //^^^^you have to call default constructor of type
  type outcome = type();
}

最好typename用于约定，使用class也可以。

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

如果传递的参数和成员同名，则需要使用this. 你不能做

a =a;
b =b;

因为a,b在本地范围内，但this->a意味着类成员a。

由于您总是想将整数转换为 char 数组，我认为您并不需要模板。除非您将来还想将 double、float 和其他类型转换为char*。我还没有查看所有问题，因此可能还有其他问题。

于 2013-04-13T13:28:28.207 回答