Объединение двух массивов типа T в C++

Question

В настоящее время я пытаюсь перегрузить оператор +, чтобы объединить два массива типа T, но я наносил удар по стене в течение последнего часа или около того. Я хочу сделать это, не используя stl, потому что я новичок в C++, и я хочу получить хороший контроль над реализацией классов перед использованием стандартных.

Контекст будет состоять в том, что я в настоящее время разрабатываю собственный класс vector, используя шаблонный динамически выделенный массив.

Поэтому то, что я заинтересован в в этой точке перегрузки оператора + так, что при выполнении c = a + b внутри основной функции, где a , b , c являются Vector<T> объекты, c бы стать сочетание этих двух (конкатенации).

Я не могу поверить в это, поскольку функция, определяющая поведение оператора, может обрабатывать не более одного параметра.

Может ли кто-нибудь предложить какие-либо идеи?

Answer 1

Попробуйте это:

template<typename T> 
class Vector 
{ 
private: 
    T *m_array; 
    int m_count; 

public: 
    Vector() 
     : m_array(NULL), m_count(0) 
    { 
    } 

    Vector(const Vector &src) 
     : m_array(NULL), m_count(0) 
    { 
     T* new_array = new T[src.m_count]; 
     for (int x = 0; x < src.m_count; ++x) 
      new_array[x] = src.m_array[x]; 

     m_array = new_array; 
     m_count = src.m_count; 
    } 

    ~Vector() 
    { 
     delete[] m_array; 
    } 

    // mutilator and accessor functions ... 

    Vector& operator=(const Vector &rhs) 
    { 
     if (this != &rhs) 
     { 
      T* new_array = new T[rhs.m_count]; 
      for (int x = 0; x < rhs.m_count; ++x) 
       new_array[x] = rhs.m_array[x]; 

      T* old_array = m_array; 
      m_array = new_array; 
      m_count = rhs.m_count; 

      delete[] old_array; 
     } 

     return *this; 
    } 

    Vector& operator+=(const Vector &rhs) 
    { 
     int new_count = m_count + rhs.m_count; 
     T* new_array = new T[new_count]; 

     for (int x = 0; x < m_count; ++x) 
      new_array[x] = m_array[x]; 
     for (int x = 0; x < rhs.m_count; ++x) 
      new_array[m_count+x] = rhs.m_array[x]; 

     T* old_array = m_array; 
     m_array = new_array; 
     m_count = new_count; 

     delete[] old_array; 

     return *this; 
    } 
}; 

template<typename T> 
Vector operator+(const Vector<T> &lhs, const Vector<T> &rhs) 
{ 
    // if you want to optimize this further, make this operator 
    // a 'friend' of the Vector class so it can access the 
    // m_array and m_count fields directly, then it can perform 
    // one allocation+copy instead of two... 

    Vector<T> v(lhs); 
    v += rhs; 
    return v; 
} 

Vector a, b, c; 
// add items to a and b ... 
c = a + b;