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

Grand theft dora

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

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

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

抽象

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

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

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

封装

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

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

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

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

例如:
电视封装形式:

1
2
3
4
5
6
7
8
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)是指允许不同类的对象对同一消息做出的响应不同。

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

建立类与对象

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

类的定义格式如下:

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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显式声明的方式。

实例:定义一个成员函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#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
    <类型> 	<类名>::   <成员函数名>(形参表)      {函数体}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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()输出计算结果
}

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

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

  • 类的成员函数的重载&&类与结构体的关系
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#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)
};

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

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

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