C++复习

最新推荐文章于 2021-10-29 17:23:49 发布

原创最新推荐文章于 2021-10-29 17:23:49 发布 · 316 阅读

0 ·

CC 4.0 BY-SA版权

C/C++ 专栏收录该内容

15 篇文章

订阅专栏

第0讲面向对象技术概述

面向对象程序的特点

1、开发时间短，效率高，可靠性高，所开发的程序更强壮

2、重用，共享，可维护性，精简

3、适合于大程序长时间的开发工作

面向对象程序设计是一种以对象为基础，以事件或消息来驱动对象执行处理的程序设计技术。

OOP的四个基本特征

抽象：对具体对象(问题)进行概括，抽出这一类对象的公共性质并加以描述的过程。（数据抽象&&代码抽象）

封装：将抽象出的数据及方法结合为一个整体的信息隐蔽技术。

继承：对具有层次关系的类的数据和操作进行共享的一种方式。

多态：不同的对象接受同一消息时产生不同的行动的现象。（重载函数和虚函数）

消息（Message）是描述事件发生的信息，它是对象之间发出的行为请求。

第一二讲 C++基础

1、C++变量存储类型

<存储类型> <变量类型> <变量列表>

auto存储类

Ø属于一时性存储，其存储空间可以被若干变量多次覆盖使用。

register存储类

Ø存放在通用寄存器中。

extern存储类

Ø在所有函数(该.c文件外)和程序段中都可引用。

static存储类

Ø在内存中是以固定地址存放的，在整个程序运行期间都有效。

2、位运算--移位

1、左移运算（<<）

左移后，低位补0，高位舍弃。

2、右移运算（>>）

右移后，低位：舍弃
高位：无符号数：补0

有符号数：补“符号位”

3、枚举类型

只要将需要的变量值一一列举出来，便构成了一个枚举类型。

枚举类型的声明形式如下：

enum 枚举类型名 {变量值列表};

例如：

enum weekday {sun, mon, tue, wed, thu, fri, sat};

注意！sun没有引号

4、常量指针

const 它限定一个变量不允许被改变，产生静态作用。

常量： const int Number = 1

指向常量的指针：不能通过指针来改变所指对象的值，但指针本身可以改变，可以指向另外的对象。

例：

int n1=3;

int const n2=5;

const int *pn= &n1;

pn=&n2; //正确

*pn=6; //错误

若声明指针常量，则指针本身的值不能被改变。例：

int n1=3;

int const n2=5;

int *const pn= &n1;

pn=&n2; //错误

*pn=6; //正确

5、动态内存分配

c_point = new char[37]; //动态分配数组

delete [ ] c_point; //释放数组

6、整行输入字符串

cin.getline(字符数组名St, 字符个数N, 结束符);

7、字符串处理函数

