重載+運算符連接C++中的兩個字符串（有些疑惑）

Question

幾天前我剛剛開始學習C++。我被賦予了一個任務來展示+運算符重載來連接兩個字符串。我想出了這個解決方案：

#include <iostream> 

using namespace std; 

class Strcpy{ 
private: 
    char* wrd; 
    int len; 

public: 
    Strcpy(); 
    Strcpy(char*); 

    void Display(); 

    friend Strcpy operator + (Strcpy, Strcpy); 
    friend Strcpy concatinator(Strcpy, Strcpy); 
}; 

Strcpy :: Strcpy(){ 
    wrd = '\0'; 
    len = 0; 
} 

Strcpy :: Strcpy(char* w){ 
    int i; len = 0; 
    for(i = 0; w[i] != '\0' ; i++) 
     len ++; 
    wrd = w; 
} 

void Strcpy :: Display(){ 
    cout << "\nOutput: " << wrd << " "<< len; 
} 


Strcpy operator + (Strcpy obj1, Strcpy obj2){ 
    Strcpy temp; 
    int i; 
    temp.wrd = new char[obj1.len + obj2.len]; 
    temp = concatinator(temp, obj1); 
    temp = concatinator(temp, obj2); 
    temp.wrd[temp.len] = '\0'; 
    return temp; 

} 

Strcpy concatinator(Strcpy obj, Strcpy temp){ 
    for(int i = 0; temp.wrd[i] != '\0'; i++) 
     { 
      obj.wrd[obj.len] = temp.wrd[i]; 
      obj.len++; 
     } 
    return obj; 
} 

int main(){ 
    Strcpy word, word_I("Hello"), word_II("World"); 
    word = word_I + word_II; 
    word.Display(); 
    return 1; 
} 

要注意的一些事情包括：

• 從字符串常量「字符*」 [-Wwrite串]我意識到這棄用轉換所引起因爲我正在將不可變類型轉換爲可變類型，但是我可以嘗試使用哪種替代方法來擺脫此問題。
• 我想避免使用朋友函數，但重載操作符需要兩個參數，如果它仍然是類成員，則這是不可能的。

• 下面一行的工程，即使它被更改一樣的，爲什麼會出現這種情況：

  temp.wrd = new char[obj1.len + obj2.len]; 
  //changed to 
  temp.wrd = new char[//any number here]; 
  

• 我想避免使用字符串函數，如果這是不可能的。

• 每當我嘗試下面的形式取得輸入，它崩潰：

  char* Strcpy :: get(){ 
      char* temp; 
      cin >> temp; 
      return temp; 
  } 
  
  int main(){ 
      Strcpy word; 
      Strcpy word_I(word.get()), word_II(word.get()); 
      word = word_I + word_II; 
      word.Display(); 
      return 1; 
  } 
  

• 最後，我希望得到任何幫助，這將有助於我對現有的解決方案提高和一些解釋，以爲什麼這是更好的，我犯的錯誤。

Answer 1

棄用轉換 - Wwrite-strings]我意識到這是由於我正在將不可變類型轉換爲可變類型而引起的，但是我可以嘗試使用哪種替代方法來擺脫此問題。

您從不修改*w，因此您可以使用指向const的指針代替。

我想避免使用朋友函數，但重載操作符需要兩個參數，如果它仍然是一個類成員是不可能的。

成員運算符重載的第一個參數是隱式this指針。如果您聲明Strcpy Strcpy::operator+(const Strcpy&) const，它將是一個二元運算符。也就是說，朋友操作員可能是更好的方法。

下面一行的工程，即使它被更改一樣的，爲什麼會出現這種情況：

temp.wrd = new char[obj1.len + obj2.len]; 
//changed to 
temp.wrd = new char[//any number here]; 

只要這將作爲「任意數量的」大到足以容納整個字符串。如果你在界限之外寫，行爲是不確定的。

每當我嘗試以下形式服用的輸入端，它崩潰：

char* temp; 
cin >> temp; 

流提取操作者需要傳遞給它一個char*必須指向陣列足夠大，以包含用戶輸入。您忘記初始化temp，所以不滿足要求。結果，程序的行爲是不確定的。解決方案：分配一些內存並初始化temp以指向該內存。

同樣的錯誤發生在構造函數Strcpy(char*)。您不初始化this->wrd，但您將其解除引用。因此行爲是不確定的。解決方案與上述相同。

Answer 2

如果我理解這個權利

我想避免使用友元函數，但重載操作符 需要兩個參數，如果它仍然是一個類成員這是不可能的。

你的說法是錯誤的。

樣品用於一個類中的二元+運算：

#include <iostream> 

class Int { 
    private: int _i; 
    public: 
    Int(int i = 0): _i(i) { } 
    Int operator + (const Int &i) const 
    { 
     return Int(_i + i._i); 
    } 
    int get() const { return _i; } 
}; 

int main(int, char**) 
{ 
    Int i1(1), i2(2); 
    Int i; 
    i = i1 + i2; 
    std::cout << "i: " << i.get() << std::endl; 
    return 0; 
} 

編寫和用gcc上cygwin的測試：從字符串常量 '字符*'[

$ g++ -o test-op-plus test-op-plus.cc 

$ ./test-op-plus.exe 
i: 3