How to change pointer? copy constructor - c++

Question

I want to make "set" function. This function changes the values of a2 from "set(int x, int y)" to "y"
#include <iostream>
using namespace std;
class IntArray {
private:
int* m_data;
int m_len;
public:
IntArray(int = 0, int = 0);
~IntArray();
void print(void);
IntArray(const IntArray& copy); // copy Constructor
void set(int x , int y) {
int temp = x;
x = y;
y = temp;//!!
}
};
IntArray::IntArray(int size, int init) {
if (size <= 0) {
m_data = nullptr; m_len = 0;
}
else {
m_data = new int[size];
m_len = size;
for (int idx = 0; idx < m_len; ++idx)
*(m_data + idx) = init;
}
}
IntArray::~IntArray() {
delete[]m_data;
}
void IntArray::print(void) {
for (int idx = 0; idx < m_len; ++idx)
cout << *(m_data + idx) << ' ';
cout << std::endl;
}
int main() {
cout << "a1: ";
IntArray a1{ 10, 100 };
a1.print();
cout << "a2: ";
IntArray a2{ a1 };// 10~100
a2.set(3, 999);
a2.set(9, 123);
a2.print();
return 0;
}
Excepted
a1: 100 100 100 100 100 100 100 100 100 100
a2: 100 100 100 999 100 100 100 100 100 123

Answer 1

Here's what you need.
let's fix up your declaration and introduce two new helper methods, alloc and copyFromOther.
class IntArray {
private:
int* m_data;
int m_len;
void alloc(int len);
void copyFromOther(const IntArray& copy);
public:
IntArray();
IntArray(const IntArray& copy);
~IntArray();
IntArray& operator=(const IntArray& copy);
void print();
void set(int index, int value);
};
Then the helper methods are for quick allocations and copy. Notice that I didn't special case length == 0. That's because it's perfectly fine to say, new int[0]. It will allocate a pointer of zero length. You can change this if you want to force a null pointer when length is zero. Also be aware that copy constructors need to be able to handle "copying to yourself". That is, if you say:
IntArray arr(10, 20);
arr.set(5,5);
arr = arr;
As weird as the above looks, it's the source of a lot of bugs when a copy constructor doesn't handle that case. That's covered below.
So now the implementation
void IntArray::alloc(int len) {
delete [] m_data; // erase what we had before
m_data = new int[len]; // you could say m_data = len ? new int[len] : nullptr
m_len = len;
}
void IntArray::copyFromOther(const IntArray& copy) {
// special case - allow for "copying to ourselves" by doing nothing
// if we didn't handle this, the alloc function would delete the pointer
if (copy.m_data == m_data) {
return;
}
alloc(copy.m_len);
for (int idx = 0; idx < m_len; ++idx)
m_data[idx] = copy.m_data[idx];
}
}
Then the implementation
IntArray::IntArray() : m_data(nullptr) {
alloc(0);
}
IntArray::IntArray(const IntArray& copy) m_data(nullptr), m_len(0) {
copyFromOther(copy);
}
IntArray& IntArray::operator=(const IntArray& copy) {
copyFromOther(copy);
return *this;
}
And let's fix your set method as you had asked about it in a separate question:
void IntArray::set(int index, int value) {
if ((index >= 0) && (index < m_len)) {
m_data[index] = value;
}
}
Your destructor and print methods are fine as you have them. print doesn't need to have an explicit void parameter.