我正在使用 C++ 创建自己的 String 类，仅用于学习目的。

然后我卡在了应该做决定的地方。让我解释一下。

我的类(class)有两个选择。我将仅在下面发布相关的代码片段，因为我不想分散您对我手头问题的注意力。如果为了帮助我，您需要更多信息，我很乐意提供。

选项 1

class String {
    size_t _length;
    char* _stringHead;
public:
    String(const std::string&);
    String(const char*);
    String(const char);
};
String operator+(String, const String);

const bool operator==(const String, const String);
const bool operator!=(const String, const String);
const bool operator<(const String, const String);
const bool operator<=(const String, const String);
const bool operator>(const String, const String);
const bool operator>=(const String, const String);

选项 2

class String {
    size_t _length;
    char* _stringHead;
public:
    //irrelevant part of code in Option 2
    String(const std::string&);
    String(const char*);
    String(const char);
    //irrelevant part of code in Option 2
};
String operator+(String, const String&);

const bool operator==(const String&, const String&);
const bool operator!=(const String&, const String&);
const bool operator<(const String&, const String&);
const bool operator<=(const String&, const String&);
const bool operator>(const String&, const String&);
const bool operator>=(const String&, const String&);

//for std::string
String operator+(String, const std::string&);

const bool operator==(const String&, const std::string&);
const bool operator!=(const String&, const std::string&);
const bool operator<(const String&, const std::string&);
const bool operator<=(const String&, const std::string&);
const bool operator>(const String&, const std::string&);
const bool operator>=(const String&, const std::string&);

String operator+(const std::string&, String);

const bool operator==(const std::string&, const String&);
const bool operator!=(const std::string&, const String&);
const bool operator<(const std::string&, const String&);
const bool operator<=(const std::string&, const String&);
const bool operator>(const std::string&, const String&);
const bool operator>=(const std::string&, const String&);
//for std::string

//the same goes for char* and char
...
//the same goes for char* and char

因此，正如您从Option 1 和Option 2 规范中看到的那样，这里的决定是关于是否使用在构造函数的帮助下完成的隐式类型转换或者为我希望我的 String 类型工作的每种类型分别键入每个实用程序。

据我目前所知，使用第一种方法的好处是它更易于实现和维护。而第二种方法可能会产生更好的性能结果。

我希望得到建设性的论据，哪种方法更好，在什么情况下以及您会使用哪种方法。我认为我在这里最感兴趣的部分是第二种方法的性能优势是否合理。

最佳答案

当将参数类型的实例传递给需要类类型的方法时，隐式构造函数用于创建类类型的实例。这种隐式转换是通过调用类的构造函数来完成的。

例如，运行与您类似的代码:

#include <iostream>

class String {
 public:
  String(const std::string& s) {
    std::cout << "called" << std::endl;
  };
};

std::ostream& operator<< (std::ostream& stream, const String& s) {
  return stream;
}

void hello(String s) {
  std::cout << "Hello " << s; // Outputs "called" before "Hello ".
}

int main() {
  std::string s = "world";
  hello(s); // Uses the implicit conversion constructor.
}

因为每次都必须创建类 String 的新实例，所以预计性能会受到轻微影响。但是，在我看来，这还不足以抵消其好处:隐式转换可以极大地简化类设计者的工作并使类的使用更加容易。

但是，请记住，在某些情况下，如果转化是自动发生的，团队成员更有可能感到惊讶，而不是因为转化的存在而得到帮助。

举个例子:

#include <iostream>

class String {
 public:
  String(int size) {};
};

std::ostream& operator<< (std::ostream& stream, const String& s) {
    return stream;
}

void hello(String s) {
  std::cout << "Hello " << s; // Prints "Hello " as no error occurs.
}

int main() {
  hello(10); // It still calls the implicit conversion constructor.
}

在上面的代码中，explicit 关键字产生的错误消息可以节省调试人员的一些时间。

隐式转换有意义的一些情况是:

1. 该类的构造成本低到足以让您不关心它是否是隐式构造的。
2. 一些类在概念上与其参数相似，例如 std::string 反射(reflect)了与 const char* 相同的概念它可以隐式转换自，因此隐式转换是有意义的，就像这里的情况一样。
3. 如果隐式转换被禁用，一些类会变得更难用。想想每次你想传递一个std::string字符串文字。

一些隐式转换意义不大的情况是:

1. build 成本​​高。
2. 类在概念上与其参数非常不同。考虑使用 String 和 int 的示例。
3. 构造可能会产生不需要的副作用。例如，AnsiString 类不应从 UnicodeString 隐式构造，因为 Unicode-to -ANSI 转换可能会丢失信息。

因此，在您的特定情况下，我的建议是使用转换，因为它很有意义，因为您的类与 std::string 非常相似，并且可以最大限度地减少代码重复，但在未来， 考虑使用隐式转换。

关于c++ - 在这种情况下，通过构造函数或显式函数进行隐式转换更好吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/52431214/