what is happened for constructors that accept objects as parameters ? - c++

Question

i want ask what is actually meaning by objects conversion , for example:
why i can't access print at class B using foo after assignment it to A ?!
#include <iostream>
using namespace std;
class A {};
class B {
public:
// conversion from A (constructor):
B (const A& x) {}
void print(){cout << "Huo Jackman!\n";}
};
int main ()
{
A foo;
B bar = foo; // calls constructor
foo.print();
return 0;
}

Answer 1

Use:
bar.print();
Please note that the original foo object is not changed when bar is created. foo has type class A, which doesn't contain a print method, and in C++ it's not possible to add methods on the fly.

Answer 2

Your code is an example of Type Conversion. By doing the following
B (const A& x) {}
You are constructing a new object of Type B from an object of Type A. Here the original object A remains unchanged. When you write
A foo;
B bar = foo; // calls constructor
You have first created foo which is an object of Type A. From this object you are now creating an object of Type B taking foo as an argument. It will construct bar but will leave foo unchanged. That is why you cannot invoke the print method on foo since the print method is defined only for bar and not foo.
Now as you asked what would you gain by doing this.
Consider the following code
void fun ( B& b )
{
// do something with object b
}
void main ()
{
A a;
fun ( a );
}
The function fun here is expecting an object of type B but it is being passed an object of Type A. Before generating compile error, the compiler will try to see if there is any way it can construct object of Type B from an object of Type A. If you had not defined any conversion, the compiler will generate compile error. But here since we can construct an object of type B taking A as an argument, the compiler will do that and the call will succeed. This type of mechanism does have some unintended consequences. Here you wanted to call the function fun with object of type B but the call succeeded even with object of type A since compiler does an implicit conversion from Type A to Type B using the constructor in B. To stop this kind of behavior, keyword 'explicit' can be used on the affected constructor.
explicit B (const A& x) {}
Consider the following code inside class B
B& operator= (const A& x) {return *this;}
This will not create any new object. However it will be used modify an object of type B using an object of type A. If on the other hand we want to construct an object of Type A from an object of Type B we will have to use a typecast operator ( conversion function) in class B:
operator A() { return A(); }
So the class B would look something like:
class B
{
public:
B ( const A& a ) {} // conversion from A using constructor
B& operator= ( const A& a ) { return *this;} // conversion from A using assignment
operator A() { return A(); } // conversion to A using typecast operator
};
int main ( int argc, char** argv )
{
A a;
B b= a; // Construct B from A using constructor ( 1st one above )
b = a; // copy a into b using assignment operator ( 2nd one above)
a = b; // construct A from B using typecast operator ( 3rd one above )
return 0;
}
Please refer to this and this for some additional information