Copying similar classes in C++

Question

I have two classes with similar structure.

class A{
    int a;
    char *b;
    float c;
    A(char *str) { //allocate mem and assign to b }
};

class B{
    int a;
    char *b;
    float c;
    B(char *str) { //allocate mem and assign to b }
    B(B & bref) { //properly copies all the data }
};

I want to copy an object of B to the object of A. Are the following conversions fine?

A aobj("aobjstr");
B bobj("bobjstr");
bobj = aobj;    //case 1
bobj = B(aobj); //case 2

Will the case 2 work? Will aobj be properly converted and interpreted as B & when B's copy constructor gets called?

EDIT: What about?

B bobj(aobj)

Answer 1

No, you can't implicitly convert between unrelated types without writing conversion constructors or conversion operators. Presumably, your compiler told you this; mine gave errors such as:

error: no match for ‘operator=’ in ‘bobj = aobj’
note:  no known conversion for argument 1 from ‘A’ to ‘const B&’
error: no matching function for call to ‘B::B(A&)’

You could allow the conversion by giving B a conversion constructor:

class B {
    // ...
    B(A const & a) { /* properly copy the data */ }
};

If you can't change the classes, then you'll need a non-member function to do the conversion; but this is probably only possible if the class members are public. In your example, all the members, including the constructors, are private, so the classes can't be used at all. Presumably, that's not the case in your real code.

If you want to live dangerously, you might be able to get away with explicitly reinterpreting an A object as a B, since they are both standard-layout types with the same data members:

// DANGER: this will break if the layout of either class changes
bobj = reinterpret_cast<B const &>(a);

Note that, since your class allocates memory, it presumably needs to deallocate it in its destructor; and to avoid double deletions, you'll also have to correctly implement both a copy constructor and a copy-assignment operator per the Rule of Three.

If that all sounds like too much work, why not use std::string, which takes care of memory management for you?

Answer 2

If you tried to compile it you would find that none of this works. For one thing your constructors are private.

bobj = aobj;    //case 1

This tries to call an assignment operator with the signature:

B& B::operator =(A const&)

This does not exist and compilation will fail.

bobj = B(aobj); //case 2

This tries to call A::operator B(), which does not exist and compilation will fail.

Finally:

B bobj(aobj)

This tries to call a constructor with the signature B::B(A const&), which does not exist and compilation will fail.

You say,

I can't change/modify class A and B, those are generated.

Then either the generator needs to be fixed or you're going to have to write your own adaptors.

Answer 3

You can do this by considering the following notes:

1) char* b makes a problem. When you copy aobj to bobj, the value of pointer aobj.b will be copied to bobj.b which means that they both refer to a same memory location and changing one like this: aobj.b[0] = 'Z' will cause bobj.b to change.

You can solve this by changing b from a pointer to a flat array:

//...
char b[MAXLEN];
//...

The better solution to this is to define a constructor (accepting the other type) and overload the assignment (=) operator, at least for class B, and handle the pointer assignment (allocate buffer for the new pointer and copy content to it).

2) UPDATED: A sample syntax is like this:

   bobj = B(reinterpret_cast<B&> (aobj));

   // or simply:
   bobj = reinterpret_cast<B&> (aobj);

3) Note that this is dangerous, not safe, and not recommended. This means that the design of your solution should probably change. For example, A and B may both inherit from a common base class; B inherits from A; or B explicitly defines a constructor and an assignment operator for class A. These are far more recommended.