using namespace std;
class Base
{
public:
    Base(int i):b(i) {cout<<"Base constructor. b="<<i<<endl;}
    ~Base(){cout<<"Base destructor. b="<<b<<endl;}
    int GetB(){return b;}
private:
    int b;
};

class Base11:virtual public Base
{
public:
    Base11(int i,int j):Base(i),b11(j)
    {
        cout<<"Base11 constructor."<<endl;
    }
    ~Base11(){cout<<"Base11 destructor."<<endl;}
    void Print()
    {
        cout<<"Data in Base11. b11="<<b11<<",b="<<GetB()<<endl;
    }
private:
    int b11;
};
class Base12:virtual public Base
{
public:
        Base12 (int i,int j):Base(i),b12(j)
    {
        cout<<"Base12 constructor.";
    }
        ~Base12(){cout<<"Base12 destructor."<<endl;}
        void Print()
        {
            cout<<"Data in Base12. b12="<<b12<<",b="<<GetB()<<endl;
        }
private:
    int b12;
};
class Base2:public  Base
{
public :
    Base2(int i,int j):Base(i),b2(j)
    {
        cout<<"Base2 constructor."<<endl;
    }
    ~Base2() {cout<<"Base2 destructor."<<endl;}
    void Print()
    {
        cout<<"Data in Base2. b2="<<b2<<",b="<<GetB()<<endl;
    }
private:
    int b2;
};
class Derived:public Base11,public Base12,public Base2
{
public:
    Derived(int i,int j,int k,int l,int m,int n,int x,int y):Base11(i,j),Base12(k,l),Base2(m,n),Base(x),d(y)
    {
        cout<<"Derived constructor."<<endl;
    }
    ~Derived(){cout<<"Derived destructor."<<endl;}
    int GetD(){return d;}
private:
    int d;
};

int main()
{
    Derived obj(1,2,3,4,5,6,7,8);
    obj.Base11::Print();
    obj.Base12::Print();
    obj.Base2::Print();
    cout<<"Data in itself. d="<<obj.GetD()<<endl;
    return 0;
}

这个程序是我教材里的一个例子，但是我编译时报错，出现了二义性，想了一下，的却是的，而书本却能给出了下面的输出结果，想问是怎么回事？
Base constructor. b=7
Base11 constructor.
Base12 constructor.
Base constructor. b=5
Base2 constructor.
Derived constructor.
Data in Base11. b11=2,b=7
Data in Base12. b12=4,b=7
Data in Base2. b2=6,b=5
Data in itself. d=8
...

不会啊，那里有二义性的，我试了下，完全正常运行啊

不会吧，我用的是vs2008和vs2010，都报错了ambiguous access of 'Base

类Derived从类Base11和Base12继承了成员GetB（），然后又从类Base2继承了GetB（），这不是二义性吗？

class Base2 : virtual public Base

我在dev c++下测试这个程序没问题，在vs2008下就出现你说的那情况
我个人是觉得因为你在Drived类有对Base类进行构造，所以在Base11,Base12,Base2中对Base类的构造将被忽略，所以应该没有问题的，按照rjsp所说，Base类一旦成为虚基类，其他类只能虚继承于他吗？我也不太清楚，等待大家的讨论，学习学习。
另外，类Derived从类Base11和Base12继承了成员GetB（），然后又从类Base2继承了GetB（），这不是二义性吗？ 楼主对二义性的理解有误，二义性不是这个意思，二义性是对调用来说的

可是它的原意不是这个啊，它题目解释说的Base2不是虚对象

对啊，对GetB()访问时不就会出现二义性吗？

如果非要写class Base2 : public Base要什么解决基类的二义？标准上是什么说的？
如果定义和调用Base默认构造函数，就不会出现二义，为什么？
我查了资料，没能查到……

貌似这个程序不存在二义性问题。
说说我的二义性的理解吧：二义性是指在一个多继承的类继承类中，包含了的基类有两个以上的基类成员中有相同的函数名和参数类型及个数。这样在主函数中，用继承类的对象来调用基类们共有的函数时，如果不用作用域分辨符时，就会因为编译系统不知道是那个基类的函数成员，而产生歧义，因此出现了二义性。
如：
#include<iostream>
using namespace std;
class A
{
public:
    A(int a);
    int geta();
private:
    int x;
};
A::A(int a)
{
    x=a;
}
int A::geta()
{
    return x;
}
class B
{
public:
    B(int b);
    int geta();
private:
    int x;
};
B::B(int b)
{
    x=b;
}
int B::geta()
{
    return x;
}
class C:public A,public B
{
public:
    C(int c,int d);
    int getC();
private:
    int y;
};
C::C(int c,int d):A(c),B(d)
{
    y=c;
}
int C::getC()
{
    return y;
}
int main()
{
    int a,b;
    a=8;
    b=3;
    C cc(a,b);
    cout<<cc.geta()<<"  "<<cc.geta()<<endl<<cc.getC()<<endl;//应该是: cout<<cc.geta()<<"  "<<cc.geta()<<endl<<cc.getC()<<endl;
    return 0;
}