C++期末复习

Chapter1

1. 对象就是可以控制和操作的实体。在现实世界中，任何事物都是对象。C++中 对象是描述其属性的数据以及对这些数据施加的一组操作封装在一起构成的统一体。用数据来体现属性，用函数来实现对数据的操作，以实现某些功能。
2. 在现实世界中，类是对一组具有共同的属性和行为的对象的抽象。类和对象的关系是抽象和具体的关系

类是对多个对象进行抽象的结果

一个对象是类的一个实例

1. 对象之间的联系称为对象的交互   一个对象向另一个对象发出的请求被称为消息
2. 对象发消息可一对多、多对一  相同消息可给不同对象，同一对象可接受不同消息  对象可响应消息，也可不响应
3. 方法->成员函数
4. 抽象的过程是将有关事务的共性归纳、集中的过程
5. 封装是指把数据和实现操作的代码集中起来放在对象内部，并尽可能隐蔽对象的内部细节（各个对象相互独立，互不干扰；对外隐蔽）
6. 继承关系可以使后者继承前者的基本特性，又可以增加一些新的特性（若类之间有继承关系，则：a.类间具有共享特性b.类间有差别或新增部分c.类间具有层次结构）（避免共用代码的重复开发；通过增强一致性来减少模块间的接口和界面）
7. 多态性是指不同的对象收到相同的消息时，执行不同的操作

编译时多态性：函数重载，运算符重载

运行时多态性：虚函数

Chapter2

1. const int LIMIT=100;

const char*name=”chen”;(可以指向另一个常量，但常量不能修改)

char *const name=”chen”;(指的位置固定，但内容可以修改)

const char *const name=”chen”(包含以上两条)

函数的形参也可以用const说明，形参在函数内部不被改动，在函数中参数只许读，不许写

1. 内置函数（函数前+inline）消除了#define（只做简单的字符置换）的不安全因素
2. 函数原型

返回类型 函数名（参数表）; void write(char *s){……}

使用在前，定义在后，要先声明；定义在前，使用在后，不必声明

1. 正在上传…重新上传取消

1. 函数重载

1. 应在参数个数或参数类型上有所不同，而不是返回类型
2. Void draw(int r=0;int x=0;int y=0);

Void draw(int r)

调用draw(20)  程序无法确定用哪个函数

1. :: 作用域运算符

Eg ::a=10 对被屏蔽的同名全局变量进行访问

1. 强制类型转换

float x=float(i);   float x=(float)i;

1. new delete

eg: int *p=new int;

   *p=10;

       delete p;

Eg:int *pi=new int[10]/[2][3][4]/[r*c];

  delete []pi;

1. 引用

int i； int &j=i;  i和j的地址相同，二者变化相同

1. 定义引用应立即初始化（int i； int &j; j=i;错误）
2. 引用可以初始化另一个引用
3. 不存在引用数组，二级引用，引用指针
4. int *p=&i;指针） int &p=i;引用）
5. 函数可返回一个引用，就可将函数写在赋值运算符的左边eg：int &index(int);//声明

index(2)=25;

        (6)

正在上传…重新上传取消

1. void指针是通用型指针，可指任何类型

Chapter3

1. class 类名{   };
2. 成员函数定义：（返回类型要与函数原型中声明的返回类型匹配）

类外定义：   返回类型 类名::函数名（参数表）

                             {    函数体     }

类内定义：  隐式定义：函数的原型与定义都在类的内部完成

显式定义：类内只给成员函数原型，类外定义，但在定义前需要冠以关键字 inline

1. 对象的定义  ○声明类的同时，直接定义对象——全局对象，生存期内任何函数都能使用class point{   }op1,op2;

○声明类之后，在使用时再定义对象

point  op1, op2;

1. 对象中成员的访问

对象名.数据成员名    对象名.成员函数名（实参表）

若是对象指针，则用->

point *p;   op->setpoint(5,6); i=op->getx(); j=op->gety();

1. 构造函数（给数据成员赋值）

