有了虚函数，为什么还要纯虚函数，什么情况下使用纯虚函数？什么是抽象类什么是纯虚函数纯虚函数跟一般的虚函数有什么区别

本文目录

• 有了虚函数，为什么还要纯虚函数，什么情况下使用纯虚函数
• 什么是抽象类什么是纯虚函数纯虚函数跟一般的虚函数有什么区别
• 纯虚函数的定义
• 什么是纯虚函数
• 虚函数 纯虚函数是一个东西吗
• 关于纯虚函数
• C++中纯虚函数有什么作用
• 5.请回答: 在c++中什么是虚函数什么是纯虚函数

有了虚函数，为什么还要纯虚函数，什么情况下使用纯虚函数

给一个不太准确但通俗易懂的解释。这东西用的不多，假如创建一个纯虚函数，就是抽象类，所有其他人想继承这个类，都必须严格按照这个类的规定进行重写，这在多人开发的时候可以保证一定的格式，代码更清晰，便于管理。我觉得，一个抽象类，什么都没定义，他连一个实际对象都没有，这东西根本没什么其他意义。纯虚函数就是什么都没有，比如一个类“龙”，放在世界范围讲，这是一个很抽象的概念，中国的龙和国外的不同，能干什么也不同，就可以定义为纯虚，但放在中国范围讲，起码鹿角蛇神鱼鳞等，能行云部雨这些基本概念还在，能衍生出更多有特定属性的龙种。

什么是抽象类什么是纯虚函数纯虚函数跟一般的虚函数有什么区别

纯虚函数和抽象类:
含有纯虚函数的类是抽象类,不能生成对象,只能派生。他派生的类的纯虚函数没有被改写,那么,它的派生类还是个抽象类。

定义纯虚函数就是为了让基类不可实例化化,因为实例化这样的抽象数据结构本身并没有意义.或者给出实现也没有意义。定义纯虚函数的一般形式为:
class 类名{
virtual 返回值类型函数名(参数表)= 0; // 后面的“= 0“是必须的,否则,就成虚函数了
};
纯虚函数是一个在基类中说明的虚函数,它在基类中没有定义,要求任何派生类都定义自己的版本。纯虚函数为各派生类提供一个公共界面。
从基类继承来的纯虚函数,在派生类中仍是虚函数。

纯虚函数的定义

纯虚函数是一种特殊的虚函数，它的一般格式如下：
class 《类名》
{
virtual 《类型》《函数名》(《参数表》)=0;
…
};
在许多情况下，在基类中不能对虚函数给出有意义的实现，而把它声明为纯虚函数，它的实现留给该基类的派生类去做。这就是纯虚函数的作用。
纯虚函数可以让类先具有一个操作名称，而没有操作内容，让派生类在继承时再去具体地给出定义。凡是含有纯虚函数的类叫做抽象类。这种类不能声明对象，只是作为基类为派生类服务。除非在派生类中完全实现基类中所有的的纯虚函数，否则，派生类也变成了抽象类，不能实例化对象。
一般而言纯虚函数的函数体是缺省的，但是也可以给出纯虚函数的函数体（此时纯虚函数变为虚函数），这一点经常被人们忽视，调用纯虚函数的方法为baseclass::virtual function.

什么是纯虚函数

纯虚函数是面向对象程序设计中的一个重要的概念。只能适用于指针和参考的计算机工程运算.当从父类中继承的时候，虚函数和被继承的函数具有相同的签名。但是在运行过程中，运行系统将根据对象的类型，自动地选择适当的具体实现运行。虚函数是面向对象编程实现多态的基本手段。

虚函数 纯虚函数是一个东西吗

这个是C++内容!
虚函数和纯虚函数不是一个东西!!!!

---------------------------------------
虚函数和纯虚函数

在面向对象的C++语言中，虚函数（virtual function）是一个非常重要的概念。因为它充分体现了面向对象思想中的继承和多态性这两大特性，在C++语言里应用极广。比如在微软的MFC类库中，你会发现很多函数都有virtual关键字，也就是说，它们都是虚函数。难怪有人甚至称虚函数是C++语言的精髓。

那么，什么是虚函数呢，我们先来看看微软的解释：

虚函数是指一个类中你希望重载的成员函数，当你用一个基类指针或引用指向一个继承类对象的时候，你调用一个虚函数，实际调用的是继承类的版本。

——摘自MSDN

