Question

我仅出于学习目的使用C ++为String创建自己的类。

我停留在应该做出决定的地方。让我解释一下这件事。

我上课有两个选择。我将在下面仅发布相关的代码段，因为我不想分散您的注意力。如果为了帮助我，您需要更多信息，我们将很乐意提供。

选项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

因此，从选项1 和选项2 中可以看到，此处的决定是关于是否使用隐式类型转换的，该转换是在构造函数的帮助下完成的或为我想要 String 类型使用的每种类型分别键入每种实用程序。

据我现在所见，使用第一种方法的好处是易于实现和维护。虽然第二种方法可能会产生更好的性能结果。

我想获得建设性的论据，哪种方法更好，在哪种情况下以及您将使用哪种方法。我认为，我最感兴趣的是第二种方法的性能收益是否合理。

Answer 1

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

例如，运行与您的代码相似的代码：

#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关键字产生的错误消息可以为某人节省一些调试时间。

隐式转换有意义的某些情况是：

该类足够便宜，以至于您不需要关心它是否是隐式构造的。
某些类在概念上与它们的参数相似，例如std::string反映了与其可以隐式转换的const char*相同的概念，因此隐式转换很有意义，因为就是这种情况。
如果禁用了隐式转换，则某些类将变得更加令人不适。考虑一下，每次要传递字符串文字时，都必须显式构造std::string。

在某些情况下，隐式转换的意义不大：

建筑很昂贵。
类在概念上与它们的参数非常不同。考虑带有String和int的示例。
构造可能会产生有害的副作用。例如，AnsiString类不应从UnicodeString隐式构造，因为Unicode到ANSI的转换可能会丢失信息。

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

在这种情况下，通过构造函数或显式函数进行隐式转换的更好的方法是什么？

1 个答案: