#include<iostream>
using namespace std;
class A{
public:
    A(int x){ a = x; }
    A(A &qq){ a = qq.a; }
    int getX(){
        return a;
    }
private:
    int a;
};
class B{
private:
    A xx;
public:
B(A C){ xx(C); }//这个地方到底有什么问题？
    int bbb(){ return xx.getX(); }//

};
int main()
{
    A d(12);
    cout << d.getX() << endl;
    return 0;

镶套类如何赋值？

好吧 都比了一下

这样写
#include<iostream>
using namespace std;
class A{
public:
    A(int x=0){ a = x; }
    AConstructor(A &qq){ a = qq.a; }//复制功能不再写成构造函数，弄成成员函数
    int getX(){
        return a;
    }
private:
    int a;
};
class B{
private:
    A xx;
public:
B(A C){ xx.AConstructor(C); }//这里调用成员就没有问题，如果调用构造的话
                             //xx在定义成员的时候就已经构造了一次，
                             //它会因重复调用构造函数报错
    int bbb(){ return xx.getX(); }//

};
int main()
{
    A d(12);
    cout << d.getX() << endl;
    return 0;
}

class A
{
public:
    explicit A( int x ) : val_(x)
    {
    }
    A( const A& a ) : val_(a.val_)
    {
    }
    int getvalue() const
    {
        return val_;
    }
private:
    int val_;
};

class B
{
public:
    explicit B( const A& a ) : a_(a)
    {
    }
    int getvalue() const
    {
        return a_.getvalue();
    }
private:
    A a_;
};

#include <iostream>
using namespace std;

int main( void )
{
    A a(12);
    cout << a.getvalue() << endl;
    return 0;
}

拽B啊