Why is the copy assignment method not been called? - c++

Question

Am wondering why the copy assignment operator is not been called and yet the assignment seems to happen? This is my code:
#include <cstring>
#include <iostream>
class String{
public:
String(){ std::cout << "Empty Ctor" << '\n'; }
String(const char* s):data{(char*)s}{ std::cout << "Args Ctor"; }
Strin& operator=(const String&);
char* showData(){ return *data; }
private:
char* data;
};
String& String::operator=(const String& s){
std::cout << "Copy Assignment" << '\n'; // <- This is NEVER printed
delete [] data;
data = new char[strlen(s.data)+1];
strcpy(data, s.data);
return *this;
}
int main(){
String* s1 = new String("Hello");
String* s2 = new String("World");
s2 = s1; // This should call the overloaded copy assignment operator!?
std::cout << s2->showData() << '\n'; // prints "Hello"
return 0;
}
The cout in the assignment operator is not been printed
Updating my code - based on earlier suggestions. This works as expected
#include <cstring>
#include <iostream>
class String{
public:
String():data{nullptr}{ std::cout << "Empty ctor" <<'\n' ;}
String(const char* s)
{
std::cout<< "Const Args ctor" <<'\n' ;
data = new char[strlen(s)+1];
strcpy(data, (char *)s);
}
String(const String& other){
std::cout << "Copy Ctor" << '\n';
*this = other;
}
String& operator=(const String& s){
std::cout << "Assignment" << '\n';
if (&s != this){
delete [] data;
data = new char[strlen(s.data)+1];
strcpy(data, s.data);
}
return *this;
}
~String(){
std::cout << "Dtor" << '\n';
delete [] data;
}
char* showData(){ return data; }
private:
char* data;
};
int main()
{
std::cout << "Main" << '\n';
String a("A: Hello");
std::cout << a.showData() <<'\n';
String b("B: World");
std::cout << b.showData() <<'\n';
b = a;
std::cout << b.showData() <<'\n';
return 0;
}

Answer 1

s2 = s1; is just assignment between pointers, it won't call the copy assignment operator, just makes s2 pointing to the same object pointed by s1.
You might want to try with *s2 = *s1;, which uses the copy assignment operator of String. But you don't need the raw pointer indeed, you can just
String s1("Hello");
String s2("World");
s2 = s1; // This would call the overloaded copy assignment operator
std::cout << s2.showData() << '\n'; // prints "Hello"

Answer 2

"s2 = s1; // This should call the overloaded copy assignment operator!?"
No. It should not.
You are just assigning the value of one pointer variable to another. No copy assignment of your objects the pointers point to is happening.
This would do as you expect:
String s1("Hello");
String s2("World");
s1 = s2;
As would
*s1 = *s2;
in your original code.

Answer 3

Ok, lets start with this, pointer is not a string, it is a pointer (that points to a string).
So this:
String* s1 = new String ("BLE");
is creating a string somewhere in memory, and the point that will point to it. So a representation of it is:
+--------+
s -> | 0x005 |----+
+--------+ \
\
\
\
\
+---+---+---+---+---+---+---+
| | | | | B | L | E |
+---+---+---+---+---+---+---+
0x 1 2 3 4 5 6 7
This:
String* s2;
s2 = s1;
makes s2 pointing to same address (holding the same value at assign location for the pointer):
+--------+
s1-> | 0x005 |+
+--------+ \
\
+--------+ \
s2-> | 0x005 |----+
+--------+ \
\
\
+---+---+---+---+---+---+---+
| | | | | B | L | E |
+---+---+---+---+---+---+---+
0x 1 2 3 4 5 6 7
Operator = in String is for type String not for the pointer, so if you have something like this:
String s1 = "BLA";
String s2 = s1;
This creates brand new object and copies data over to that new object.
I suggest you read Programming Principles and Practice Using C++ chapter 18.5.
I also believe you have a lot of errors in your code. You cannot do what you are doing.
Here is sample of your code which actually uses copy assignment:
#include <cstring>
#include <iostream>
class String{
public:
String() : data {new char[1]} { std::cout << "Empty Ctor\n" << '\n'; }
String(const char* s):data{new char[strlen(s)]}{ strcpy (data, s); std::cout << "Args Ctor\n"; }
String& operator=(const String&);
char* showData(){ return data; }
private:
char* data;
};
String& String::operator=(const String& s){
std::cout << "Copy Assignment" << '\n'; // <- This is NEVER printed
delete[] data;
data = new char[strlen(s.data)+1];
strcpy(data, s.data);
return *this;
}
int main(){
String s1 ("Hello");
String s2 ("World");
s2 = s1; // This should call the overloaded copy assignment operator!?
std::cout << s2.showData() << '\n'; // prints "Hello"
return 0;
}
or as other suggested:
#include <cstring>
#include <iostream>
class String{
public:
String() : data {new char[1]} { std::cout << "Empty Ctor\n" << '\n'; }
String(const char* s):data{new char[strlen(s)]}{ strcpy (data, s); std::cout << "Args Ctor\n"; }
String& operator=(const String&);
char* showData(){ return data; }
private:
char* data;
};
String& String::operator=(const String& s){
std::cout << "Copy Assignment" << '\n'; // <- This is NEVER printed
delete[] data;
data = new char[strlen(s.data)+1];
strcpy(data, s.data);
return *this;
}
int main(){
String* s1 = new String("Hello");
String* s2 = new String("World");
*s2 = *s1; // This should call the overloaded copy assignment operator!?
std::cout << s2->showData() << '\n'; // prints "Hello"
return 0;
}
This is reason why you should learn C and pointers before you start messing around with pointers in C++.

Answer 4

Because you are assigning a pointer to another pointer. Do this:
*s2 = *s1;