C++面向过程 期末复习 重点总结

 

• 位、字节、字符

 

1. 位（bit）：

数据存储的最小单位。每个二进制数字0或者1就是1个位；

一个数字一位

2、字节（B）：

8个位构成一个字节；即：1 byte (字节)= 8 bit(位)；

     1 KB = 1024 B(字节)；

     1 MB = 1024 KB;   (2^10 B)

     1 GB = 1024 MB;  (2^20 B)

     1 TB = 1024 GB;   (2^30 B)

 

3、ASCII码字符集

 

    （1）标准ASCII字符集：有96个打印字符，和32个控制字符组成；共96+32=128个；

 

     (2)用7位二进制数来对每1个字符进行编码；（2^7=128）

     而由于7位还还不够1个字节，而电脑的内部常用字节来用处理，每个字节中多出来的最高位用0替代；从0----127，来表示128个ACSii编码；

    

(3）扩展ASCII字符集： 256个字符；

 

• 程序结构

1. 声明不会分配内存，定义才会
2. 块作用域：

{

int a;

}

a的生命期在{ }内，在{ }外a无效。

1. 预定义的标识符不是关键字，可以用于用户标识符（main,define,stand,printf）,标识符的第一个字符必须为字母或者_
2. 隐式或显式的类型转换都不会改变操作对象本身的值。

 

 

 

 

• 数据类型和表示

 

1. 数据类型的取值范围？

(1)int: 4字节，最高位为符号位，有4*8-1=31位用来表示数，故不含符号可以表示2^31=2147483648个数，所以表示范围为0~2147483647。

包含符号，表示范围-2147483648~+2147483648

为什么负的比正的多1？与补码有关

(2)unsigned [int]: 没有符号，故一共可表示2^32=4294967296个数，所以范围为：0~4294967295.

 

2.各种数据类型：

int：4字节

short int：2字节

long int：4字节

long long int：8字节

char：1字节

float：4字节，6位有效数字；如不能表示1000.235（7位），只能表示1000.23（6位）

double：8字节，15位有效数字

bool：1字节，true/faulse

 

1. 进制：

1. 八进制：在常数开头加一个0，比如021表示八进制数21
2. 十六进制：在常数前加一个0X

1. 浮点数的表示：

1. 小数形式：如果在实数的后面加F或者f，表示这个数是float型；如果在实数后面加L或者l，表示这个数是double

省略写法：.46=0.46;  35.=35.0;

1. 指数形式：3.14159可写作：0.314159*10^1,在程序中表示为0.314159e1；

E后面表示10的几次方。

※e前e后必有数，e后必须为整数！

123e13√；

1.43e2.3×；

E4×

-.34e-2√

5、字符常量

（1）转义字符：

<1>  \t  水平制表符：\t是补全当前字符串长度到8的整数倍，最少1个最多8个空格，补多少要看你\t前字符串长度。比如当前字符串长度10，那么\t后长度是16，也就是补6个空格。如果当前字符串长度12，此时\t后长度是16，补4个空格；

 

<2> \r 回车

<3>\ddd：1-3位八进制数代表的字符,只能往后面读三个数字

\xhh：1-2位十六进制数所表示的字符，只能往后面读两个数字

<4>\x（十六进制）和\（八进制）不同的在于，在字符串中，\x读取后面的所有数字，而不是只有两位有效；\却只读取后面三位有效数字；

例如

输出结果：A、A、__

1. 字符串常量

所有的字符串常量都以’\0’结尾，故实际在内存中比字符串长度多一个字节

如:”abc”在内存中的实际占4个字节，存储为”a b c \0”

 cout<<sizeof(“abc”);

输出的结果为 4

 

1. 符号常量

#define PRICE 30;

表示在本程序中把30用一个符号常量PRICE表示；以后写PRICE就是表示30，而且PRICE表示的值不能通过赋值改变

但如果这时候写#define PRICE 35；就可以把所有的PRICE都改成35.

 

1. 静态变量 static

1. 静态局部变量：

函数内部定义的静态变量

static int m;静态变量在不初始化时自动初始化为0

作用域是函数内部

1. 静态全局变量：

全局变量定义在函数体外部，在全局数据区分配存储空间，且编译器会自动对其初始化=0。

普通全局变量对整个工程可见，其他文件可以使用extern外部声明后直接使用。也就是说其他文件不能再定义一个与其相同名字的变量了（否则编译器会认为它们是同一个变量）。

静态全局变量仅对当前文件可见，其他文件不可访问，其他文件可以定义与其同名的变量，两者互不影响。

在定义不需要与其他文件共享的全局变量时，加上static关键字能够有效地降低程序模块之间的耦合，避免不同文件同名变量的冲突，且不会误使用

1. 类中的静态变量：各个对象共用，要在类的外面再次声明；

 

 

• 一些运算符

 

1. 自增自减运算符：

i++表示本条语句结束后再把i加1

++i表示先把i加1再使用i

计算得b=10

 

1. 强制类型转换运算符

（double）（x+y）；表示把x+y的结果转换为double型

（double）x+y；表示先把x转换成double再与y相加

（float）(1/2)=0

 

 

1. 逗号运算符：

逗号运算符又称“顺序求值运算符”

3+5, 8+9

表示先求3+5，再求8+9

b=(a=3*5, a*4)

表示：a=3*5=15，b=整个括号内算完的值，b=15*4=60

b=(3*4,2*3);

结果：b=6

 

1. 逻辑运算符：

逻辑运算符的偷懒现象：

1. 如果&&之前已经出现0，则&&后表达式不执行。
2. 如果||前已经出现1，则||后表达式不执行。

 

1. 条件表达式：唯一一个三元运算符

(a):(b)?(c)

若a为真，就算b，若a为假，就算c

 

5、sizeof（）不会实际运算表达式，只是计算大小。例如sizeof（a++）计算之后a的值没有改变

 

 

• 枚举类型

（1）enum是关键字，标识枚举类型。定义枚举类型必须用enum开头。

（2）枚举型是一个集合，集合中的元素(枚举成员)是一些命名的整型常量，元素之间用逗号,隔开。

（3）枚举数据表的值都是整数。第一个枚举成员的默认值为整型的0，后续枚举成员的值在前一个成员上加1。也可以人为设定枚举成员的值，从而自定义某个范围内的整数。

（4）可以在定义类型时对枚举常量初始化。

（5）枚举类型可以进行比较。

（6）枚举常量不是字符串，不能用%s方式输出字符串。

（7）枚举型是预处理指令#define的替代

 

 

• 控制符

控制符的使用方法：

    标准库：#include<iomanip>

例如宽度设置符：

int a=10;

cout<<setw(4)<<a;

结果是 _ _ 1 0  (setw（）只对后面的第一个数据起作用)

 

 

• 指针的定义问题：

用变量a给出下面的定义

1. 一个指向指针的指针，它指向的指针是指向一个整型数

int **a;

1. 一个有10个指针的数组，每个指针指向一个整型数

 int *a[10];       解释：*a[10]  表示有十个指针

1. 一个指向含有10个整型元素的数组的指针

int (*a)[10];     解释：(*a)表示只有一个指针

1. 一个指向函数的指针，函数有一个int型的参数并返回一个整型

int (*a)(int)

 

 

 

• 输入输出函数：getchar()与putchar()

1. putchar（）：

putchar（a）；输出括号内的字符变量

2、getchar( ):

括号内不用写参数，a=getchar（）；表示从终端读取一个字符，赋值给a

 

 

• switch-case的使用

1、default必须放在最后吗？

答： 不是。 default就是在所有其他case都不满足条件的情况下执行，不论你放在哪个位置都可以被执行。

2、case后一定是常量

 

• 构造函数与析构函数

1、构造函数名与类名相同。

2、构造函数无函数返回类型说明。注意是什么也不写，也不可写void！

   拷贝构造函数的参数一定是对象的引用，不然会产生无限递归调用拷贝构造函数的情况。

3、构造函数初始化列表：

   

3、构造函数的调用：

例：

构造函数没有参数时，调用方法： tree t;（看起来就像只有申明对象，没有调用构造函数）

有参数时，调用：tree t(?,?);

1. 析构函数：~tree() {  }

先构造的后析构，后构造的先析构

 

 

• const

1. const定义常量：不可修改
2. const指针：

int* const p：指针本身是常量，指向固定的地址

const int* p：指向的内容不可变

const int* const p：都不可变

1. 函数中的const：

1. int fun( const int a )：a在函数中作为常量，不可改变
2. int fun( const Class& student )：引用的参数在函数内不可改变

1. 类中的const：

1. const修饰成员变量：只能在声明时就赋值，或者在初始化列表中赋值。
2. const修饰成员函数：void function() const; 不能改变对象成员变量，不能在此函数中调用非const的成员函数

 

八、运算符的重载：

1. 语法：见“复数类”

1. 运算符重载本质是函数的重载
2. 几个不允许：

（1）C++中不允许重载的运算符：成员访问运算符（.）、成员指针访问运算符（*）、域运算符（：：）、sizeof、条件运算符（？：）

        （2）不能改变运算符的优先级、运算对象的个数、结合性

        （3）重载运算符不能有默认的参数

 

• while（！i）：表示while（i==0）

 

 

 

• 继承与派生类

例子：

// 定义一个基类( person 类)

class person

{

private :

    char name [10] ;

    int age;

    char sex;

public:

// …

} ;

 

// 定义一个派生类

class employee∶public person

{

    char department[20] ;

    float salary;

public:

    // …

} ;

 

继承方式：

（1）无论哪种派生方式, 基类中的私有成员既不允许外部函数访问, 也不允许派生类中的成员函数访问,但是可以通过基类提供的公有成员函数访问。

（2）公有派生与私有派生的不同点在于基类中的公有成员在派生类中的访问属性。

·公有派生时, 基类中的所有公有成员在派生类中也都是公有的。

·私有派生时, 基类中的所有公有成员只能成为派生类中的私有成员。