C++总复习笔记

  C Plus 总复习笔记

 

2014.6.25.Chitry

 

第一章 面向对象介绍

2014年6月25日 09:28:36

 

1.    结构化程序设计：程序 = 算法 + 数据结构

 

基本思想：自顶向下，逐步细化的设计方法和单入单出的控制结构

 

重点：函数

 

                 缺点：a.程序难以管理

      b.数据修改存在问题

      c.程序可重用性差

      d.用户难以在系统分析阶段准确定义，致使系统在交付使用时产生许多问题

      e.用系统开发的每个阶段的成果来进行控制，不能适应事物变化的要求

 

          缺陷根源：  数据与数据处理相分离

 

 

 

2.面向对象程序设计：   程序 = 对象 + 对象 + 对象 + … + 消息传递

 

“以对象为中心的思维方式”

将系统看成通过交互作用来完成特定功能的对象的集合，每个对象用自己的方法来管理数据，亦即：只有对象内部的代码能够操作对象内部的数据

 

模拟自然界认知和处理事物的方法，将数据和对数据的操作方法放在一起，形成一个相对独立的整体——抽象（object）

 

对象 = [ 算法 + 数据结构 ]  “结合，适应变化，封装的，呈现的行为时稳定的，仅借口暴露 ”

 

对象（内容） = 属性 + 行为

 

同类对象可抽象出共性，形成类（class）

 

一个类中的数据通常只能通过本类提供的方法进行处理，这些方法成为该类与外部的接口

 

对象之间通过消息（message）进行通讯

 

 

3.面向对象程序设计的基本特征、特性、及其优缺点：

 

A.面向对象程序设计的基本特征：  抽象、封装、继承、多态

 

B.面向对象编程的特性：     a.程序设计的重点在数据而不是函数

b.程序由对象对象组成，建立对象不是为了完成一个步骤，而是为了描述某个事物在整个解决问题的步骤中行为

c.对象之间通过相互协作来完成功能

e.函数与相关数据紧密结合

e.数据可以被隐藏

f.很容易扩充新的数据和函数

 

C.面向对象编程的优缺点：

优点：a.易维护

   b.质量高

   c.效率高

   d.易拓展

缺点：相对面向过程，运行效率会下降10%左右

 

 

 

4.面向结构化和面向对象的不同之处：

 

根本在于其抽象的级别不同

 

A.结构化程序设计方法应用的是过程抽象，是将问题域中具有明确功能定义的操作抽取出来，并将其作为一个实体看待

 

B.面向对象对象设计方法应用的是数据抽象，是较过程抽象更高级别的抽象方式，将抽象客体的属性和行为绑定在一起，实现统一的抽象，从而实现对现实世界客体的真正模拟。

 

 

 

5.编程语言四大需求：

 

1>.效率：速度

2>.灵活

3>.抽象：大型的系统开发的适应

4>.生产力：开发效率

 

* C ：效率、灵活

     C Plus：效率、灵活、抽象

 Java  &  .Net ：抽象、生产力

 

 

 

6.世界上第一种面向对象编程语言：  SmallTalk

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

第二章 从C到C++（C99，C++11）

2014年6月25日11:20:26

 

1.输入输出流： cin >> 变量                     输入对象：键盘

cout << 数据                    输出对象：显示屏

“>>” ”<<”仍然保留“按位移”功能

I/O流输入输出的是一串字节

 

2.命令空间：using namespace std;

若预处理命令为  .h 头文件形式，则无需申请命令空间

两种头文件不能混用！！

(尖括号为根目录下寻找头文件，圆括号为当前目录下查找头文件)

 

3.输出操纵符：“endl”  插入换行符，并刷新流（！！！endl不能用在输入流中，否则会报错！！！）

 

4.格式控制符：

cout << hex << x << ‘ ’ << dec  << x << ‘ ’<< oct << x << endl;

hex：十六进制输出

dec:十进制输出

oct:八进制输出

*作用域一直到程序结束

 

 

#  cout << setw(6) << 456 << endl;    以六位域宽输出“456”

但是必须加入iomanip.h头文件

 

