期末复习笔记（大一下）

 主要本人期末复习使用，朋友们可以参考。

目录

cpp-09 

cpp-10

cpp-11

cpp-12 继承

cpp-13 多态

cpp-14 文件处理

cpp-17 异常处理 

cpp-15 STL

cpp-18 类模板

cpp-09 

•  预处理器封装 

#ifndef A_H
#define A_H
class A{ int a;}
#endif

• sizeof（类对象）

sizeof的结果将大于等于类中数据成员的大小

an object name (对象名): 点操作符

a reference to an object (对象引用): 点操作符

a pointer to an object (对象指针): 箭头操作符

• 缺省构造函数

不带参数的构造函数 或所有参数都有默认值的构造函数

•  函数重载

C++允许函数同名，但要求参数不同（数量、类型、顺序）。

Class A
{  int x, y;
  public:
    A( )
    { x=y=0; } 
    A( int x1 )
    {x=x1;y=0;}
    A( int x1,int y1 )
    {x=x1;y=y1;}
}

• 析构函数自动调用的两种情况

（1）如果一个对象被定义在一个函数体内，则当这个函数结束时，该对象的析构函数被自动调用；

（2）当一个对象是使用new运算符被动态创建的，在使用delete运算符释放它时，delete将会自动调用析构函数

• 各类对象的生存周期

全局对象 ：在任何函数 ( 含 main) 执行前，构造；在程序结束时，析构 . 局部对象 ： 自动变量：对象定义时，构造；块结束时，析构 .                   静态变量： 首次定义时，构造？ ；程序结束时，析构 .

 

•  默认实参必须是函数参数列表中右端（尾部）的参数，即如果某个参数设定了默认实参，那么该参数右边的所有参数都必须具有默认实参！

// OK
int boxVolume( int length = 1, int width = 1, int height = 1 );
int boxVolume( int length, int width = 1, int height = 1 );
int boxVolume( int length, int width, int height = 1 );
// ERROR
int boxVolume( int length = 1, int width, int height = 1 );
int boxVolume( int length, int width=1, int height );
// ERROR: missing default parameter for parameter x

• 显式传递给函数的实参是从左至右给形参赋值

int boxVolume( int length=1, int width=1,int height=1 );
boxVolume();           // length=1, width=1, height=1 
boxVolume(10);       // length=10, width=1, height=1
boxVolume(10,5);    // length=10, width=5, height=1
boxVolume(10,5,2); // length=10, width=5, height=2

cpp-10

•  常成员函数(两处都要声明)

prototype:

  void printUniversal() const;

definition:

  void Time::printUniversal() const { … }

要求 : 不能修改 本对象的数据成员 不能调用本对象其它 non-const 成员函数

class Time 
{
public:
   Time( int = 0, int = 0, int = 0 ); 
   void setTime( int, int, int ); 
   void setHour( int ); 
   void setMinute( int ); 
   void setSecond( int ); 
   int getHour() const; 
   int getMinute() const; 
   int getSecond() const; 
   void printUniversal() const; 
   void printStandard(); 
private:
   int hour; int minute; int second; 
}; 
void Time::test(Time &another) const
{
	minute = 20; 
	// 不能修改object
	printStandard();
	// 不能调用non-const成员函数
	another.minute = 20;
	// OK，非同一object
	another.setHour(6);
	// OK
}

• 所有的类成员都可以用构造函数初始化列表进行初始化，而以下情况只能如此：

const data member ( 例外 ?const static integer) reference data member 引用类型的数据成员 member objects, 数据成员是其他类 ( 未提供缺省构造函数 ) 的对象* 继承类的基类 base class * 若无缺省构造函数，则必须使用初始化列表 若有缺省构造函数，此时如果成员对象没有显式通过成员初始化列表中初始化，则自动隐含调用缺省构造函数 (default constructor). 