这个定义说得不是很明白。MSDN中还给出了一个例子，但是它的例子也并不能很好的说明问题。我们自己编写这样一个例子：

＃i nclude “stdio.h“

＃i nclude “conio.h“

class Parent

{

public:

char data;

void Function1();

virtual void Function2(); // 这里声明Function2是虚函数

}parent;

void Parent::Function1()

{

printf(“This is parent,function1\n“);

}

void Parent::Function2()

{

printf(“This is parent,function2\n“);

}

class Child:public Parent

{

void Function1();

void Function2();

} child;

void Child::Function1()

{

printf(“This is child,function1\n“);

}

void Child::Function2()

{

printf(“This is child,function2\n“);

}

int main(int argc, char* argv)

{

Parent *p; // 定义一个基类指针

if(_getch()==’c’) // 如果输入一个小写字母c

p=&child // 指向继承类对象

else

p=&parent // 否则指向基类对象

p-》Function1(); // 这里在编译时会直接给出Parent::Function1()的

入口地址。

p-》Function2(); // 注意这里，执行的是哪一个Function2？

return 0;

}

用任意版本的Visual C++或Borland C++编译并运行，输入一个小写字母c，得到下面的结果：

This is parent,function1

This is child,function2

为什么会有第一行的结果呢？因为我们是用一个Parent类的指针调用函数Fuction1()，虽然实际上这个指针指向的是Child类的对象，但编译器无法知道这一事实（直到运行的时候，程序才可以根据用户的输入判断出指针指向的对象），它只能按照调用Parent类的函数来理解并编译，所以我们看到了第一行的结果。

那么第二行的结果又是怎么回事呢？我们注意到，Function2()函数在基类中被virtual关键字修饰，也就是说，它是一个虚函数。虚函数最关键的特点是“动态联编”，它可以在运行时判断指针指向的对象，并自动调用相应的函数。如果我们在运行上面的程序时任意输入一个非c的字符，结果如下：

This is parent,function1

This is parent,function2

请注意看第二行，它的结果出现了变化。程序中仅仅调用了一个Function2()函数，却可以根据用户的输入自动决定到底调用基类中的Function2还是继承类中的Function2，这就是虚函数的作用。我们知道，在MFC中，很多类都是需要你继承的，它们的成员函数很多都要重载，比如编写MFC应用程序最常用的CView::OnDraw(CDC*)函数，就必须重载使用。把它定义为虚函数（实际上，在MFC中OnDraw不仅是虚函数，还是纯虚函数），可以保证时刻调用的是用户自己编写的OnDraw。虚函数的重要用途在这里可见一斑。

再看下面的
-----------------------------------------------------------
上一篇:为何析构函数中的cout不起作用 下一篇:菱形虚拟继承后，派生类的大小问题C++中虚函数和纯虚函数的概念，差别和分别存在的原因
摘自：C++中虚函数和纯虚函数的概念，差别和分别存在的原因

首先：强调一个概念
定义一个函数为虚函数，不代表函数为不被实现的函数
定义他为虚函数是为了允许用基类的指针来调用子类的这个函数
定义一个函数为纯虚函数，才代表函数没有被实现
定义他是为了实现一个接口，起到一个规范的作用，规范继承这个
类的程序员必须实现这个函数。

对继承的影响：
普通的类（没有虚函数，纯虚函数）就可以被继承，而且工作的相当好

关于这个问题有以下疑问：
纯虚函数难道就是为了实现接口？接口存在的意义？
我实在弄不懂，我干嘛要预先定义好？未来的事情本难料
就等有一天我的类中需要使用某个函数，在添加一个函数
不久可以？

关于实例化一个类：
有纯虚函数的类是不可能生成类对象的，如果没有纯虚函数则可以。比如：
class CA
{
public:
virtual void fun() = 0; // 说明fun函数为纯虚函数
virtual void fun1();
};

class CB
{
public:
virtual void fun();
virtual void fun1();
};

// CA，CB类的实现
...

void main()
{
CA a; // 不允许，因为类CA中有纯虚函数
CB b; // 可以，因为类CB中没有纯虚函数
...
}

---------------------------------------------------------------
虚函数在多态中间的使用：
多态一般就是通过指向基类的指针来实现的。

dog mydogwangwang;
mydogwangwang.born();
一定是返回“dog”

那么
horse myhorsepipi;
myhorsepipi.born();
一定是返回“horse”