5.续行符：“\”  续接过长的语句

 

6.C Plus中可以随时声明定义变量（C中要求要统一列与程序前几句）

 

7.结构、联合和枚举名可以直接作为类型名

 

8.const限定符：

与宏（#define）的区别：define是完全替换，不作整合总结

const 是先整合，后替换

默认为 const （int）i = 2100;

*这个常量i是有类型的 ，占存储单元的，有地址的，可以用指针指向它，但是不能修改它（常量的不可修改性）<内存空间被固化>

 

#*#

A.      const char * name = “lin”;        指向常量的指针   固化指针所指向的空间

B.       char *  const name = “lin”;           常指针  固化指针的指向

C.       const char * const name = “lin”;   指向常量的常指针  固化指针的指向和指针所指向的空间

 

&*&%：void型指针;void * p;  不确定类型  “通用型指针”

获值后，必须进行显示转换处理

 

 

9.内联函数：空间换时间！！

 

inline int show (int i, int j)“声明和函数体都必须加上inline关键字”

 

A. 内联函数体内不允许出现循环和switch语句（if可以出现）

B.内敛函数具有宏定义的相似机理，但更安全

宏：先替换语句，后传递参数

内敛函数：先传递参数，后替换语句

 

 

 

10.带缺省参数的函数：

 

int abc (itn x = 5,float y = 5.3);

 

调用：abc(100,79.8)；//x = 100, y = 79.8

      abc(25);//x = 25,y = 5.3

   abc( );//x = 5,y = 5.3

 

*声明函数时，所有指定默认值的参数都必须出现在不指定默认值的参数的右边（实参和形参的结合时从左到右顺序进行的），因此指定参数的形参必须放在参数列表中的最右端

int fun(int i,int j = 5,int k);              //Error!!

 

*调用时，不允许出现某个参数省略，再给其后参数指定参数值的情况

abc( , 21.5);         //Error!!

 

*函数声明和定义中只要求出现一次缺省值的定义就可以了，必须是在调用以前定义好，之后不必要再定义一次，否则会出现“重复指定默认值”的错误信息

 

 

 

 

11.函数重载：               静态的多态

 

前提：同一作用域中，形参个数和形参类型不同（与返回值无关）

 

*重载函数中尽量不要使用缺省值，可能引起二义性

void abc(int i = 0,int j = 0,int k = 0);

void abc(int i);

 

调用：abc(20);

编译系统无法确定调用哪一个函数

 

*重载函数调用时，若给出的实参与形参类型不相符，C++编译器就会自动做类型转换工作，有可能的错误：

void abc(int x);

void anc(long x);

 

调用：abc(5.56);

编译无法确定应该将5.56转换为何种类型

 

 

 

12.(作用)域运算符：  “：：”

“扩大/改变局部变量的作用范围”

 

：：aver               调用已被局部同名变量覆盖的全局变量

 

 

 

 

13.无名联合：          类比匿名对象

C++一种特殊联合(union)，它在关键字union后面没有给出联合名，它可是一组数据成员共享同一内存地址

 

 

 

 

14.new/delete运算符：

A.new运算符用于创建堆空间（类似C中的malloc函数“动态分配”）

**分配成功返回空间首地址，失败提示异常（VS中）（而不是NULL空指针（VC中））**

语法：a.指针变量 = new 数据类型；            创建一个数据类型的元素

Int *p；p = new int；

 b.指针变量 = new 数据类型[长度n]；         创建n个数据类型的元素

Int *p；p = new char[50];//数组大小必须写,new不能为之初始化

 

#  new动态分配多维数组空间：

Int *p = new int[2][3][4];         必须提供所有维度的大小

*其中，第一维可以使任意整数表达式

Int i =3；

Int *p = new int[i][3][4];

 

c. new 可以在为简单变量分配内存的同时，进行初始化

指针变量 = new 数据类型（初值）

Int *p；p = new int(99);     *p = 99

 

B.delete运算符用于释放堆空间（类似C中的free函数）

语法：delete 指针变量；

   delete[] 指针变量

 

 

C.   new一个新对象：   1>.内存分配（operator new）

