重载operator+ / char* ch1 + char* ch2

Question

我创建了带有一些额外函数的简单字符串类--它主要用于学习目的。现在我想要重载操作符+，允许我在字符串中添加两个或多个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 4’和‘const 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;
            }
// .....
    }
}

Answer 1

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;
  }
};

Answer 2

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

Answer 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

再来一次！