请问一个关于动态联编的问题
请高手解释一下这段：

class A{

public :
virtual void Foo(int i=5){printf( "this is aa from a and %d\n ",i);}

virtual void f(double i){ printf( "this is a::f(double)\n ");}
};

class B: public A{
public:
virtual void Foo(int i=10){ printf( "this is aa form b and %d\n ",i*i);}

virtual void f(char i){ printf( "this is b::f(Complex)\n "); }
};


int main(){

A* pa=(A*)new B();
pa-> Foo();
pa-> f(2.0);


B b;
b.f(1.0);

return 0;
}


output:

this is aa form b and 25
this is a::f(double)
this is b::f(Complex)


当参数不同，具体是怎么调用的，请高手指点

[解决办法]
1。缺省参数编译的时候进行
2。滞后联编在执行的时候进行
这是理论原则
[解决办法]
A* pa=(A*)new B();
pa-> Foo();
所以先的i＝5已编译，虚函数机制，执行B：：Foo代码，所以25
[解决办法]
问什么 b.f(1.0)执行的 void f(char i){ printf( "this is b::f(Complex)\n "); }
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
指针引用才能的滞后联编
[解决办法]
虚拟函数的定义与声明
1。同名＋同参数表＋同返回值类型
2。参数表不能兼容derived
3。返回值类型可以兼容derived
4。默认参数，const修饰可以使用，但需一致书写，否则语法对语义上不鲁棒

const对虚拟函数：
（1）比如const用在Base，而Derived无const修饰时，这使Base的const对象才能使用此成员函数，而Derived的任何对象均可使用此virtual成员函数
（2）const使得使用静态类型，取消滞后联编

class B
{
public:
virtual void ok() const{cout < < "B::okokok " < < endl;}
};

class D:public B
{
public:
void ok() {cout < < "D::okokok " < < endl;}
};

int main()
{
// const B b;
// b.ok();
B *pb = new D;
pb -> ok(); //B::okokok
D *pd = new D;
pd -> ok(); //D::okokok
delete pb;
return 0;
}

默认参数对虚拟函数
（1）未破坏滞后联编
（2）默认参数是在编译的时候带入的

class B
{
public:
virtual void ok(int = 3) {cout < < "B::okokok " < < endl;}
};

class D:public B
{
public:
void ok(int i) {cout < < "D::okokok " < < endl; cout < < i < < endl;}
};

int main()
{
// const B b;
// b.ok();
B *pb = new D;
pb -> ok(); //D::okokok
D *pd = new D;
pd -> ok(3); //D::okokok
delete pb;
return 0;
}
学习写的文章，你看看