2>.调用构造函数

 

     Delete释放一个对象：   1>.调用析构函数

      2>.释放内存（operator delete）

 

 

 

 

15.引用：           给变量起别名                         本质是指针

 

类型 & 引用名 = 已定义的变量名

Int i= 5；

Int & j = i;           //j是i的引用，j与i共用一段存储空间，改变i、j任何一个都会改变对应内存空间上的值

 

*a.除用作函数参数或返回值类型外，声明引用时，必须立即对它进行初始化

*b.可以为一个变量起多个别名

Int i= 5；

Int & j = i；

Int & k = j；              //i、j、k共用一段空间，引用j、k本身是不分配内存的

*c.引用在初始化后不能再被重新声明为另一个变量的引用（别名），亦即一个别名不能被多个变量同时使用

*d.不允许建立void类型的引用

*e.不能建立引用数组

*f.不能建立引用的引用，不能建立指向引用的指针

Int n = 3；

Int && r = n；//Error!

Int &* p = n；//Error!

*g.可以将引用的地址赋给一个指针，此时指针指向原来的变量

Int num = 50；

Int & ref = num；

Int * p = & ref；//*p = num           &在此为取地址运算符，而不是引用运算符

 

#引用的最大用处体现在函数返回值和形参上

 

 

 

函数声明的时候变量名可以省略，但是在函数体第一行中不能省略

 

 

 

 

 

 

 

第三章 类和对象

2014年6月25日19:37:29

 

类是一种数据类型，是抽象概念，而对象是自然实体

 

1.访问控制符：信息隐藏

public：类与外部接口，任何外部函数都可以访问共有类型数据和函数

private：只允许本类中的函数访问，二类外部的任何函数都不能访问

protected：与private相似，其差别表现在继承与派生时对派生类的影响不同

*访问控制符对当前类内部无效

 

 

 

2.成员函数的定义：

A.类内部，访问控制符下直接定义

B.类外部，在函数名前加上类名和域限定符（如：int Point ：： get()）

<::get()和get()都是普通函数>

此种情况下，在类中的声明可以不带形参变量名，但有要类型

在类外定义成员函数又称作 隐式内联声明

*以内联方式定义成员函数体（显式内联）

类中声明时，函数返回值前的inline关键字可以略去

但类外定义的函数体第一行前面的inline关键字不能省去

“较短的函数才适合内联函数，必须满足内联函数的使用前提”

 

 

 

3.类与结构体的区别：未指定访问权限时，class默认是私有的，而struct是公有的

结构体是一种特殊的类！

 

 

 

4.对象的定义和使用：

1》.定义方式：

A.全局对象定义：类似全局结构体

在类的定义之后，立刻定义对象，随后用分号封装类

如：

class Point{

……

}op1，op2；

op1 和op2就是全局定义的对象

B.声明类以后，在使用时定义对象，若在main函数以内，则为局部对象

Point op1，op2；

在没有重写构造函数的情况下，此种对象定义已经分配好堆空间，这是与Java中不同的地方

 

2》.访问方式：

A.对象名.数据成员名

  对象名.成员函数名[(实参表)]

  *其中“.”称作“简点运算符”

 

  op1 .get();  完全等价于  op1 .Point :: get();

 

B.指向标识符：类似结构体指针

  如：

Data  d，*p；定义了指向类Data的指针变量p

p = &d；//使指针p指向对象d

Cout << p ->year;            //输出p指向对象中的成员year

 

 

 

 

5.构造函数和析构函数：

1》.构造函数是特殊的成员函数

创建类类型的新对象，系统会自动调用构造函数

其存在意义是：保证对象的每个数据成员都能被正确的初始化

 

定义： 1、函数名与类名完全相同

2、不能定义构造函数的类型（返回值类型），即使是void

3、通常情况下构造函数为共公有函数（私有构造函数有特殊用途）

4、可以有任意类型和任意个数的参数，一个类可以有多个构造函数（重载），一个类至少有一个构造函数

 

**在建立对象的同时，采用构造函数给数据成员赋初值，通常有两种形式：

<