重载运算符+ / char* ch1 + char* ch2答案

【问题标题】：overload operator+ / char* ch1 + char* ch2重载运算符+ / char* ch1 + char* ch2
【发布时间】：2011-04-03 22:54:16
【问题描述】：

我创建了带有一些额外功能的简单字符串类 - 主要用于学习目的。现在我想重载运算符 + 以允许我在字符串中添加两个或多个 char*。

这就是我想做的：

tom::string TXT;
TXT="abcde" + "1234";
cout << TXT << endl;

输出必须是：

abcde1234

我想稍后添加的不仅仅是 const char*：

..
int NUM=34;
TXT="abcd"+NUM+"098";
cout << TXT << endl;

输出必须是：

abcd34098

我已经用运算符做过类似的事情

TXT << "abcd" << ".......";

但我需要它与 + 运算符。另一件事是（可能会用 + 运算符排序）

void testF(tom::string INP) {
 cout << INP << endl;
}

int NUM=123;
testF("abcd"+NUM+"efg");

带输出：

abcd123efg

如果我正在尝试任何仍然以错误结尾的东西：

错误：类型的无效操作数 ‘const char [4]’和‘const char [3]’ 到二进制'operator+'

这里是 tom::string 类的一部分：

namespace tom {
    class string {
        private:
            unsigned int        _length;
            unsigned int        _search_pos;
            bool                _changed;
            bool                _indexed;
            char*               _buffer;
            unsigned int*       _indexes;
            unsigned int        _indexCount;
            char*               _emptyChar;
            unsigned int        _null;
            char*               _retBuffer[RET_BUFFERS];
            short unsigned int  _retBufferIndex;

            // ADD to string
            void _add (const char* txt) {
                _buffer=(char*) realloc(_buffer, sizeof(char)*(_length+strlen(txt)+1));
                memcpy(&_buffer[_length], txt, strlen(txt));
                _length=_length+strlen(txt);
                _buffer[_length]=static_cast<char>(0);
                _changed=true;
                free(_indexes);
                _changed=true;
                _indexCount=0;
                _indexed=false;
                _indexes = (unsigned int*) malloc (sizeof(unsigned int)*2);
            }


// .......

            // REPLACE Whole string
            string& _rvs(const char* txt) {
                free(_buffer);
                free(_indexes);
                _changed=true;
                _indexCount=0;
                _indexed=false;
                _indexes = (unsigned int*) malloc (sizeof(unsigned int)*2);
                _length=strlen(txt);
                _buffer = (char*) malloc (sizeof(char)*(_length+1));
                memcpy(_buffer, txt, _length);
                _buffer[_length]=static_cast<char>(0);
                return (*this);
            }


// .......
        public:
            // ----------------------------------------------
            // |                CONSTRUCTOR                 |
            // ----------------------------------------------
            string(const char* _init="") {
                _length=0;
                _indexCount=0;
                _changed=false;
                _indexed=false;
                _buffer = (char*) malloc (sizeof(char)*(strlen(_init)+1));
                memcpy(_buffer, _init, strlen(_init));
                _indexes = (unsigned int*) malloc (sizeof(unsigned int)*2);
                _emptyChar = (char*) malloc (sizeof(char));
                _buffer[strlen(_init)]=static_cast<char>(0);
                _emptyChar[0]=static_cast<char>(0);
                _null=(unsigned int)-1;
                _retBufferIndex=0;
                for (short unsigned int ii=0; ii<RET_BUFFERS; ii++) {
                    _retBuffer[ii] = (char*) malloc (sizeof(char));
                    _retBuffer[ii][0]=static_cast<char>(0);                 
                }
            }

            string(const tom::string& _init) {
                string((const char*)_init.c_str());
            }
            // ----------------------------------------------
            // |                 DESTRUCTOR                 |
            // ----------------------------------------------
            ~string() {
                free(_buffer);
                free(_indexes);
                free(_emptyChar);
                for (short unsigned int ii=0; ii<RET_BUFFERS; ii++) {
                    free(_retBuffer[ii]);
                }
            }


// .....
        string& operator = (string &ttxt) {
            const char* txt=ttxt.c_str();
            return (_rvs(txt));
        }

            string& operator = (const char* txt) {
                return (_rvs(txt));
            }

            string& operator = (int num) {
                char bf[32];
                sprintf (bf, "%d", num);
                const char* txt=bf;
                return (_rvs(txt));
            }

            string& operator << (const char* txt) {
                _add(txt);
                return(*this);
            }

            string& operator << (int num) {
                char bf[32];
                sprintf (bf, "%d", num);
                const char* txt=bf;
                _add(txt);
                return(*this);
            }

            operator const char*() {
                return (const char*)_buffer;
            }
// .....
    }
}

【问题讨论】：

我会改掉前缀标识符带下划线的习惯。你可能不知道相关的规则（到目前为止没有被破坏）。如果您必须为成员变量添加前缀，请使用 'm_'
郑重声明，关于字符串类型是否应该定义+ 运算符，文献中存在分歧。一方面，这似乎是一件显而易见的事情。另一方面，- 运算符没有意义。一元 + 和 - 也不行。 * 仅在一个操作数为正整数时才有意义。等等……
您的类包含 RAW 拥有的指针。我没有看到应用 3 的规则！面对你的复制构造函数完全坏了。
@Martin：说实话我不知道你在说什么 ;-( ...我是 C++ 的新手，我只是从示例中学习
@Mike：我知道有连接字符串的功能，但它更容易并且（对我而言）看起来更好，例如 debug("Variable 1:"+NUM+", indexed: "+ _索引）;喜欢用 printf 或

标签： c++ operator-overloading

【解决方案1】：

您不能只为指针类型重载运算符。至少有一个涉及的类型需要是用户定义的类型。

【讨论】：

【解决方案2】：

tom::string TXT;
TXT="abcde" + "1234";
cout << TXT << endl;

"abcde" + "1234" 首先被评估 - 你不能让它像你想要的那样工作。

您可以制作例如不过这项工作：

tom::string TXT;
TXT=tom::string("abcde") + 987 + "1234";
cout << TXT << endl;

这需要operator+(int) 和operator+(char const *)

编辑：示例运算符：

operator+ 应该返回一个新对象——而不是修改它被调用的对象。

class string {
  ...
  friend string operator+(string const & LHS, char const * RHS) {
    string s = LHS;
    s._add(RHS);
    return s;
  }
};

【讨论】：

如果第一个是（例如）tom::string("xx")，那么右侧的所有内容都会被添加，并且只有我定义了该类型才重要？
只要表达式中的 LHS 是您的字符串，运算符的关联性将确保所有连续添加都调用 operator+(yourstring, 不管)。
我已经添加了string& operator + (const char* txt) { _add(txt); return(*this); }，但我遇到了 malloc 错误；-(
@tominko: operator+ 应该创建并返回一个新对象。 operator+= 应该修改 this
@Erik:thanx for that - 仍然出现 malloc 错误，但有可能我班上的某些东西不正确;-)

【解决方案3】：

感谢埃里克！ ...排序（工作）

我已添加到 tom::string 类中：

friend string operator+(string const & LHS, char const * RHS) {
    string s;
    s=LHS;
    s._add(RHS);
    return s;
}

下一个抛出 malloc 错误 - 我必须检查它，但第一个工作完美！

friend string operator+(string const & LHS, char const * RHS) {
    string s=LHS;
    s._add(RHS);
    return s;
}

和测试：

void test2 (tom::string ooo) {
    cout << ooo << endl;
}

test2(tom::string("abcde")+"AA"+"BB");

显示：

abcdeAABB

再次感谢！

【讨论】：