1. 其名必须与类名相同
2. 不能有返回类型
3. 构造函数也是成员函数
4. 定义构造函数时，可以不带参数
5. 构造函数也可重载
6. 带默认参数的构造函数（类内有默认值后，类外定义可以不再指定；同时有无参数的构造函数和带默认参数的构造函数时，重载可能产生二义性）

1. 创建对象两种方法

1. 构造函数  类名 对象名（实参表）complex A(1.1,2.2);
2. new动态分配 类名 *对象指针=new 类名（实参表）

            complex *A=new complex(1.1,2.2)

1. 初始化列表对数据成员初始化

正在上传…重新上传取消

1. 析构函数(没有参数，也没有返回值，而且不能重载一个类中只能有一个析构函数)
2. 对象数组和对象指针

1. 指针引用单个对象成员

exe ob,*p;  ob.set_a(2); p=&ob; p->show_a()

1. 对象指针引用对象数组

exe ob[2],*p; ob[0].set_a(1); ob[1].set_a(2); p=ob

p->show_a(); p++;//移动指针，指向ob[1]  p->show_a();

1. this指针

当一个成员函数被调用的时候，C++自动产生一个参数，这个参数是一个类指针this，可以指向该类的一个对象，这个对象就是接收函数调用的对象。

1. 向函数传递对象

1. 对象作为函数的参数

正在上传…重新上传取消

1. 对象指针作为函数的参数

正在上传…重新上传取消

1. 对象引用作为函数的参数

正在上传…重新上传取消

1. 对象赋值语句

同类型对象可以赋值。赋值时，数据成员逐位复制

myclass o1,o2;  o1.set(20);  o2=o1;//另一种方式：o2(o1)

1. 拷贝构造函数

类名（const 类名 &对象名）{ 函数体  }

1. string 类

正在上传…重新上传取消

1. 静态成员   前面冠以关键字 static

1. 静态数据成员：一个类无论定义多少个对象，都共用一个静态数据成员。

a.访问方式：类名::静态数据成员名

b.必须类外初始化（main函数前）：

数据类型 类名::静态数据成员名=初始值

c.也可通过对象进行访问  

对象名.静态数据成员名or对象指针->静态数据成员名

d.私有静态数据成员不能类外函数或对象访问

      （2）   静态成员函数

                    a.类外定义时，不要用static

                    b. 静态成员函数没有 this 指针，只能访问静态成员（包括静态成员变量和静态成员函数）

                    c.调用格式：类名::静态成员函数名

16. 类组合

class X{ 类名1 对象1;类名2 对象2；………};

类组合的构造函数可以用初始化表

X::X(参数0)：对象1（参数表1），对象2（参数表2）{ 构造函数体 }

17.友元函数可通过对象、对象引用、对象指针来访问本类的私有成员

外部定义友元函数时，不必加  类名：：

友元成员函数 类1的成员函数又是类2的友元函数           能访问类1、2的私有成员

友元类  类1定义时类内说明类2，冠以关键字 friend则类2是类1的友元类

18.常类型 常类型变量不可改变

  常引用  const 类型&引用名;

  常数据成员 const int i；初始化只能通过初始化表

chapter4

1. 派生类的声明：class 派生类名：继承方式 基类名{     };
2. 正在上传…重新上传取消

正在上传…重新上传取消

1. 创建派生类对象时，先执行基类的构造函数，在执行派生类的构造函数；撤销派生类对象时，先执行派生类析构函数，再执行基类的析构函数。

派生类名（参数总表）：基类名（参数表1），内嵌对象名1（内嵌对象参数表1），…，内嵌对象名n（内嵌对象参数表n）

