M
masood.iqbal
I have a few questions regarding overloaded typecast
operators and copy constructors that I would like an
answer for. Thanks in advance.
Masood
(1) In some examples that I have seen pertaining to
casting class A to class B, the implementation of the
overloaded typecast operator does something like this:
A:perator B(...)
{
B localCopy(...);
// perhaps some attributes of the "this" object
// are passed to the constructor
return localCopy;
}
Is this correct? Aren't we returning a local copy of
B?
(2) It appears that the following syntaxes are
equivalent:
[Here b is an instance of Class Y and Class Y has an
overloaded typecast operator for Class X]
(a) X c = (X)b; // Typecast style
(b) X c = X(b); // Function call style
Is this correct?
(3) I am surprised that the typecasting to self type is
allowed. If we have a class that supports both a copy
constructor with one argument and an overloaded
typecast operator to its own type (for whatever
reason), it appears that they will have identical
calling syntaxes.
Is this correct? If this is correct, how does the
compiler remove the ambiguity.
I have a small coding sample that illustrates my
doubts.
/////////////////////////////////////////////////////////////
#include <string.h>
#include <iostream.h>
class First
{
int value;
public:
First(int i = 0)
{
value = i;
}
operator int() // typecast to integer
{
return value;
}
};
class Second
{
int data;
char label[100];
public:
Second(int i = 0, char* str = "???")
{
data = i;
strcpy(label, str);
}
Second(const Second& obj) // Copy constructor
{
cout << "Copy constructor called\n";
data = obj.data;
strcpy(label, obj.label);
}
operator char*() // typecast to char*
{
return label;
}
operator First() // typecast to First
{
First f(data);
return f;
}
operator Second() // typecast to Self-type
{
cout << "Typecast operator to self called\n";
Second s(data, label);
return s;
}
};
int
main()
{
First first_a(56);
cout << "It is " << (int)first_a << endl;
Second second_b(98, "Howdy Doody");
First first_c = (First)second_b; // typecast style conversion
First first_d = First(second_b); // function call style conversion
cout << "ONE: It is " << (int)first_c
<< " and " << (char *)second_b << endl;
cout << "TWO: It is " << (int)first_d
<< " and " << (char *)second_b << endl;
Second second_e(second_b);
// What got called ---- the overloaded typecast
// self-type or the copy constructor?
return 0;
}
operators and copy constructors that I would like an
answer for. Thanks in advance.
Masood
(1) In some examples that I have seen pertaining to
casting class A to class B, the implementation of the
overloaded typecast operator does something like this:
A:perator B(...)
{
B localCopy(...);
// perhaps some attributes of the "this" object
// are passed to the constructor
return localCopy;
}
Is this correct? Aren't we returning a local copy of
B?
(2) It appears that the following syntaxes are
equivalent:
[Here b is an instance of Class Y and Class Y has an
overloaded typecast operator for Class X]
(a) X c = (X)b; // Typecast style
(b) X c = X(b); // Function call style
Is this correct?
(3) I am surprised that the typecasting to self type is
allowed. If we have a class that supports both a copy
constructor with one argument and an overloaded
typecast operator to its own type (for whatever
reason), it appears that they will have identical
calling syntaxes.
Is this correct? If this is correct, how does the
compiler remove the ambiguity.
I have a small coding sample that illustrates my
doubts.
/////////////////////////////////////////////////////////////
#include <string.h>
#include <iostream.h>
class First
{
int value;
public:
First(int i = 0)
{
value = i;
}
operator int() // typecast to integer
{
return value;
}
};
class Second
{
int data;
char label[100];
public:
Second(int i = 0, char* str = "???")
{
data = i;
strcpy(label, str);
}
Second(const Second& obj) // Copy constructor
{
cout << "Copy constructor called\n";
data = obj.data;
strcpy(label, obj.label);
}
operator char*() // typecast to char*
{
return label;
}
operator First() // typecast to First
{
First f(data);
return f;
}
operator Second() // typecast to Self-type
{
cout << "Typecast operator to self called\n";
Second s(data, label);
return s;
}
};
int
main()
{
First first_a(56);
cout << "It is " << (int)first_a << endl;
Second second_b(98, "Howdy Doody");
First first_c = (First)second_b; // typecast style conversion
First first_d = First(second_b); // function call style conversion
cout << "ONE: It is " << (int)first_c
<< " and " << (char *)second_b << endl;
cout << "TWO: It is " << (int)first_d
<< " and " << (char *)second_b << endl;
Second second_e(second_b);
// What got called ---- the overloaded typecast
// self-type or the copy constructor?
return 0;
}