麻烦C++大神来分析一下两道题。。

#include
class one
{
public:
virtual void f(){cout<<"1";} //虚拟函数
};
class two:public one
{
public: //没有重载f(),所以f()被继承。
two(){cout<<"2";}
};
class three:public two
{
public:
virtual void f(){two::f();cout<<"3"; } //重载了虚拟函数，two::f()被隐藏
};
int main()
{
one aa,*p; //注意p是基类的指针
two bb; //two:two()被调用，输出“2”
three cc; //three::three()被调用，同时会在调用基类的构造函数two:two(),输出“2”
p=&cc; //多态调用，实际成了指向子类的指针。
p->f(); //调用了three::f(), 而two::f()就是one::f(),输出“1”，再输出“3”
return 0;
}

#include
using namespace std;
class A{
public:
virtual void funcl(){cout<<"A1";} //注意是 funcl
void func2(){cout<<"A2";}
};
class B: public A{
public:
void func1(){cout<<"B1";} //是 func1，所以还存在B:funcl()
void func2(){cout<<"B2";}
};
int main(){
A *p=new B; //p是实际指向B类的指针
p->funcl(); //没有被重载
p->func2();
return 0;
}

这个题目完全是坑爹的，没什么意义。

第一题

int main(){
      one aa,*p;  // aa调用one的构造器，不会有输出；p是指针，不会调用one构造器
      two bb;     // bb调用two的构造器，打印出“2”
      three cc;   // cc调用three的构造器，其中自动调用父类two的构造器，打印出“2”
      p=&cc;      
      p->f();     // f是虚函数，会实现多态，所以实际调用的是three::f()。
                  // 其中先显式地调用two::f()，而two::f()继承于one类，会打印出“1”
                  // 然后，three::f()打印出“3”
      return 0;
}
// 最终打印出“2213”

第二题

int main(){
      A *p=new B;
      p->funcl();  // 不知道是不是你笔误，这里是funcl不是func1，所以打印“A1”
      p->func2();  // 非虚函数，不会实现多态，调用A::func2()，打印出“A2”
      return 0;
}
// 最终打印出“A1A2”

3)one aa,*p; //调用 one构造函数 one() 默认无操作
two bb;//调用调用 one构造函数无操作 two构造函数 two() 输出 2
three cc;//调用调用 one构造函数无操作 two构造函数 输出 2 调用 three构造函数无操作
p=&cc;
p->f();//编译阶段查找three中是否存在f()，存在着绑定three::f() 并调用
virtual void f(){
two::f();();//编译阶段查找two中是否存在f()，不存在则查找one 存在着绑定one::f() 并调用
cout<<"3";
}
4)
p->funcl();//同3，并且也这有A类有这函数，可能是打错字符，没错的话是调用B的
p->func2();//非动态绑定，调用A的

虚函数和动态联编的知识，自己去看下书

1) 2213
2) A1A2