Оператор + перегрузка не работает

Question

Я только что разработал класс String и перегрузил =, <, [] операторы, но мой оператор + не работает, немного помогите ему!

Класс:

class String 
{ 
private: 
    int length; 
    char *chars; 
public: 
    String oprator+(String &obj); 
} 

Основной код:

int main () 
{ 
    String str1; 
    str1 = "This is first text"; 
    String str2; 
    str2 = "This is second text"; 

    String bigString = str1 + str2; 
    bigString = bigString + "This is third text"; 
} 

оператор + перегрузки:

String::String operator+ (String &obj) 
{ 
    String *temp = new String(); 
    strcpy(temp->chars, chars); 
    strcat(temp->chars, obj.chars); 
    return *temp; 
} 

Answer 1

Ваш operator+ следует читать

class String 
{ 
private: 
    int length; 
    char *chars; 
    String(const char* s, size_t n): 
     length(n), 
     chars(new char[n]) 
    { 
     std::copy(s, s+length, chars); 
    } 

public: 
    explicit String(size_t l): 
     length(l), 
     chars(new char[l]) 
    { 
    } 

    String(char const* s): 
     String(s, strlen(s)) 
    { 
    } 

    String(String const& s): 
     String(s.chars, s.length) 
    { 
    } 

    String& operator=(String s) 
    { 
     std::swap(chars, s.chars); 
     std::swap(length, s.length); 
     return *this; 
    } 

    ~String() {delete[] chars;} 

    template<size_t N> String(const char s[N]): 
     String(s, N) 
    { 
    } 

    void append(String const& s) 
    { 
     char* tmp = new char[length + s.length]; 
     std::copy(chars, chars+length, tmp); 
     std::copy(s.chars, s.chars + s.length, tmp + length); 
     delete[] chars; 
     chars = tmp; 
    } 

    template<typename S> friend S& operator<<(S&, String const&); 
}; 

String operator+(String const& s1, String const& s2) 
{ 
    String merged(s1); 
    merged.append(s2); 
    return merged; 
} 

template<typename S> S& operator<<(S& stream, String const& s) 
{ 
    return stream << s.chars; 
} 

int main() 
{ 
    String s("bla"); 
    std::cout << s << std::endl; 
    String s2 = s + "bla"; 
    std::cout << s2 << std::endl; 
} 

Вы не хотите изменять аргумент, поэтому он должен быть ссылкой на константу. Что делает его неконстантный предотвращает код, как

bigString = bigString + "This is third text"; 

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

И оператор не должен быть функцией-членом, а свободной функцией, чтобы воспользоваться преобразованиями по первому аргументу. С бесплатной функцией, вы можете сделать

bigString = "This is third text" + bigString; 

, что невозможно с помощью функции-члена, потому что char const[] не имеет operator+, который принимает String.

PS: Вы можете прочитать Monoliths "Unstrung" для некоторого критика интерфейса std :: string.