Concatenating two dynamic string arrays? - c++

Question

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;
}
The above is my code (thus far). What I'm trying to accomplish is to concatenate a's dynamic array with b's dynamic array (I cannot use vectors or any STLs, this is meant to be a rudimentary imitation of a vector).
Example:
The user inputs a size of 2 for a and inputs "Hello" and "World".
The user inputs a size of 2 for b and inputs "Goodbye" and "World".
The output should be "Hello World Goodbye World".
I highlighted what I think the problem is, which is the overloading of + and the += operators. My reasoning is that I create a new array, fill it up with the value's from a and b, swap the values, and then return the supposed concatenation.
My reasoning may not seem sound because frankly, I'm quite confused on how to proceed with this.

Answer 1

There are a few issues with your code concerning operator +=.
First, operator += should return a reference to the current object, i.e. return *this;. It shouldn't return a brand new Vector1 object.
Second, this line:
size_t combosize = size_ + rhs.size_;
Object combo[combosize];
is not valid ANSI C++, since arrays must be declared with a compile-time expression to denote the number of entries. Since combosize is a runtime value, it cannot be used.
You are probably using the GCC compiler, where there is a Variable Length Array extension, but again, this is an extension and is not really part of the C++ language.
Also, you are missing some constructors that would make writing operator += much easier. The constructor for Vector1 that you're lacking is this one:
Vector1::Vector1(size_t num) : array_(new Object[num]), size_(num) {}
This constructor just constructs a Vector1 with num entries.
Given the above, to fix the issues:
Vector1& operator+=(const Vector1 & rhs)
{
// create a temporary vector
Vector1 temp(size_ + rhs.size_);
// copy elements to temp array
for (int i = 0; i < size_; i++)
temp.array_[i] = array_[i];
// copy elements from rhs to temp array
int j = 0;
for (int i = size_; i < size_ + rhs.size_; i++, j++)
temp.array_[i] = rhs.array_[j];
// assign and return
*this = temp;
return *this;
}
Vector1 operator+(const Vector1 & rhs) const
{
Vector1 temp(*this);
temp += rhs;
return temp;
}
Note that in operator += we just create a temporary Vector1, fill it up with the values from *this and the passed in Vector1, and assign it to the current object. The *this = temp; line requires a working assignment operator. See the next section below.
The other issue is your Vector1::operator= is incorrect. It does not deallocate the memory allocated to _array previously, thus you have a memory leak.
The easiest way to fix this is to use the copy / swap you used in the operator=(Vector1 &&):
Vector1 & operator=(const Vector1 & rhs)
{
Vector1 temp(rhs);
std::swap(size_, temp.size_);
std::swap(array_, temp.array_);
return *this;
}