连接两个动态字符串数组

template <typename Object>
class Vector1 {
public:
explicit Vector1(const Object & value = Object()) : size_{0} {
    array_ = new Object{value};
    size_++;
}
Vector1(const Vector1 & rhs) : size_{rhs.size_} { //copy constructor
    array_ = new Object[size_];
    for (int i = 0; i < size_; i++) {
        array_[i] = rhs.array_[i];
    }
}
Vector1 & operator=(const Vector1 & rhs) { //copy assignment operator
    array_ = new Object[rhs.size_];
    if (this != &rhs) {
        size_ = rhs.size_;
        for (int i = 0; i < size_; i++) {
            array_[i] = rhs.array_[i];
        }
    }
    return *this; 
}
Vector1(Vector1 && rhs) : array_{rhs.array_}, size_{rhs.size_} { //move constructor
    rhs.array_ = nullptr;
    rhs.size_ = 0;
}
Vector1 & operator=(Vector1 && rhs) { //move assignment operator
    if (this != &rhs) {
        std::swap(size_, rhs.size_);
        std::swap(array_, rhs.array_);
    }
    return *this;
}
void print(ostream & out) const {
    for (int i = 0; i < size_; i++) {
        out << array_[i] << " ";
    }
}
void ReadVector1() {
    int count = 0;
    cout << "Enter a size: ";
    cin >> size_;
    array_ = new Object[size_];
    for (int i = 0; i < size_; i++) {
        cout << "Enter element " << count + 1 << ": ";
        cin >> array_[i];
        count++;
    }
}
size_t Size() const {
    return size_;
}
**Vector1 operator+=(Vector1 & rhs) {
    size_t combosize = size_ + rhs.size_;
    Object combo[combosize];
    int count = 0, rhscount = 0;
    for (int i = 0; i < combosize; i++) {
        if (i % 2 == 0) {
            combo[i] = array_[count];
            count++;
        }
        else {
            combo[i] = rhs.array_[rhscount];
            rhscount++;
        }
    }
    std::swap(combosize, rhs.size_);
    std::swap(combo, rhs.array_);
    return *this;
}
Vector1 operator+(const Vector1 & rhs) const {
    Vector1 temp(*this);
    temp += rhs;
    return temp;
}**
~Vector1() { //destructor
    delete[] array_;
}
private:
    size_t size_; 
    Object *array_;
};
template <typename Object>
ostream & operator<<(ostream & out, const Vector1<Object> & rhs) {
    rhs.print(out);
    return out;
}

int main(int argc, char **argv) {
   Vector1<string> a, b;
   a.ReadVector1(); //user provides input for Vector1 a
   cout << a << endl;
   b.ReadVector1(); //user provides input for Vector1 b
   cout << b << endl; 
   cout << a + b << endl; //concatenates the two Vector1s
   Vector1<string> d = a + b;
   cout << d;
   return 0;
}

以上是我的代码(到目前为止(。我试图完成的是将 a 的动态数组与 b 的动态数组连接起来(我不能使用向量或任何 STL，这意味着对向量的基本模仿(。

例：

用户输入大小为 2 的 a，然后输入"Hello"和"World"。用户为 b 输入大小 2，然后输入"再见"和"世界"。输出应为"你好世界再见世界"。

我强调了我认为的问题是什么，即 + 和 += 运算符的重载。我的理由是我创建一个新数组，用 a 和 b 的值填充它，交换值，然后返回假定的串联。

我的推理可能看起来不合理，因为坦率地说，我对如何进行这项工作感到非常困惑。