class Test{
public:
    Test( int a ){ num = a;
     cout<

10 20 

class Test{
public:
    Test( int a=0 ){ num = a;
    cout<

0 20 

•  友元函数

函数声明 ：在类里 函数定义 ：在类作用域外面 可以访问类的 私有和保护成员 尽管类定义中有友元函数原型， 友元函数仍然不是成员函数 由于友元函数不是任何类的成员函数，所以 不能用句柄 ( 对象 ) 加点操作符来调用 友元关系不满足对称性和传递性 如果 class A 是 class B 的友元类，并不代表 class B 是 class A 的友元类 如果 class A 是 class B 的友元类， class B 是 class C 的友元类，不能推导出 class A 是 class C 的友元类

 .运算符比*运算符优先级高

•  函数的级联调用：
   

class Time 
{
public:
   Time( int = 0, int = 0, int = 0 ); 
   Time &setTime( int, int, int ); 
   Time &setHour( int ); 
  Time &setMinute( int ); 
   Time &setSecond( int ); 
   void print() const;

private:
   int hour;
   int minute; 
   int second;
}; 
class Time2 
{
public:
   Time2( int = 0, int = 0, int = 0 ); 
   Time2 setTime( int, int, int ); 
   Time2 setHour( int ); 
   Time2 setMinute( int );
   Time2 setSecond( int );
   void print() const;
private:
   int hour; 
   int minute; 
   int second; 
}; 

 t.setHour( 18 ).setMinute( 30 ).setSecond( 22 );

t.setMinute( 30 ).setSecond( 22 ); t.setSecond( 22 );

•  传引用或传拷贝对比：

 

•  动态数组

int size = 10;
int *grades = new int[size];
delete [ ] gradesArray;

对象的指针数组 

Time ** timePtr = new Time*[5];
for (int i =0; i<5; i++) timePtr[i] = new Time();
for (int i =0; i<5; i++) delete timePtr[i];
delete [] timePtr;

•  类的const类型成员

① 类定义中不能进行初始化，因为头文件中类的定义只是一个声明，并没有分配真正空间，因此变量是不存在的，因此是不能赋值的。 ② const 定义的变量必须赋值 ③ 解决办法： 在构造函数后的参数初始化列表中初始化

 类的static类型成员

① 采用静态数据成员来实现 同一个类的对象共享数据 ② 静态数据的成员 必须要在类的外部 给出它的定义，定义时可以初始化，在类内部声明

cpp-11

• 运算符重载：

定义重载的运算符(可视为特殊函数)就像定义函数(全局/成员)，区别是该函数的名称是

  operator@

  其中operator是关键词，@是被重载的运算符，如：

  HugeInt operator+(const HugeInt& a);

举例

• 流输入输出的重载稍微不太一样

friend ostream& operator<<(ostream&, const HugeInt&);

ostream& operator<<(ostream& cout, const HugeInt& x)
{
    int i = 0;
    for (; i <= 29; i++)
    {
        if (x.integer[i] != 0)
            break;
    }
    if (i == 30)
        cout << "0";
    for (; i <= 29; i++)
    {
        cout << x.integer[i];
    }
    return cout;
}

HugeInt operator=(const HugeInt&);

HugeInt operator+(const HugeInt&) const;

HugeInt HugeInt::operator=(const HugeInt& x) 

{
}
HugeInt HugeInt::operator+(const HugeInt& x) const
{
}

• 有动态数据成员时，必须自定义拷贝构造函数(深拷贝)和析构函数 

d1传给函数里的d一次
Date d2=d 第二次
return d2第三次 

• 转换构造函数

单实参 的构造函数，用于将其他类型的对象 ( 包括基本数据类型 ) 转换为当前类的对象 任何单参数构造函数都可看做是转换构造函数 目的：使编译器 自动 执行类型转化！（ 隐式调用 ）

• strcpy（)

char * strcpy(char *dst,const char *src)   
{
    if((dst==NULL)||(src==NULL))
         
           return NULL; 
 
    char *ret = dst; //[1]
 
    while ((*dst++=*src++)!=''); //[2]
 
    return ret;//[3]
}

关于空3：

由strcpy代码可知，实际上的代码复制，是把开始传入的指针作为起点

cpp-12 继承

见C++ 类继承的简单例子与理解

cpp-13 多态

见C++ 银行账户的多态继承层次结构

派生类virtual可省略。只要基类声明函数为虚函数，则所有派生类的该函数均为虚函数

基  类
	class Shape{
	public:
		virtual void draw() const;
	};
派生类
	class Rectangle : public Shape{
		void draw() const; 
	};

 

 只有通过引用或指针来访问对象的虚函数时才进行动态绑定。

通过引用或指针访问对象的非虚成员函数，采用静态绑定。（与句柄类型的成员函数代码绑定）

通过“类名+::”访问对象成员函数，也采用静态绑定。

cpp-14 文件处理

见C++ 文件处理的简单应用（模拟从各种客户端访问一个网站）

C++ 学籍管理系统的简单实现 

•  创建ofstream对象

构造函数 ofstream (const char* filename,int mode) filename ：文件名由文件的主名和扩展名两部分组成 。 mode ： ios ::out ：缺省模式 ， 覆盖文件中已有数据 ios ::app ： 向文件末尾添加数据 例： ofstream outClientFile ( "clients.dat", ios ::out ); 建立了一个到文件的“通信通道” 如果该文件名不存在，则新建一个同名文件

 对于已创建的文件对象，使用成员函数打开文件

与构造函数的参数相同，可以先创建再打开 例： ofstream outClientFile ； outClientFile .open ("clients.dat“, ios ::out);

 in ：(从文件读取) 打开方式只要含in，如文件不存在则返回失败。在打开为输入输出方式时（同时用out），编程应注意判断是否失败，失败时千万不可再写入文件。

out： (写入文件) 如文件不存在，则建立新文件，如文件存在，如果同时未设定app, in，则文件清空。

fstream iofile；//既输入又输出用

iofile.open(“myfile.txt”,ios::in|ios::out);

•  判断打开文件是否成功

打开文件时应该判断是否成功，若成功，文件流对象值为非零值，不成功为0（NULL），文件流对象值就是指它的地址。

//打开一个文件完整的程序
int main()
{
  fstream iofile(”myfile.txt”,ios::in|ios::out);
  if(!iofile)  {  //“！”为重载的运算符
      cout<<”不能打开文件:”<<”myfile,txt”< 
文件的打开与关闭
打开：
 
使用文件流对象的成员函数打开一个磁盘文件。
 
iofile.open(“myfile.txt”,ios::in|ios::out);
 
也可直接通过构造函数打开文件：
 
fstream iofile(”myfile.txt”,ios::in|ios::out);
 
关闭：
 
三个文件流类各有一个关闭文件的成员函数 :
 

 void 
 ifstream
 ::close();
 

 void 
 ofstream
 ::close();
 

 void 
 fstream
 ::close();
 
使用很方便，如：iofile.close();
 
cpp-17 异常处理  
异常处理模板：
解决思路：C++提供了一些内置的语言特性来抛出（throw）异常，用以通知“异常已经发生”，然后由预先安排的程序段来捕获（catch）异常，并对它进行处理。
 
//抛掷异常的程序段

......
throw    表达式;
......
//捕获并处理异常的程序段
try
   {复合语句}
catch（异常类型声明1）
    {复合语句}
catch（异常类型声明2）
    {复合语句}
    …
 
头文件：#include  
易错
 

 try
 与
 catch
 间不能添加其他代码
 

 一个
 catch
 处理器只能有一个参数
 

 在
 try
 语句后两个不同
 catch
 处理器中捕获相同异常类型
 ——
 错误！
 

 通过引用捕获异常对象，能够去除表示抛出的异常对象的复制开销
 
 
 虚函数中的异常指定：
  派生类的虚函数的异常指定必须与基类虚函数的异常一样或更严格。因为当派生类的虚函数被指向基类类型的指针调用时，保证不会违背基类成员函数的异常规范。
 
class CBase{
public:
  virtual int fun1(int)  throw();
  virtual int fun2(int)  throw(int);
  virtual string fun3()   throw(int,string);};
class CDerived:public CBase{
public:
  int fun1(int)  throw(int);
  //错！异常规范不如throw()严格
  int fun2(int)  throw(int);  //对！有相同的异常规范
  string fun3()  throw(string); }
  //对！异常规范比  throw(int,string)更严格
 
cpp-15 STL 
cpp-18 类模板 
见 自定义类模板的简单实践
 
     template <类型形参表>
　  返回值类型 函数名(形参表)
 
　　{
 
　　//函数定义体
 
　　}
 
 
<类型形参表>可以有一到若干个类型形参，各形参前需要加上typename/class关键字，表示传递类型，当有多个形参时，各形参间用逗号分隔。
 
<类型形参表>中的每个形参表示一种数据类型。函数模板“形参表”中至少有一个形参的类型必须用<类型形参表>中的形参来定义。
 
函数模板只是说明，不能直接执行，需要特化为模板函数后才能执行。  
 
函数模板重载

 允许有其它同名的函数模板，但参数不同
 

 允许有其它同名的函数，但参数不同
 

 编译器挑选最佳匹配的函数或模板
 

 编译器通过匹配过程确定调用哪个函数。
 

 首先，
 编译器寻找和使用最符合函数名和参数类型的函数调用。
 如果找不到
 ，则检查是否可以用函数模板产生符合函数名和参数类型的模板函数。
 

 如果有
 多个函数和调用函数相匹配（且匹配程度相同）
 ，编译器会认为有二义性，将产生编译错误
 

 如果没有找到符合函数，将考虑调用强制类型转换
 
#include 
using namespace std;

template 
void print (const T &a, int b) {cout << "first function called!"<< endl;}

template 
void print (const T &a, T1 b) {cout << "second function called!";}

template 
void print (const T &a, int c, T1 b) {cout << " third function called!";}

template 
void print (const T &a, T1 b, int c) {cout << “fourth function called!";}

void print (int a, int b) {cout << " fifth function called!"<< endl;}

void print (int a ) {cout << “sixthfunction called!"<< endl;}

print(1,2);  print(1.1, 2); 
 
类模板定义：

 1
 、
 类模板通过允许将泛型类实例化为明确类型的类来实现软件复用
 

 2
 、类是对问题空间的抽象，而类模板则是对类的抽象，即更高层次上的抽象。
 

 3
 、程序中可以首先定义一个类模板，然后通过使用不同的实参生成不同的类。
 

 4
 、类模板的定义格式：
 
template > //模板声明
 
class <类名>  // 类定义
 
{
 
  ……
 
};
 
 
 
每个“类型形参”前必须加typename or class关键字，对类模板进行实例化时，代表某种数据类型；也可以是普通数据类型形参，实例化时代表具体数据
 
 
例如：
 
 
template < typename arg1, int arg2, typename arg3>
 
 
class myclass
 
 
　　{  arg1  buffer[arg2]；
 
 
           arg3  x;　　//类的定义体
 
 
　　}；
 
 
 
 
类模板中成员函数可以放在类模板的定义体中(此时与类中的成员函数的定义方法一致)定义，也可以放在类模板的外部来定义，格式为：
 
 
template <类型形参表>
 
 
函数返回类型  类模板名<类型名表>::成员函数(形参)
 
 
template < typename arg1, int arg2, typename arg3>
 
 
void myclass::print() {}
 
 
类模板使用注意：

 类模板定义只是对类的描述，它本身还不是一个实实在在的类。
 

 类模板不能直接使用，必须
 先特化（
 specialized
 ）
 为相应的
 模板类
 ，定义模板类的对象
 (
 即实例
 )
 后，才可使用
 (
 创建对象等
 )
 。
 

 可以用以下方式创建类模板的特化及对象。
 

 类模板名
 <
 类型实参表
 > 
 对象名表
 ；
 
如：Myclass a;
 

 此处的
 <
 类型实参表
 >
 要与该模板中的
 <
 类型形参表
 >
 匹配，要具有
 同样的顺序和类型
 ，否则会产生错误！ 
 
 
#include 
using namespace std;	

template 
class AnyType
{	T  x, y;
public:
	AnyType(T a, T b): x(a), y(b){}
	T GetX(){return x;}
	T GetY(){return y;}
};
int main()
{    
	AnyType  i (1, 2);
	AnyType  d (1.5, 2.7);
	AnyType  c ('a', 'b');
	AnyType  s ("Hello", "template class");		
	cout << "整型类：" << i.GetX() << ", " << i.GetY() << endl;
	cout << "双精度类：" << d.GetX() << ", " << d.GetY() << endl;
	cout << "字符类：" << c.GetX() << ", " << c.GetY() << endl;
	cout << "字符串类：" << s.GetX() << ", " << s.GetY() << endl;
	return 0;
}
 
类模板中的static数据成员

 从类模板实例化的每个模板特化有自己的
 static
 数据成员
 

 该模板特化的所有对象共享一个
 static
 数据成员
 

 static
 数据成员必须被定义，在文件范围内被初始化
 
template 
class A
{    static int x；
}；
 template < typename T> int A::x=0;
 A a1,a2; // a1和a2共享一个x
 A b1,b2; // b1和b2共享一个x