Как исправить переполнение стека на перегруженном операторе сложения в c ++

Question

Я пытаюсь изучить концепцию перегрузки операторов в c ++, но я застрял в проблеме, которую пытаюсь решить, используя operator+, где в моей основной функции я добавляю классы userdefiend вместе. Конструктор класса принимает указатель строки в качестве параметра.

Мое понимание концепции перегрузки операторов заключается в том, что вы объявляете функцию в классе, используя ключевое слово operatorX, и заменяете X на оператор, который вы хотите перегрузить. Например, если я хочу перегрузить оператор '-', я должен написать так operator-. Но когда я отлаживаю свой код, это приводит к переполнению стека, и программа останавливается.

Класс выглядит следующим образом:

class Hello{
public:
    Hello(string str):pstr(&str){

    }
    //The overloaded function below
    Hello operator+(Hello& h1){
        Hello temp(*this);//creates a copy of the current Hello-object
        temp = temp + h1;//adds the new value to the temporary object
        return temp; 
    }
private:
    string* pstr;//pointer to string-object
}

Я знаю, что получаю переполнение стека в перегруженной функции.

В основном методе у меня есть следующий код:

void main(){
    Hello h1("Hello ");
    h1 + Hello("World");
}

Я не знаю, что я правильно закодировал это, но результат должен быть Hello World в возвращаемом объекте, если я не ошибаюсь.

Как я могу решить эту проблему, чтобы избежать переполнения стека во время выполнения кода, а также как получить правильное возвращаемое значение?

Answer 1

в

Hello operator+(Hello& h1){
    Hello temp(*this);//creates a copy of the current Hello-object
    temp = temp + h1;//adds the new value to the temporary object
    return temp; 
}

оператор + рекурсивно вызывает себя, вам нужно действительно реализовать добавление

, вероятно, вы хотели:

Hello operator+(const Hello& h1) {
    Hello temp(*pstr + *(h1.pstr))
    return temp;
}

Исходя из этого, почему у вас есть pstr в качестве указателя на std::string, а не просто на std::string str;?

Гораздо более практично иметь, например:

class Hello{
  public:
    Hello(string s) : str(s) {  }

    Hello operator+(const Hello& h1){
       Hello temp(str + h1.str);

       return temp;
    }
  private:
    string str;
};

---

Обратите внимание, если вы действительно хотите, чтобы string* pstr; ваш конструктор

Hello(string str):pstr(&str){}

был неправильным, поскольку вы сохраняете адрес параметра,вам нужно изменить его, например:

Hello(string str) : pstr(new string(str)) {}

, и, имея указатель, вам нужно добавить деструктор для удаления строки, а конструктор копирования, оператор = и т. д., посмотрите на rule_of_three

Answer 2

При перегрузке операторов ключевой концепцией является то, как будет выглядеть поведение, если тип, который вы определяете, является примитивным типом. Например, как будет выглядеть добавление указателя на строку с другим указателем на строку.

Как уже упоминалось выше, ваше определение рекурсивно вызывает оператор +.

Вот пример, который может быть полезен: https://www.geeksforgeeks.org/operator-overloading-c/