{         //派生类新增成员的初始化数据     }

1. 正在上传…重新上传取消

正在上传…重新上传取消

正在上传…重新上传取消

正在上传…重新上传取消

1. 派生类同名成员会覆盖基类同名成员

可用  基类名：：f（）； 来分辨

1. 多重继承

class派生类名：派生方式1 基类名1，…，派生方式n 基类名n{ }；

1. 派生类名(参数总表):基类名1(参数表1),基类名2(参数表2),.....,基 类名n(参数表n)

{

//派生类新增成员的初始化语句...

}

构造函数调用顺序:从左往右。最后是派生类

  析构函数调用顺序则反过来。

1. 虚基类

class 派生类名：virtual 继承方式 基类名{   //………   }

a.同一个虚基类构造函数只调用一次，且只在第一次出现时调用

b.如果在虚基类中定义有带形参的构造函数,并且没有定义默认形式的构造函数,则整个继承结构中,所有直接或间接的派生类都必须在构造函数的成员初始化表中列出对虚基类构造函数的调用。

正在上传…重新上传取消

1. 赋值兼容 在需要基类对象的地方，都可以用公有派生类对象替代

正在上传…重新上传取消

chapter5

1. 运算符的重载

operator @（） @为运算符 可以返回任何类型

不能重载的运算符 .  ::  ?:

（1）类外函数complex operator+(complex o1,complex o2){  }

………

total1=operator+(com1,com2);//调用重载运算符的第一种方式

total2=com1+com2；//调用重载运算符的第二种方式

1. 友元函数

类内声明：class X{ friend 返回类型 operator@（参数表）}；

类外定义：返回类型 operator @（参数表）{ 函数体 }

双目运算符（+ -）参数有两个

单目运算符（++ --）参数有一个 friend X operator++（X &obj）

1. 成员函数

类内声明：class X{返回类型 operator@（形参表）；}

类外定义：返回类型 X：：operator@（形参表）{函数体}

双目运算符 参数表只有一个操作数（右操作数），左操作数为隐含的当前对象

单目运算符 不需要操作数，当前对象为操作数

1. 一般而言，双目运算符采用友元函数重载，单目运算符采用成员函数重载。如果操作数（特别是左操作数为对象）有类型转换时，必须用友元函数来实现重载

调用形式 a+b   operator+(a,b)  a.operator+(b)

         ++a   operator++(&a)  a.operator++()

(5)    对于单目运算符，建议选择成员函数;

对于运算符“=、( )、[ ]、->”只能作为成员函数;

对于运算符“+=、-=、/=、*=、&=、!=、~=、%=、>>=、 <<=”，建议重载为成员函数;

对于其他运算符，建议重载为友元函数。

1. 赋值运算符“=”重载

X & X::operator=(const X &source) { 成员间赋值 }

对象赋值直接调用 obj2=obj1；

若涉及到动态分配内存，可能出现指针悬挂问题 可采用深层复制来解决

1. 类型转换

隐式类型转换：

在赋值A=B时，B的值需转换为A类型后再进行赋值。

当char或short类型变量与int类型变量进行运算时，将 char或short类型转换成int 类型。

当两个操作对象类型不一致时，在算术运算前，级别低的自动转换为级别高的类型

显式类型转换：见chapter2.7

1. 类型转换函数

只能用成员函数不能用友元函数；没有参数，也不显示给出返回类型；函数体内必须return返回目的类型的一个数据

class 源类类名{ operator 目的类型（）{  return目的类型的数据 }     };

使用类型转换函数：X obj； int（obj）；

1. 虚函数 （成员函数）

virtual 函数类型 函数名（形参表） {  函数体  }

虚函数要求函数名、返回类型、参数个数、参数类型和顺序与基类中的虚函数原型完全相同

chapter6

1. 函数重载:同一个名字定义不同的函数，这些函数功能不

同，执行不同的操作。

函数模板:同一个名字定义不同的函数，这些函数功能相

同，而参数类型和返回类型不同。

1. 函数模板声名格式

template<class 类型参数>

返回类型 函数名（模板形参表）{ 函数体 }

eg:  template<class T>或template<typename T>

T max(T x, T y){ return(x>y)?x:y;}

1. 函数模板中允许使用多个类型参数，但template定义部分的每个模板形参前必须有关键字class/typename  template<class t1,calss t2>
2. 类模板  

template<class 类型参数>

class 类名{   }

类外定义：template<class T>

X<T>::X(T x1,T x2){  }

template<class T>

T X<T>::max(){  }

类模板定义对象   类名<实际类型名(int)>对象名（实参表）

1. 堆栈类模板stack 可以存放字符型和整形数据