从成员成语中复制/移动构造函数

Question

I'm using base-from-member idiom and I now stuck with copy/move constructors for them. Suppose following code:

#include <iostream>
#include <string>
#include <boost/lexical_cast.hpp>

using namespace std;

struct A // base class
{
    A(string &s) : s(s), c(0) { };
    A(const A &a) : s(a.s), c(a.c) { };
    void print() { cout << s << endl; c++; }
    int print_count() { return c; }

    string &s;
    int c;
};

struct B_base // this class will be initialized before A
{
    B_base(int i)
    {
        s = boost::lexical_cast<string>(i);
    }

    B_base(const B_base &other) : s(other.s) { };

    string s;
};

struct B : B_base, A // main class
{
    B(int i) : B_base(i), A(B_base::s) { }
    B(const B &other) : B_base(other), A(other) { } // <-- problem here 

    using A::print;
    using A::print_count;
};


int main()
{
    B b(10);
    b.print(); // prints '10'
    cout << b.print_count() << endl; // prints '1'


    B b1(b);
    b1.print(); // prints '10'

    A &a = b;
    a.s =  "FAIL"; // we modify b, not b1 here!

    b1.print(); // but b1 prints 'FAIL' here --- error (it should still print '10')
    cout << b.print_count() << " " << b1.print_count() << endl; // prints '1 3'

    return 0;
}

Problem here is that reference As (which is point to B_base::s ) is copied from one instance to another, while it should be modified to point to another B_base::s . Things may be even worse, if previous instance is go out of scope ending with dangling references.

My question is: how can I make correct copy of class with base-from-member idiom? (I think move constructor will be similar to copy one, right?)

Answer 1

The base-from-member idiom you are exercising in this case means: you want a class B derived from A with have to be initialized using a member of B (with is: string s ).

B b(10);
B b1(b); //   B(const B &other) : B_base(other), A(other) { }
         //   now A::s in b1 is a ref to b.s
A &a = b;//   and a.s is a ref to b.s too.
a.s =  "FAIL"; // we modify b, and A::s in b1 to!

This problem can be solved making the copy constructor:

B(const B &other) : B_base(other), A(B_base::s) { }

Also, having A::s and B_base::s with the same name, make thing more difficult to understand.

EDIT: As a class designer, you have to decide with is the exact meaning of your copy constructor.
For example, in this case you may want to keep track (with A::c ) of the number of printing of each newly create object A . The copy constructor I proposed do it.

But if you want to keep track of all printing of the original string thing are more complex. Just note that if you copy the old A::c to the new A it will be correct initialized, bur not cross actualized when the the printing of the same original string is made using different copies of A . If this is not a problem you can modify the constructors:

A(string &s, int _c=0) : s(s), c(_c) { };

...

B(const B &other) : B_base(other), A(B_base::s, other.c) { }