在這種情況下，通過構造函數或顯式函數更好的隱式轉換是什么？

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關鍵字產生的錯誤消息可以節省一些花在調試上的時間。

隱式轉換有意義的一些情況是：

1. 這個類很便宜，可以構造你不關心它是否隱式構造。
2. 有些類在概念上與它們的參數類似 ，例如std::string反映了與它可以隱式轉換的const char*相同的概念，因此隱式轉換是有意義的，就像這里的情況一樣。
3. 如果禁用隱式轉換，某些類會變得更加令人不愉快。 想想每次要傳遞字符串文字時都必須顯式構造一個std::string 。

隱式轉換不太有意義的一些情況是：

1. 施工很昂貴。
2. 類在概念上與它們的論點非常不同。 考慮使用String和int的示例。
3. 施工可能會產生不良副作用。 例如， AnsiString類不應該從UnicodeString隱式構造，因為Unicode到ANSI的轉換可能會丟失信息。

所以，我在你的特定情況下的建議是使用轉換因為它是有意義的，因為你的類與std::string非常相似並且最小化代碼重復，但是在將來， 使用帶有思想的隱式轉換 。