也是多态呀？
/////////////////////////////////////////////////
有一点你必须明白，就是用父类的指针在运行时刻来调用子类:
例如，有个函数是这样的：
void animal::fun1(animal *maybedog_maybehorse)
{
maybedog_maybehorse-》born();
}

参数maybedog_maybehorse在编译时刻并不知道传进来的是dog类还是horse类，所以就把它设定为animal类，具体到运行时决定了才决定用那个函数。
也就是说用父类指针通过虚函数来决定运行时刻到底是谁而指向谁的函数。
////////////////////////////////////////////////////////////////////
//用虚函数
#include 《iostream.h》

class animal
{
public:
animal();
~animal();
void fun1(animal *maybedog_maybehorse);
virtual void born();

};

void animal::fun1(animal *maybedog_maybehorse)
{
maybedog_maybehorse-》born();
}

animal::animal()
{
}
animal::~animal()
{
}
void animal::born()
{
cout《《 “animal“;
}

class dog: public animal
{
public:
dog();
~dog();
virtual void born();
};

dog::dog()
{
}
dog::~dog()
{
}
void dog::born(){
cout《《“dog“;
}

class horse:public animal
{
public:
horse();
~horse();
virtual void born();
};

horse::horse()
{
}

horse::~horse()
{
}
void horse::born(){
cout《《“horse“;
}

void main()
{
animal a;
dog b;
horse c;
a.fun1(&c);
}

//output: horse

/////////////////////////////////////////////////////////////////
//不用虚函数

#include 《iostream.h》

class animal
{
public:
animal();
~animal();
void fun1(animal *maybedog_maybehorse);
void born();

};

void animal::fun1(animal *maybedog_maybehorse)
{
maybedog_maybehorse-》born();
}

animal::animal()
{
}
animal::~animal()
{
}
void animal::born()
{
cout《《 “animal“;
}

class dog: public animal
{
public:
dog();
~dog();
void born();
};

dog::dog()
{
}
dog::~dog()
{
}
void dog::born(){
cout《《“dog“;
}

class horse:public animal
{
public:
horse();
~horse();
void born();
};

horse::horse()
{
}

horse::~horse()
{
}
void horse::born(){
cout《《“horse“;
}

void main()
{
animal a;
dog b;
horse c;
a.fun1(&c);
}

output: animal

---------------------------------------------------------------

有纯虚函数的类是抽象类，不能生成对象，只能派生。他派生的类的纯虚函数没有被改写，那么，它的派生类还是个抽象类。
---------------------------------------------------------------

定义纯虚函数就是为了让基类不可实例化化,
因为实例化这样的抽象数据结构本身并没有意义.
或者给出实现也没有意义
实际上我个人认为纯虚函数的引入,是出于两个目的,
1.为了安全.因为避免任何需要明确但是因为不小心而导致的未知的结果.
提醒子类去做应做的实现.
2.为了效率,不是程序执行的效率,而是为了编码的效率.

关于纯虚函数

其实从底层来看，编译器只为纯虚函数保留了一个入口地址空间，其他什么都不做。由派生出的子类负责将此地址空间覆盖成为自己的成员函数地址。这样做的目的是为了实现多态，因为对不同派生类的成员函数的访问都会映射到不同的代码当中。

这样基类的指针就可以访问到派生类的成员函数了。

C++中纯虚函数有什么作用

　　通过它可以指明一个虚拟函数只是提供了一个可被子类型改写的接口。

　　纯虚函数是在基类中声明的虚函数，它可以在基类中有定义，而且派生类必须定义自己的实现方法。基类不能生成对象，可以使用指针或者引用派生类对象。基类不在基类中实现纯虚函数的方法是在函数原型后加“=0”

　　virtual void funtion1()=0

引入原因/纯虚函数的作用

1. 为了方便使用多态特性，我们常常需要在基类中定义虚拟函数。

2. 在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。

　　为了解决上述问题，引入了纯虚函数的概念，将函数定义为纯虚函数（方法：virtual ReturnType Function()= 0;），则编译器要求在派生类中必须予以重写以实现多态性。同时含有纯虚拟函数的类称为抽象类，它不能生成对象。这样就很好地解决了上述两个问题。

5.请回答: 在c++中什么是虚函数什么是纯虚函数

虚函数可确保调用的函数是派生类的而不是基类的。

纯虚函数是什么都没写的一个函数virtualvoid fuc（）=0，需要派生类自己去写出它。