strcat（连接），strcpy（复制），
strcmp（比较），strlen（求长度），
strlwr(转换为小写），
strupr（转换为大写）

头文件<string.h>

第三讲类与对象

1、private是缺省权限

2、protected与private类似，其差别表现在继承与派生时对派生类的影响不同，只允许本类中的函数访问，而类外部的任何函数都不能访问。

3、内联成员函数：

在类中声明内联成员函数的方式：

Ø将函数体放在类的声明中（隐式调用）

Ø使用inline关键字，声明和实现都需要加上inline函数（显式调用）

4、构造函数与类名同名，且不能指定返回值类型，允许重构

5、拷贝构造函数是一种特殊的构造函数，其形参为本类的对象引用。作用：使用一个对象（参数指定的对象），去初始化一个正在被建立的同类型对象

class 类名

{

public :

类名（形参）；//构造函数

类名（类名 & 对象名）；//拷贝构造函数

...

}；

6、拷贝构造函数调用的三个情况

用类的一个对象去初始化该类的另一个对象时系统自动调用它实现拷贝赋值
函数的形参为类对象，调用函数时，实参赋值给形参，系统自动调用拷贝构造函数
函数的返回值是类对象时，系统自动调用拷贝构造函数

！注意！函数形参为类对象的引用或指针，不会调用拷贝构造函数

7、析构函数

1、析构函数没有返回值，没有重载函数，有且只有一个

2、且必须是public访问权限

3、不能随意调用，只有在类对象的生命周期结束的时候由系统自动调用。

8、类的静态成员static

1、某个类的所有对象为静态成员分配一个共享存储空间。

2、使用全局变量会不安全

3、不管定义多少个对象，这个静态成员只有一个实例

4、静态成员必须初始化

5、调用公有静态成员时，可采用如下格式之一：

Ø<类名>::<静态成员>

Ø对象.<静态成员>

Ø 对象指针->静态成员

6、静态成员函数可以直接访问该类的静态数据和静态函数成员，但不能随意访问类的非静态数据成员

9、友元

1、不改变其访问权限，但是又需要类外的函数直接访问其类的私有数据或其他数据

2、u友元函数和友元类在被访问的类中声明，其格式分别如下：

friend <返回值类型> <函数名>(<参数表>);

friend <类名>;

10、this指针

1、静态成员不能访问this指针

第四讲继承与派生

1、继承方式：

不同继承方式的影响主要体现在：

1、派生类成员对基类成员的访问控制。（派生类内部）

2、派生类对象对基类成员的访问控制。（派生类外部）

2、公有继承

原有类型保持不变，派生类成员不能访问private，派生对象只能访问public成员（类对象本来就不能访问protected成员）

3、私有继承（private）

public和protected变成private，基类private成员不可访问，成员函数可以访问public和protected成员，通过派生类的对象不能访问基类中的任何成员。

4、保护继承

基类的public和protected成员都以protected身份出现在派生类中，基类的private成员不可访问，派生类中的成员函数可以直接访问基类中的public和protected成员，但不能访问基类的private成员。通过派生类的对象不能访问基类中的任何成员。

5、保护成员特点

对建立其所在类对象的模块来说（水平访问时），它与 private 成员的性质相同。
对于其派生类来说（垂直访问时），它与 public 成员的性质相同。
既实现了数据隐藏，又方便继承，实现代码重用。

6、构造函数调用次序

1．调用基类构造函数，调用顺序按照它们被继承时声明的顺序（从左向右）。

2．调用成员对象的构造函数，调用顺序按照它们在类中声明的顺序。

3．派生类的构造函数体中的内容。

7、虚继承

解决多继承时候的成员二义性

B1,B2继承于B，同时C继承与B1,B2，这时候，需要在B1,B2继承于B时，都加上虚继承

class B1 : virtual public B

{

private:

int k1;

};

而C中无需加入关键字virtual

构造顺序：

步骤：先根据继承声明顺序将所有虚基类排序；其次构造这些虚基类；最后按继承声明顺序构造非虚基类。

！虚继承B只会构造一次，但是假如没有申明是虚继承，会构造多次

8、赋值兼容原则

一个公有派生类的对象在使用上可以被当作基类的对象，反之则禁止。具体表现在：

Ø派生类的对象可以被赋值给基类对象。

Ø派生类的对象可以初始化基类的引用。

Ø指向基类的指针也可以指向派生类。

第五讲虚函数与多态性

1、虚函数

虚函数是动态联编的基础
是非静态成员函数
在类的声明中，在函数原型之前写virtual
virtual 只用来说明类声明中的原型，不能用在函数实现时
虚函数具有继承性，基类中声明了虚函数，派生类中无论是否说明，同原型函数都自动为虚函数
调用方式：通过基类指针或引用，执行时会根据指针指向的对象的类，决定调用哪个函数

#include <iostream.h>
class B0	//基类B0声明
{
public:	//外部接口
	virtual void display（ ）
     {cout<<"B0::display（ ）"<<endl;}
                                         //虚成员函数
};

class B1: public B0	//公有派生
{ public:
	  void display（ ）
     {  cout<<"B1::display（ ）"<<endl;  }
};

class D1: public B1	//公有派生
{ public:
	  void display（ ）
     {  cout<<"D1::display（ ）"<<endl;  }
};

void fun(B0 *ptr)	//普通函数
{    ptr->display（ ）;    }

void main（ ）	//主函数
{	B0 b0,  *p;	//声明基类对象和指针
	B1 b1;	//声明派生类对象
	D1 d1;	//声明派生类对象
	p=&b0;
	fun(p);	//调用基类B0函数成员
	p=&b1;
	fun(p);	//调用派生类B1函数成员
	p=&d1;
	fun(p);	//调用派生类D1函数成员
}

程序的运行结果为：

B0::display（ ）
B1::display（ ）
D1::display（ ）

2、联编

u 静态联编（静态束定）

Ø联编工作出现在编译阶段，用对象名或者类名来限定要调用的函数。

u 动态联编

Ø联编工作在程序运行时执行，在程序运行时才确定将要调用的函数。

3、纯虚函数

纯虚函数的形式：

class  类名
 {
     virtual 类型 函数名(参数表)=0; 
                                          //纯虚函数
     ...
};

带有纯虚函数的类称为抽象类

对于暂时无法实现的函数，可以声明为纯虚函数，留给派生类去实现。

抽象类只能作为基类使用，不能声明抽象类的对象。

构造函数不能是虚函数，析构函数可以是虚函数

4、运算符重载

函数类型  operator 运算符（形参）
{
       ......
}

重载为类成员函数时，参数个数=原操作数个数-1，（后置++、--除外）

重载为友元函数时参数个数=原操作数个数，且至少应该有一个自定义类型的形参。

Complex Complex::operator + (Complex c){ // 复数加法
	Complex t;
	t.Real = Real + c.Real;
	t.Image = Image + c.Image;
	return t;
}


class Complex {
public:
	Complex operator ++ ( );    //前置自增运算
	Complex operator ++ (int); //后置自增运算
    ……其他详见前例
};

第六章流与异常处理

1、常见函数

cout.width(10);
cout.fill(‘*’);    //用*填充
cout << values[i]<< '\n';   

//指定宽度 
cout << setw(6) << names[i] << setw(10) << values[i] << endl;

2、进制

dec、oct和hex操纵符设置输入和输出的缺省进制。

Øcout<<"hex:"<<hex<<i<<endl;

Øcout<<"oct:"<<oct<<i<<endl;

Øcout<<"dec:"<<dec<<i<<endl;