Checking to see if a char pointer is null - Copy Constructor - c++

Question

I am working on the following code
class base
{
private:
char* mycharpointer;
std::string mystring;
public:
base() : mycharpointer(NULL) {/*default constructor*/}
//Copy Constructor
base(const base& rhs){
if(mycharpointer != NULL) ---> Why is this condition true ?
{
mycharpointer = new char[ strlen(rhs.mycharpointer + 1)];
strcpy(this->mycharpointer,rhs.mycharpointer);
}
mystring = rhs.mystring;
}
base operator=(base& b)
{
if(this == &b)
return *this;
base temp(b);
temp.swap(*this);
return *this;
}
//Swap operation
void swap(base& lhs) {
std::swap(lhs.mycharpointer,this->mycharpointer);
std::swap(lhs.mystring,this->mystring);
}
//Destructor
virtual ~base(){
if(mycharpointer)
delete[] mycharpointer;
}
};
class der : public base
{
public:
char* mycharpointer_der;
std::string mystring_der;
foo* f;
public:
der():mycharpointer_der(NULL)
{
}
der(const der& rhs) : base(rhs)
{
if(mycharpointer_der)
{
mycharpointer_der = new char[ strlen(rhs.mycharpointer_der + 1)];
strcpy(this->mycharpointer_der,rhs.mycharpointer_der);
}
mystring_der = rhs.mystring_der;
f = new foo(*rhs.f);
}
der& operator=(der& d)
{
if(this == &d) //Make sure its not the same class
return *this;
base::operator= (d);
der temp(d);
temp.swap(*this);
return *this;
}
//Swap operation
void swap(der& lhs) {
std::swap(lhs.mycharpointer_der,this->mycharpointer_der);
std::swap(lhs.mystring_der,this->mystring_der);
}
virtual ~der(){
if(mycharpointer_der) //Necessary check as to make sure you are not deleting a NULL address otherwise exception thrown.
delete[] mycharpointer_der;
}
};
int main()
{
der d;
d.mycharpointer_der = "Hello World";
d.mystring_der = "Hello String";
der b;
b = d;
}
Now in the above code the copy assignment operator of d is called. which in return calls the copy assignment operator of the base class. In the copy assignment operator of the base class the copy constructor of the base class is called. My question is why is the condition
if(mycharpointer != NULL)
in the base class turning out as true ? Even when I have explicitly assigned it a NULL in the initialization list of the base class.

Answer 1

That check is ridiculous. At the point of construction, when we get into the body, mycharpointer is default-initialized and will contain some garbage value which may be 0 but likely won't be.
That said, what happens if rhs.mycharpointer is NULL? Then the strlen call would fail. That's the charpointer whose value you need to be checking:
base(const base& rhs)
{
if (rhs.mycharpointer) {
mycharpointer = new char[ strlen(rhs.mycharpointer) + 1 ];
// outside the parens ^^^^
strcpy(this->mycharpointer,rhs.mycharpointer);
}
else {
mycharpointer = NULL;
}
mystring = rhs.mystring;
}
Or since you're already using string, we could keep using string for mycharpointer too. That has the added benefit of us not even having to write the copy constructor which, as you can see, can be error prone:
base(const base& ) = default;

Answer 2

C++ compiler only make sure the global variable and static variables will be initialized, so In this case, the mycharpointer may actually points to some useless garbage(dangling pointer)
base(const base& rhs){
if(mycharpointer != NULL) ---> Why is this condition true ?
{
mycharpointer = new char[ strlen(rhs.mycharpointer + 1)];
strcpy(this->mycharpointer,rhs.mycharpointer);
}
mystring = rhs.mystring;
}
as mycharpointer actually point to the data allocated on the heap, so if you want to rellocate it, you need to release existing data first.
something like:
if ( mycharpointer) {
delete [] mycharpointer;
}

Answer 3

Apparently you're expecting the default constructor to run before the copy constructor does.
But it won't.