文章目录

1. 抽象
2. 封装
3. 继承
1. 3.1. 子类(派生)
4. 多态
5. 建立类与对象
1. 5.1. 类的成员函数

Grand theft dora

抽象、封装、。
面向对象的核心是类,利用它可以实对**数据和方法(函数)**的封装，通过类类的继承，能够实现对问题的深入抽象描述。在面向对象程序设计中，程序模块由类构成。

函数是对方法的封装，用于完成特定的功能。

C++是一种比较流行的面向对象语言，面向对象语言有三大特性：继承，封装和多态。

抽象

抽象与具体相对应,
就是找出事物的共性，忽略具体细节,将相同性质的事物化为一类，，

抽象就是面向对象程序设计的基本原则之一

类是抽象的描述，是具有相同的属性和行为形成的一组对象，一个属于某类的对象称为该类的一个实例。

封装

利用**类(class)的形式进行封装，通过封装可以将每个对象的数据（属性）和操作（行为）封装在一个类中，使其形成一个有机的整体**.

一部分操作或属性作为类与外部的接口，将其他成员隐藏起来，这样可以使用接口访问程序。

使用接口访问程序，使模块化程序之间关系更简单、数据更安全，对程序的修改该也仅限制于内部。

将数据和代码封装为一个可重用的C++类,在编写代码的时候就可以使用现有的类，而不必了解具体的实现细节。

例如：
电视封装形式：

class Television    //class关键字 类名
{               //边界
public:          //外部接口
    void SetChannel(int Channe1Num);    //行为，代码成员
    void ShutDown();              //行为，代码成员
private:                //特定的访问权限
    int CurrentChanel;              //属性，数据成员
};                                  //边界

这是一个C++类的声明，它声明了Television的类，
大括号”{ }”中部分成员称为**类体，类体由成员表**组成，成员表为 数据定义或函数定义。

声明为public和private是利用指定成员的不同访问权限。

声明为Public的函数为类提供了外部接口，外接只能通过这个接口与television类发生联系，.
声明为private的整形数据是Television类的私有成员，外接无法直接访问。
可以看到，C++中通过类的机制实现了对数据的有效封装。

继承

继承(inheritance)将一个类的操作和数据结构提供另一个类，这使得程序员可以使用已有的类建立新类。新类继承了现有类的特性，包裹一些属性和行为,并且可以修改或增加新的属性和行为。

继承是面向对象技术能够提高软件开发效率的重要原因之一，更好的解决了软件可**重用性**问题。

子类(派生)

C++可以声明一个新类作为另一个类的派生。派生类(也叫子类)继承父类的属性和操作。

子类也声明了新的操作和属性，除去了一些不适合于自身用途的继承下来的操作和属性。

继承也可以重用父类的代码，只专注与子类代码的编写。

父类中已经实现的操作，在新的应用中，无需修改复用，所做的就是声明其派生类，在子类中做一些增加和修改。这种机制，实现了**代码的重用**。

多态

virtual函数(虚函数)表示允许在相同家族中的类有不同的行为。这些不同是引起多态行为的原因。

多态性(polymorphism)是指允许不同类的对象对同一消息做出的响应不同。

一般类中定义的属性或行为，被特殊类继承后，可以具有不同的语义。

建立类与对象

类由描述某类事物的数据和处理这些数据的函数组成，是一种导出数据类型，可用于定义对象。要定义对象，首先先定义类。

类的定义格式如下：

class  <类名>
{  private:         //定义私有成员或成员函数
    <成员表1>
    public：     //定义公有数据成员或成员函数
    <成员表2>
    protected:      //定义保护数据成员或成员函数
    <成员表3>
};

例如：声明一个类来描述电视，其形式如下：

class  Television
{
public:                                     //定义公有成员，允许本类或类外的函数访问
    void SetChannel(int ChangelNum);
    void Shutdown();
    void TurnOn();
private:                                    //定义私有成员,只允许本类的内部函数访问
    int CurrentChannel;
    bool IsOpen;
};
void Television::SetChannel(int ChannelNum)
{
    //....
    CurrentChannel=
}

Television Tv;      // Television类的实例化
Tv.TurnOn();        //调用成员函数打开电视
Tv.SetChannel(8);   //调用成员函数选择频道
Tv.ShutDown();      //调用成员函数关闭电视

public:定义公有成员；允许本类或类外的函数访问、调用。

在书写习惯时，让公有成员在最前面被声明，这样方便阅读。
private:定义私有成员函数；值允许本类的内部函数访问，

类外函数不允许访问私有成员函数，也不允许调用私有成员函数

建议将变量定义为私有成员,这样类以外的代码不能直接访问类的数据，从而实现封装。

