MFC程序开发-C++知识补强（二）

4.继承

类的继承是指派生类可以全部或者部分的继承基类的特征，同时加入所需要的新特征和功能。

单继承格式为：class 类名:访问限定符 基类名

其中，访问限定符一共有三种，介绍如下：

public：对于基类中的public成员，在派生类中仍然是public，protected成员仍然是protected

protected：对于基类中的public成员和protected成员，在派生类中全部为protected

private：对于基类中的public成员和protected成员，在派生类中全部为private。

多继承：派生类继承了多个基类。格式为：class 类名:访问限定符1  基类名1,访问限定符2  基类名2,......

如果多个基类中都有同名的方法，那么在调用基类时需要指明调用的是哪一个类的方法。格式为：对象名.类名::方法；

如果类的多个基类派生于同一个类，那么在调用该类的方法时，会出现编译错误，因为编译器不知道该调用哪一个父类的方法，这时候同样需要指明调用的是哪一个类的方法，格式同上。也可以采用虚继承。

虚继承：用virtual关键字进行的继承，其格式如下：class 类名:virtual  访问限定符 基类名称 

当进行虚继承时，编译器会通过指针对其进行处理，使其只能产生一个基类子对象，这样编译器就不会产生错误。

给出一个简单的例子好了：

#include "stdafx.h"
#include<iostream>
using namespace std;


class ball
{
public:
	ball();
	~ball();
	void output();
private:

};

ball::ball()
{
}

ball::~ball()
{
}

void ball::output(){
	cout << "ball is interesting" << endl;
}


class player:public ball
{
public:
	player();
	~player();
	void output1();
private:

};

player::player()
{
}

player::~player()
{
}

void player::output1(){
	cout << "is a player ";
}

class tennis:public ball
{
public:
	tennis();
	~tennis();
	void output1();
private:

};

tennis::tennis()
{
}

tennis::~tennis()
{
}

void tennis::output1(){
	cout << "of tennis!" << endl;
}

class rafa:public tennis,public player
{
public:
	rafa();
	~rafa();
	void output2();
private:

};

rafa::rafa()
{
}

rafa::~rafa()
{
}

void rafa::output2(){
	cout << "Rafa ";
}

int _tmain(int argc, _TCHAR* argv[])
{
	rafa Rafael;
	Rafael.tennis::output();
	Rafael.output2();
	Rafael.player::output1();
	Rafael.tennis::output1();
	system("pause");
	return 0;
}

输出如下：

同时，我在子类中试图重写父类方法时，发现如果要重写方法，则要在子类中重新声明该方法。然后就是发现了一个超级有趣的知识点：重载、覆盖和隐藏的区别

下面是一个讲的很好的博文的地址：http://www.cnblogs.com/sujz/articles/2044365.html

5.静态成员和静态方法

静态成员：其数据是属于类的，通过类名就可以访问数据的成员。静态数据成员在声明时就分配了存储空间，而且类中的所有方法都可以访问这个静态成员，也可以利用这个特性在同一个类中的各个对象之间传递数据。当一个对象修改了静态数据成员，了一个对象在访问静态数据成员时，也会发生变化。声明静态数据成员的方法很简单，就是在类型之前加static关键字即可。

静态方法：同静态成员一样，声明方法就是在返回值类型前加static关键字。但是需要注意的是，在静态方法中只能访问静态数据成员，不能访问普通的数据成员。

给一个例子：

#include "stdafx.h"
#include<iostream>
using namespace std;


class rafa
{
public:
	rafa();
	~rafa();
	static int i;
	static void output(int num);
private:

};
int rafa::i = 1;//初始化静态数据成员

rafa::rafa()
{
}

rafa::~rafa()
{
}

void rafa::output(int num){
	cout << i + num << endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
	rafa::i = 2;
	rafa::output(2);
	rafa::output(4);
	system("pause");
	return 0;
}

此处要注意的是，静态数据成员在声明之后一定要初始化才可以！

6.友元类和友元函数

友元类：友元类实现了一个类对另一个类的无限制访问，一个类在确认另一个类为友元后，可以让另一个类读写自己的私有数据成员和方法。

友元函数：一个类在确认另一个类的某个方法为自己的友元函数后，在那个方法中就可以访问类的私有数据成员和方法了。这样就避免了让整个类称为另一个类的友元。

友元类和友元函数的声明方法都是在最前面加上friend关键字。

下面给一个例子：

#include "stdafx.h"
#include<iostream>
using std::cin; using std::cout; using std::ostream; using std::istream; using std::endl;

class ball;//

class rafa
{
public:
	rafa();
	~rafa();
	void output1();
	ball* newball;
private:

};

class ball
{
public:
	ball();
	~ball();
	friend void rafa::output1();
private:
	void output(){ cout << "Playing ball is interesting!" << endl; }
};

ball::ball()
{
}

ball::~ball()
{
}


rafa::rafa()
{
}

rafa::~rafa()
{
}

void rafa::output1(){
	newball = new ball;
	newball->output();
}

int _tmain(int argc, _TCHAR* argv[])
{
	rafa Rafael;
	Rafael.output1();
	system("pause");
	return 0;
}

注意友元函数的声明格式，在类中声明的友元函数需要在类声明之前就已经定义了。在使用时，友元函数不能访问直接访问类的成员，而是要访问对象的成员。

若是要声明类的对象，那么类一定要在声明对象前进行定义，就像是代码中//所提示的那样。