面向对象和面向过程编程的区别

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

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

一、面向对象与面向过程

面向过程:

关注的是如何解决问题,以及解决问题的步骤

面向对象:

抽象:

先找出(想出)能解决问题的"对象",分析该对象解决问题所需要的属性(成员变量)和行为(成员函数)

封装:

把抽象的结果封装成一个类(结构),并给类(结构)的成员变量、成员函数设置相应的访问权限(public\protected\private)

继承:

1、在封装前先考虑现有的类是否能够解决一部分问题,如果有则把现有的继承过来,在此基础上进行扩展,以此来缩短解决问题的时间

2、把一个复杂的大问题拆分成若干个小问题,每个小问题设计一个类去解决,最后把这些类通过继承合并成一个能够解决复杂大问题的类

多态:

发出一个指令,系统会根据实际情况不同,执行相应的操作,这种特性叫做多态(同一个命令有多种形态)

比如重载过的函数,当调用函数时,编译器会根据参数的类型、个数,调用相应的重载版本,这就是一种多态

具体调用哪个版本的重载函数是编译器在编译时就能确定的,因此重载函数叫做编译时多态

注意:对象的行为的细节依然是面向过程,面向对象是以更高的维度去思考问题,而不是寻求解决问题的捷径

二、类和对象

什么是类和对象

类是由程序员设计的一种数据类型,它里面包含了成员变量、成员函数

对象是类的实例化,可以理解为使用类这种数据类型创建的变量

类的设计和实例化

class 类名

{

成员变量; // 类中默认属性是private 私有的

public:

成员函数;

};

对象实例化:

方法1: 类名 对象名;

方法2: 类名* 对象名_p = new 类名;

类的声明、实现和使用:

在头文件中设计和声明:

class 类名

{

成员变量; // 类中默认属性是private 私有的

public:

返回值 函数名(参数列表); // 只写函数声明

};

在对应的源文件中实现:

返回值 类名::函数名(参数列表)

{

// 在成员函数的实现中可以直接使用成员变量、成员函数,不需要加 . 或者 ->

}

注意:如果类的内容不多,也可以考虑在头文件中全部实现

使用:

实例化对象,通过 . 或者 -> 访问成员

三、访问控制限定符

private

私有的,被它修饰的成员只能在类内访问,这也是类的默认访问属性

设置为私有是为了对类进行保护,一般会给成员变量设置为私有的

public

公开的,被它修饰的成员在任何位置都可以访问,一般把类的成员函数设置为公开的

protected

保护的,被它修饰的成员只能在类内和子类中访问,但是不能在类外访问

四、构造函数

构造函数是类的同名成员函数,当实例化对象时它会自动执行,一般设置负责对类进行初始化、分配资源

class 类名

{

int* p;

public:

类名(参数) // 构造函数 可重载

{

p = new int;

}

};

1、构造函数必须是public,否则根本无法实例化对象

2、构造函数可以重载,可以有多个版本

3、带参数的构造函数的调用

类名 对象名(实参);

类名* 对象名p = new 类名(实参);

4、默认情况下编译器会自动生成一个没有参数、什么都不做的无参构造函数,一旦显式地实现了构造函数,该无参构造就不会再生成

Test t;

Test* t = new Test;

5、构造函数也可以使用默认形参,从而可以达到无参构造的效果,因此实例化对象时不提供任何参数,不一定调用无参构造

6、构造函数没有返回值

7、不要使用malloc为类对象分配内存,因为它不会调用构造函数

五、析构函数

析构函数负责对类对象进行收尾,例如:释放类中的资源、保存数据等,当类对象销毁时会自动执行

class 类名

{

int* p;

public:

类名(参数) // 构造函数 可重载

{

p = new int;

}

~类名()

{

delete p;

}

};

1、析构函数也必须是public

2、析构函数没有参数、没有返回值、不能重载

3、当类对象生命周期完结,以及使用delete销毁对象时,会自动调用析构函数

4、构造函数一定会执行,析构函数不一定会执行

5、不要使用free销毁类对象,因为它不会调用析构函数

6、如果没有显示地实现析构函数,编译器也会自动生成一个什么都不做的析构函数

六、初始化列表

初始化列表是构造函数的一种特殊语法,只能在构造函数中使用

class 类名

{

public:

类名():成员1(初始化数据),成员2(初始化数据)...

{

// 初始化数据可以是常量、变量

}

}

1、类的成员变量不可以直接设置初始值,而在构造函数执行时成员变量都已经定义完毕,因此对于带有const属性的成员变量就无法在构造函数中初始化

2、初始化列表先于构造函数执行的,在初始化列表执行时类对象还没构造完成,是唯一一种可以给const属性的成员变量初始化的方法

3、当参数名与成员变量名相同时,编译器会自动分辨成员和参数

4、如果有成员是类类型,则该成员的构造函数(有参、无参)也可以在初始化列表中调用

作业:

1、使用C++的语法实现通讯录

2、使用C++的语法实现五子棋

选作:

1、使用C++的语法实现NetWork

class Mail

{

const int max_cnt;

string* name;

char* sex;

string* tel;

public:

Mail(int max_cnt):max_cnt(max_cnt)

{

// 申请内存

name = new string[max_cnt];

...

}

~Mail()

{

}

...其他增删改查的成员函数

bool add();

};

int main()

{

Mail* mail = new Mail(50);

mail->add();

...

delete mail

}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值