оператор перегрузки + / char * ch1 + char * ch2

Question

Я создал простой строковый класс с некоторыми дополнительными функциями - в основном для целей обучения. Теперь я хочу перегрузить оператор +, чтобы позволить мне добавить два или более символа * в мою строку.

вот что я хочу сделать:

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

и вывод должен быть:

abcde1234

Я хочу добавить больше, чем просто константный символ *, например:

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

и вывод должен быть:

abcd34098

я уже проделал аналогичную операцию с оператором << </p>

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

но мне это нужно с оператором +. Другое дело (вероятно, это будет отсортировано с помощью оператора +)

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

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

с выводом:

abcd123efg

, если я пытаюсь что-либо, все еще заканчивающееся ошибкой:

ошибка: недопустимые операнды типов ‘Const char [4]’ и ‘const char [3]’ в двоичный ‘оператор +’

вот часть класса 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

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

Answer 2

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

"abcde" + "1234" оценивается первым - вы не можете заставить его работать так, как хотите.

Вы можете, например, выполнить эту работу, хотя:1008 * и operator+(char const *)

РЕДАКТИРОВАТЬ: Оператор выборки:

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

Answer 3

Спасибо Эрику! ... отсортировано (работает)

Я добавил в tom :: string class:

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

Спасибо еще раз!