1.继承类型(参考博客:http://blog.sina.com.cn/s/blog_648d306d0100rzs6.html)
私有继承,公有继承,和保护继承三种,主要是子类在类内,类外使用基类的成员的权限不同。
例如,基类A,B继承A,C继承B
B继承A的方式有两方面的影响:
①B在类内、类外使用A成员的权限
②C在类内、类外使用A成员的权限
测试代码如下:
class A
{
public:
int m_public;
protected:
int m_protected;
private:
int m_private;
};
class B :public A
{
void SetPublic(int nPublic)
{
m_public = nPublic;
}
void SetProtected(int nProtected)
{
m_protected = nProtected;
}
void SetPrivate(int nPrivate)
{
m_private = nPrivate; //错误,因为基类的private成员不能用
}
};
B b; //创建B类的对象c
b.m_public = 100; //正确
b.m_protected = 100; //错误,public继承中基类的protected在派生类中是protected
b.m_private = 100; //错误,在派生类中都不可以直接使用,在类外就更不能了
class C :protected A
{
void SetPublic(int nPublic)
{
m_public = nPublic;
}
void SetProtected(int nProtected)
{
m_protected = nProtected;
}
void SetPrivate(int nPrivate)
{
m_private = nPrivate; //错误,因为基类的private成员不能用
}
};
C c; //创建C类的对象c
c.m_public = 100; //错误,protected继承C类里变成了protected成员
c.m_protected = 100; //错误,protected继承C类里还是protected成员
c.m_private = 100; //错误,在派生类中都不可以直接使用,在类外就更不能了
class D :private A
{
void SetPublic(int nPublic)
{
m_public = nPublic;
}
void SetProtected(int nProtected)
{
m_protected = nProtected;
}
void SetPrivate(int nPrivate)
{
m_private = nPrivate; //错误,因为基类的private成员不能用
}
};
D d; //创建D类的对象d
d.m_public = 100; //错误,private继承D类里变成了private成员
d.m_protected = 100; //错误,private继承D类里变成了private成员
d.m_private = 100; //错误,在派生类中都不可以直接使用,在类外就更不能了
分析:①A的公有成员和保护成员在B中权限不变,即在B类内均可访问,在类外不可访问A的保护成员
②A的公有成员和保护成员在C中变为保护成员属性,即在C类内均可访问,在类外不可访问
③A的公有成员和保护成员在D中均变为私有成员属性,访问同2;
看起来私有继承和保护继承的效果是一样的,其实他们的效果体现在下一层继承,测试代码:
class E :public B
{
void SetPublic(int nPublic)
{
m_public = nPublic; //正确 因为这是B类的公有成员
}
void SetProtected(int nProtected)
{
m_protected = nProtected; //正确 因为这是B类的保护成员,现成变成E类的protected成员
}
void SetPrivate(int nPrivate)
{
m_private = nPrivate; //错误,因为基类的private成员不能用
}
};
E e; //创建E类的对象e
e.m_public = 100; //正确
e.m_protected = 100; //错误,protected继承E类里变成了protected成员
e.m_private = 100; //错误,在派生类中都不可以直接使用,在类外就更不能了
class F :public C
{
void SetPublic(int nPublic)
{
m_public = nPublic; //正确 因为这是C类的protected成员
}
void SetProtected(int nProtected)
{
m_protected = nProtected; //正确因为这是C类的protected成员,现成变成F类的protected成员
}
void SetPrivate(int nPrivate)
{
m_private = nPrivate; //错误,因为基类的private成员不能用
}
};
F f; //创建F类的对象f
f.m_public = 100; //错误,在C类里就已变成protected成员
f.m_protected = 100; //错误,protected继承E类里变成了protected成员
f.m_private = 100; //错误,在派生类中都不可以直接使用,在类外就更不能了
class G :public D
{
void SetPublic(int nPublic)
{
m_public = nPublic; //错误 因为这是D类的private成员
}
void SetProtected(int nProtected)
{
m_protected = nProtected; //错误因为这是D类的private成员
}
void SetPrivate(int nPrivate)
{
m_private = nPrivate; //错误,因为基类的private成员不能用
}
};
分析:①继承方式对类内的影响体现了,私有继承时,在G中类内类外均不可访问
2.多态性调用
多态性调用分为两种:静态绑定(即函数重载)和动态绑定(虚函数),也有人称为编译时多态和运行时多态。本来重载和覆盖很好区别,但是C++的隐藏规则,很容易使人迷惑。
①多态性(晚绑定)的使用基础是赋值兼容,而赋值兼容成立的条件是公有继承,因此,只有公有继承方式才能实现运行时多态
②虚函数语法:
基类:virtual 返回值类型 函数名(参数列表);
派生类:(virtual)可以省略,函数名和参数列表同基类完全一致,即通过覆盖实现多态;若参数列表不一致,则为重载,就会产生隐藏,不能实现多态的效果。
③虚函数的实现原理
在包含虚函数的类中,编译器都会隐形的定义一个指针,指向虚表,虚表中存放的是虚函数的偏移量而非地址
表中虚函数的位置与基类中虚函数的声明顺序一致
虚表指针大小为4字节
若子类对基类中的虚函数没有覆盖,则在虚表中存放的就是基类虚函数 的地址
④多态性调用的实现(与指针类型无关,而与指向的对象有关)
例程:
#include<iostream>
using namespace std;
class A
{
public:
void foo()
{
printf("1\n");
}
virtual void fun()
{
printf("2\n");
}
};
class B : public A
{
public:
void foo()
{
printf("3\n");
}
void fun()
{
printf("4\n");
}
};
int main(void)
{
A a;
B b;
A *p = &a;
p->foo();
p->fun();
p = &b;
p->foo();
p->fun();
return 0;
}
第一个p->foo()和p->fuu()都很好理解,本身是基类指针,指向的又是基类对象,调用的都是基类本身的函数,因此输出结果就是1、2。
第二个输出结果就是1、4。p->foo()和p->fuu()则是基类指针指向子类对象,正式体现多态的用法;
还有一种调用,是定义子类指针,指向基类,是不安全的,因此需要进行强制类型转换
B *ptr = (B *)&a; ptr->foo(); ptr->fun();
调用结果为3 2
从上面明显可以看出,多态性调用可指针类型无关,只和指向的对象有关;而隐藏规则恰恰相反,和指向的对象无关,只和指针的类型相关;接下来就分析隐藏规则。
3.隐藏规则
例程
//小结:1、有virtual才可能发生多态现象
// 2、不发生多态(无virtual)调用就按原类型调用
#include<iostream>
using namespace std;
class Base
{
public:
virtual void f(float x)
{
cout<<"Base::f(float)"<< x <<endl;
}
void g(float x)
{
cout<<"Base::g(float)"<< x <<endl;
}
void h(float x)
{
cout<<"Base::h(float)"<< x <<endl;
}
};
class Derived : public Base
{
public:
virtual void f(float x)
{
cout<<"Derived::f(float)"<< x <<endl; //多态、覆盖
}
void g(int x)
{
cout<<"Derived::g(int)"<< x <<endl; //隐藏
}
void h(float x)
{
cout<<"Derived::h(float)"<< x <<endl; //隐藏
}
};
int main(void)
{
Derived d;
Base *pb = &d;
Derived *pd = &d;
// Good : behavior depends solely on type of the object
pb->f(3.14f); // Derived::f(float) 3.14
pd->f(3.14f); // Derived::f(float) 3.14
// Bad : behavior depends on type of the pointer
pb->g(3.14f); // Base::g(float) 3.14
pd->g(3.14f); // Derived::g(int) 3
// Bad : behavior depends on type of the pointer
pb->h(3.14f); // Base::h(float) 3.14
pd->h(3.14f); // Derived::h(float) 3.14
return 0;
}
出现隐藏的情况:
①子类的参数列表和基类的不一致,无论该函数是否有virtual关键字,基类的函数将被子类的隐藏,即调用时和指向的对象无关,和指针类型相关,区别与重载
②子类的参数列表和基类一致,但无virtual关键字,基类的函数将被子类隐藏,区别与覆盖
4.直接定义对象,而不用指针调用成员函数,那就很简单;只是不能体现多态性
5.析构函数可以定义为虚函数,构造函数不能定义为虚函数
析构函数定义为虚函数的作用,参考博客http://www.cnblogs.com/CaiNiaoZJ/archive/2011/08/11/2134673.html,例程
#include "stdafx.h"
#include <iostream>
#include <string>
class Graph
{
protected:
double x;
double y;
public:
Graph(double x,double y);
voidvirtual showArea();//定义为虚函数或virtual void showArea()
~Graph();
};
Graph::Graph(double x,double y)
{
this->x=x;
this->y=y;
}
void Graph::showArea()
{
std::cout<<"计算图形面积"<<std::endl;
}
Graph::~Graph()
{
std::cout<<"调用图形类析构函数"<<std::endl;
}
class Rectangle:public Graph
{
public:
Rectangle(double x,double y):Graph(x,y){};
virtualvoid showArea();//定义为虚函数
~Rectangle();
};
void Rectangle::showArea()
{
std::cout<<"矩形面积为:"<<x*y<<std::endl;
}
Rectangle::~Rectangle()
{
std::cout<<"调用矩形类析构函数"<<std::endl;
}
int main()
{
Graph *graph;
graph=new Rectangle(10,5);
graph->showArea();
delete graph;
return0;
}
调用结果为:
调用图形类析构函数
没有析构Rectangle对象,将基类析构函数定义为虚析构函数,则可解决问题
虽然派生类的析构函数与基类的析构函数名字不同,但是如果将基类的析构函数定义为虚函数,由该基类派生而来的所有派生类的析构函数都自动成为虚函数。
最后,记录一下this指针的理解
在MFC中,CWnd::OnCreate()中调用了this->PreCreateWindow();
一直以为this指针是指向CWnd的,总也不能理解为什么调用的是子类的PreCreateWindow();其实this指针指向的是实例化对象,CWnd并未实例化,因此指向的是其派生类对象,因此就完全可以理解了