文章目录
- 一、多态
- 1.多态定义
- 2.多态分类
- 2.1编译时的多态
- 2.2运行时的多态
- 二、虚函数
- 1.定义
- 2.成员函数与虚函数
- 3.为什么构造函数(移动构造函数,拷贝构造函数)不可以定义为虚函数?
- 4.示例
- 5.对象和指针和引用调用
- 6.虚表分配
- 7.this指针调动示例
- 8.虚函数调用关系示例
一、多态
1.多态定义
多态性是面向对象程序设计的关键技术之一。若程序设计语言不支持多态性,不能称为面向对象的语言。利用多态性技术,可以调用同一个函数名的函数,实现完全不同的功能。
2.多态分类
2.1编译时的多态
(早期绑定)名字粉碎技术实现
通过函数的重载和运算符的重载来实现的
示例:
int Max(int a, int b)
{
return a > b ? a : b;
}
char Max(char a, char b)
{
return a > b ? a : b;
}
int main()
{
int x = Max(12, 23);
char ch = Max('c', 'b');
double dx = Max(12.23, 34.45);
return 0;
}
2.2运行时的多态
(晚期绑定)虚函数
运行时的多态性是指在程序执行前,无法根据函数名和参数来确定该调用哪一个函数,必须在程序执行过程中,根据执行的具体情况来动态地确定。它是通过类继承关系public和虚函数来实现的。目的也是建立一种通用的程序。通用性是程序追求的主要目标之一。
① 公有继承
② 必须有virtual关键字
③ 引用或者指针返回
示例:
#include<iostream>
#include<list>
#include<type_traits>
#include<initializer_list>
#include<string>
using namespace std;
class Animal
{
private:
string name;
public:
Animal(const string& na) :name(na) {}
public:
virtual void eat() {}
virtual void walk() {}
virtual void tail() {}
virtual void PrintInfo() {}
string& get_name() { return name; }
const string& get_name() const { return name; }
};
class Dog :public Animal
{
private:
string owner;
public:
Dog(const string& ow, const string na) :Animal(na), owner(ow) {}
virtual void eat()
{
cout << "Dog Eat:bone" << endl;
}
virtual void walk()
{
cout << "Dog Walk:run" << endl;
}
virtual void tail()
{
cout << "Dog Tail:wang wang" << endl;
}
virtual void PrintInfo()
{
cout << "Dog owner: " << owner << endl;
cout << "Dog name: " << get_name() << endl;
}
};
class Cat :public Animal
{
private:
string owner;
public:
Cat(const string& ow, const string na) :Animal(na), owner(ow) {}
virtual void eat()
{
cout << "Dog Eat:fish" << endl;
}
virtual void walk()
{
cout << "Dog Walk:silent" << endl;
}
virtual void tail()
{
cout << "Dog Tail:miao miao" << endl;
}
virtual void PrintInfo()
{
cout << "Dog owner: " << owner << endl;
cout << "Dog name: " << get_name() << endl;
}
};
void fun(Animal& animal)
{
animal.eat();
animal.walk();
animal.tail();
animal.PrintInfo();
}
int main()
{
Dog dog("yhping", "hashiqi");
Cat cat("hm", "Persian");
fun(dog);
fun(cat);
return 0;
}
二、虚函数
1.定义
虚函数是一个类的成员函数:
virtual 返回类型 函数名 (参数表)
关键字virtual 指明该成员函数为虚函数。virtual 仅用于类定义中,如虚函数在类外定义,可不加virtual。
当一个类的成员函数被定义为虚函数,则由该类派生出来的所有派生类中,该函数始终保持虚函数的特性。
2.成员函数与虚函数
成员函数应尽可能地设置为虚函数,但必须注意以下几条:
(1)派生类中定义虚函数必须与基类中的虚函数同名外,还必须同参数表,同返回类型。否则被认为是重载,而不是虚函数。
class Object
{
public:
virtual void fun(){}
};
class Base :public Object
{
public:
virtual void fun(int x) {}
};
如基类中返回基类指针,派生类中返回派生类指针是允许的,这是一个例外。
class Object
{
public:
virtual Object* fun() {}
};
class Base :public Object
{
public:
virtual Base* fun(int x) {}
};
(2)只有类的成员函数才能说明为虚函数。这是因为虚函数仅适用于有继承关系的类对象
(3)静态成员函数,是所有同一类对象共有,不受限于某个对象,不能作为虚函数。
(4)实现动态多态性时,必须使用基类类型的指针变量或引用,使该指针指向该基类的不同派生类的对象,并通过该指针指向虚函数,才能实现动态的多态性。
(5)内联函数每个对象一个拷贝,无映射关系,不能作为虚函数。
(6)析构函数可定义为虚函数,构造函数不能定义虚函数,因为在调用构造函数时对象还没有完成实例化。在基类中及其派生类中都动态分配的内存空间时,必须把析构函数定义为虚函数,实现撤消对象时的多态性。
(7)函数执行速度要稍慢一些。为了实现多态性,每一个派生类中均要保存相应虚函数的入口地址表,函数的调用机制也是间接实现。所以多态性总是要付出一定代价,但通用性是一个更高的目标。
(8)如果定义放在类外itual 只能加在函数声明前面,不能(再)加在函数定义前面。正确的定义必须不包括virtual。
3.为什么构造函数(移动构造函数,拷贝构造函数)不可以定义为虚函数?
因为在构建虚表之前要先查询构造函数,如果构造函数未定义,那么虚函数就不可以继续。
4.示例
#include<iostream>
#include<list>
#include<type_traits>
#include<initializer_list>
#include<string>
using namespace std;
class Object
{
private:
int value;
public:
Object(int x = 0) :value(x) {}
virtual void add()
{
cout << "Object::add" << endl;
}
virtual void fun()
{
cout << "Obect::fun" << endl;
}
virtual void print() const
{
cout << "Object::print" << endl;
}
};
class Base :public Object
{
private:
int sum;
public:
Base(int x = 0) :Object(x + 10),sum(x)
{
}
virtual void add()
{
cout << "Base::add" << endl;
}
virtual void fun()
{
cout << "Base::fun" << endl;
}
virtual void print() const
{
cout << "Base::print" << endl;
}
};
int main()
{
Base base(10);
Object* op = &base;
return 0;
}
5.对象和指针和引用调用
class Object
{
private:
int value;
public:
Object(int x = 0) :value(x) {}
virtual void add()
{
cout << "Object::add" << endl;
}
virtual void fun()
{
cout << "Obect::fun" << endl;
}
virtual void print() const
{
cout << "Object::print" << endl;
}
};
class Base :public Object
{
private:
int sum;
public:
Base(int x = 0) :Object(x + 10),sum(x)
{
}
virtual void add()
{
cout << "Base::add" << endl;
}
virtual void fun()
{
cout << "Base::fun" << endl;
}
virtual void print() const
{
cout << "Base::print" << endl;
}
};
int main()
{
Base base(10);
Object* op = &base;
Object obj(0);
//如果用指针或者引用调动虚方法,采取动态编联的方法(在运行时候确定调用关系)
op = &base;
op->add();
op->fun();
op->print();
//如果用对象调动虚方法,采取静态编联的方法(编译时期确定对象和方法进行结合)
obj = base;
obj.add();
obj.fun();
obj.print();
return 0;
}
6.虚表分配
编译时期加载虚表
#include<iostream>
#include<list>
#include<type_traits>
#include<initializer_list>
#include<string>
using namespace std;
class Object
{
private:
int value;
public:
Object(int x = 0) :value(x) {}
virtual void add()
{
cout << "Object::add" << endl;
}
virtual void fun()
{
cout << "Obect::fun" << endl;
}
virtual void print() const
{
cout << "Object::print" << endl;
}
};
class Base :public Object
{
private:
int sum;
public:
Base(int x = 0) :Object(x + 10),sum(x) {}
virtual void add()
{
cout << "Base::add" << endl;
}
virtual void fun()
{
cout << "Base::fun" << endl;
}
virtual void print() const
{
cout << "Base::show" << endl;
}
};
class Test :public Base
{
private:
int num;
public:
Test(int x=0) :Base(x+10) {}
virtual void add()
{
cout << "Tset::add" << endl;
}
virtual void print() const
{
cout << "Test::print" << endl;
}
virtual void show()
{
cout << "Test::show" << endl;
}
};
7.this指针调动示例
class Object
{
private:
int value;
public:
Object(int x = 0) :value(x) {}
virtual void add()
{
cout << "Object::add" << endl;
}
virtual void fun()
{
cout << "Obect::fun" << endl;
}
virtual void print() const
{
cout << "Object::print" << endl;
}
void fn_a()
{
fun();//系统默认为this指针调动
}
};
class Base :public Object
{
private:
int sum;
public:
Base(int x = 0) :Object(x + 10),sum(x) {}
virtual void add()
{
cout << "Base::add" << endl;
}
virtual void fun()
{
cout << "Base::fun" << endl;
}
virtual void print() const
{
cout << "Base::show" << endl;
}
};
class Test :public Base
{
private:
int num;
public:
Test(int x=0) :Base(x+10) {}
virtual void add()
{
cout << "Tset::add" << endl;
}
virtual void print() const
{
cout << "Test::print" << endl;
}
virtual void show()
{
cout << "Test::show" << endl;
}
};
int main()
{
Test t1;
Base base;
Object obj;
t1.fn_a();
base.fn_a();
obj.fn_a();
return 0;
}
8.虚函数调用关系示例
const float pi = 3.14;
typedef struct _Ops
{
float (*area)(void*);
}Ops;
typedef struct _Shape
{
Ops ops;
}Shape;
typedef struct _Square
{
Shape shape;
float length;
}Square;
typedef struct _Circle
{
Shape shape;
float radius;
}Circle;
float square_area(void* thiz)
{
if (thiz == NULL) return -1;
printf("Square area: \n");
Square* sp = (Square*)thiz;
float area = sp->length * sp->length;
return area;
}
float circle_area(void* thiz)
{
if (thiz == NULL) return -1;
printf("Circle area: \n");
Circle* sp = (Circle*)thiz;
float area = sp->radius * sp->radius * pi;
return area;
}
int main()
{
Square square;
memset(&square, 0, sizeof(Square));
square.length = 10;
square.shape.ops.area = square_area;
Circle circle;
memset(&circle, 0, sizeof(Circle));
circle.radius = 10;
circle.shape.ops.area = circle_area;
Shape* shape = NULL;
shape = (Shape*)□
cout << shape->ops.area(&square) << endl;
shape = (Shape*)&circle;
cout << shape->ops.area(&circle) << endl;
return 0;
}
运行结果: