文章概述
1.重载,重写,重定义;
2.多态的原理;
3.证明vptr指针的存在;
4.构造函数中调用虚函数,能实现多态吗?
5.父类指针步长是否和子类指针步长一样?
重载,重写,重定义
a. 重载:(1)必须在同一个类中进行;(2)子类无法重载父类的函数,父类的同名函数会被子类的相同函数名所覆盖。
class A
{
public:
int a;
public:
A()
{
a = 5;
cout << "A" << endl;
}
void printF()
{
cout << a << "A" << endl;
}
virtual ~A()
{
cout << "~A" << endl;
}
};
class B:public A
{
public:
int b;
public:
B()
{
b = 10;
cout << "B" << endl;
}
void printF()
{
cout << b << "B" << endl;
}
//这种方式也会覆盖父类的同名函数
//int printF()
//{
// cout << b << "B" << endl;
// return 0;
//}
~B()
{
cout << "~B" << endl;
}
};
int main()
{
B b;
b.printF();
return 0;
}
(3)函数重载是在编译期间根据函数的类型和个数决定函数调用。
b. 函数重写: (1)必须发生在父类和子类之间;(2)父类和子类的函数必须具有相同的函数原型(函数返回值,参数,函数名);(3)如果父类的同名函数用virtual声明,则会产生多态;不使用virtual声明,则叫重定义。多态则是在程序的运行期间根据对象的实际类型调用函数。
多态的原理
a. 当类的成员用virtual修饰时(包括继承中的virtual public A),C++编译器会提前布局,在成员变量中添加一个vptr指针。(创建对象的时候初始化vptr指针,和虚函数表联系)
b. 在产生vptr指针的同时,也会在类中产生一个虚函数表(存储虚函数指针的数据结构),虚函数表示由编译器自动生成和维护的。virtual成员函数会被C++编译器放入虚函数表中。(即存在虚函数时,每个对象都有一个指向虚函数的指针——>vptr指针)。
c. 实例分析:
C c; //子类创建对象
P*p =&c;
p->print();
当执行到p->print()时,C++编译器不需要区分print()函数时父类还是子类。只会确定prinrt()是否是虚函数:
a.不是,C++编译器直接会确定被调用的成员函数(静态编译,编译的时候根据P确定类型);
b. 是, 编译器会根据对象p的vptr指针,所指的虚函数表中查找print()函数,调用。(查找和调用在程序运行的时候进行的,实现动态编译)
注意: 没有必要将所有的成员函数设为虚函数?
通过虚函数表和vptr调用重写函数是在程序运行的时候进行的,需要通过寻址操作才能确定真正应该要调用的函数。但是普通函数在程序编译的时候就已经确定了要调用的函数,因此虚函数在效率要慢与普通的函数。从效率考虑,没有必要将所有的成员函数设为虚函数。
证明vptr指针的存在
class A
{
int x;
public:
void Print()
{
}
};
class B
{
int y;
public:
virtual void Print() //会在成员变量中添加一个vptr指针
{
}
};
int main()
{
cout << "A-------->" << sizeof(A) << endl; //4
cout << "B-------->" << sizeof(B) << endl; //8
}
构造函数中调用虚函数,能实现多态吗
上面这句话是定义一个子类对象,在这个过程中父类的构造函数中调用虚函数,能实现多态吗?
class A
{
int x;
public:
A()
{
x = 10;
//cout << "A" << endl;
Print(); //父类的构造函数中调用虚函数,不会产生多态
}
virtual void Print()
{
cout << "A" << endl;
}
};
class B:public A
{
int y;
public:
B()
{
y = 10;
//cout << "B" << endl;
}
virtual void Print() //会在成员变量中添加一个vptr指针
{
cout << "B" << endl;
}
};
int main()
{
B b;
return 0;
}
为了说明子类的vptr指针的初始化时分步的。
父类指针步长是否和子类指针步长一样
a. 步长:根据类普通成员变量的个数计算的,因为类中,只有普通成员变量存储在对象中;
b. 指针的步长是根据定义指针的类型决定的。
class A
{
private:
int a;
public:
A()
{
this->a = 1;
}
virtual void print()
{
cout << "A" << endl;
}
};
class B:public A
{
private:
int b;
public:
B(int b)
{
//this->b = b;
}
virtual void print()
{
cout << "B" <<" "/*<<b*/<< endl;
}
int getB()
{
return 0;
}
};
int main()
{
A* a = NULL;
B* b = NULL;
B arr[3] = { B(1),B(2),B(3) };
a = arr; //发生多态
a->print();
b = arr;
b->print();//正常输出
//----
cout << "指针移动" << endl;
b++;
b->print();
//----错误的,子类的步长有可能有父类的步长不同
cout << "父类指针移动" << endl;
a++;
a->print();
return 0;
}
结论: a.子类步长不同于父类的步长;
b. 不要将父类指针a++与子类的对象数组混用。