private关键字可以省略，访问权限关键字缺省的情况下类成员会被当作私有类型。
protected:定义保护成员；值允许本类或子类中函数访问、调用。

类的成员函数

类的行为由类的成员函数描述,成员函数是算法实现的部分，是对封装的数据进行的唯一途径。

内联函数

代码**相对简单且调用次数频繁的成员函数可以声明为内联函数**。也可以采用在函数实现的时候加上inline显式声明的方式。

实例：定义一个成员函数

#include<iostream>
using namespace std;

class Circle
{
public:
	void SetRadius(float Radius)
	{
		m_Radius = Radius;
	}
	float GetCircumference()
	{
		return 2 * m_Radius*3.14159265;
	}
	void PrintCircumference()
	{
		cout << "Circumference:" << GetCircumference() << endl;
	}

private:
	float m_Radius;
};

void main()
{
	Circle c;					//创建一个Circle类的对象
	c.SetRadius(5);				//调用成员函数SetRadius()对对象的数据成员赋值
	c.PrintCircumference();		//调用成员函数 PrintCircumference()输出计算结果
}

Circle类定义的大括号里的3个成员函数是在类的声明部分中定义，定义在类的成员函数一般规模都比较小，只有1~5句，特别是不能使用switch语句。

在C++中，通常头文件里定义类，因此这些成员函数也别写入头文件，通常在头文件中只是声明函数，而函数定义不能在头文件了i，因为他们会被编译多次。如果是作为内联函数，则允许被包含在头文件中，因为内联函数在源程序中原地拓展，这样可以减少调用的开销。

在类中被定义的成员函数被默认为内联函数，这样就避免了函数定义不能被包含在头文件里。

类外定义的成员函数

C++允许在类声明的后面定义成员函数.
在类主体外定义成员函数的格式为:

1	<类型> <类名>:: <成员函数名>(形参表) {函数体}

其中::称为域运算，它指出成员函数是属于类名所指类中的成员函数。

class Circle
{
public:
	void SetRadius(float Radius);
	float GetCircumference(); 
		void PrintCircumference();
private:
	float m_Radius;
};

#include<iostream>
#include "header.h"

using namespace std;
void Circle::SetRadius(float Radius)   //在类外部定义时，成员函数名前要多家一个类名；如果不加编译器就会认为该函数不是类的成员函数
{
	m_Radius = Radius;
}
float Circle::GetCircumference()
{
	return 2 * m_Radius*3.14159265;
}
void Circle::PrintCircumference()
{
	cout << "Circumference:" << GetCircumference() << endl;
}


void main()
{
	Circle c;					//创建一个Circle类的对象
	c.SetRadius(5);				//调用成员函数SetRadius()对对象的数据成员赋值
	c.PrintCircumference();		//调用成员函数 PrintCircumference()输出计算结果
}

程序中采用将成员函数的定义和类的定义分开，是目前开发程序最常用的做法。

类的定义（头文件）将被堪称类的外部接口，类的成员函数则堪称是类的内部实现。这和标准库的使用道理一致。

类的成员函数的重载&&类与结构体的关系

#include<iostream>
using namespace std;
class Car
{
public:
	void SetSpeed()
	{
		m_speed = 40;
		cout << "m_speed=" << m_speed << "---->mark1" << endl;
	}
	void SetSpeed(float speed)
	{
		m_speed = speed;
		cout << "m_speed=" << m_speed << "---->mark2" << endl;
	}

private:
	float m_speed;
};

class Truck
{
public:
	void SetSepeed(float speed)
	{
		m_speed = speed;
		cout << "m_speed=" << m_speed << "---->mark3" << endl;
	}
private:
	float m_speed;
};

void SetSpeed(float speed)
{
	float sp = speed;
	cout << "sp=" << sp << "---->mark4" << endl;
}

void main()
{
	Car c;
	Truck t;
	c.SetSpeed();    //mark 1    匹配 Car类中的void SetSpeed();
	c.SetSpeed(10.2);  //mark2    匹配 Car类中的     void SetSpeed(float speed)

	t.SetSepeed(60);   //mark 3      匹配 Truck类中 void SetSepeed(float speed)
	c.SetSpeed(80);    // 同mark2
	SetSpeed(100.5);     //mark4    匹配全局函数  void SetSpeed(float speed)
};

结构体与类的唯一区别在于：在类中，其成员的缺省存取权限是私有，而在结构体类型中，其成员的缺省权限是公有。

当只需要描述数据结构时，使用结构体较好。而既要描述数据的处理方法时使用类较好。

个人技术技术经验积累

他们消亡的原因不是因为失败太多，而是因为尝试太少

C++_memo-对象

抽象

封装

继承

子类(派生)

多态

建立类与对象

类的成员函数