期末复习笔记（大一下）

ItsNorth

已于 2023-12-12 10:10:31 修改

阅读量348

点赞数

分类专栏：大一C++学习日记文章标签： c++

于 2022-06-23 19:37:53 首次发布

本文链接：https://blog.csdn.net/han_lx_/article/details/125417286

版权

大一C++学习日记专栏收录该内容

12 篇文章 2 订阅

订阅专栏

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

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<<a<<endl; }
private:
    int num;
};
class Test2{
public:
    Test2(int a, int b): t(a) { num = b; 
     cout<<b<<endl;}};
private:
    Test t;
    int num;
};
void main(){
     Test2 test(10, 20); 
}

10 20

class Test{
public:
    Test( int a=0 ){ num = a;
    cout<<a<<endl; }
private:
    int num;
};
class Test2{
public:
    Test2(int a, int b) { num = b; 
    cout<<b<<endl;}
private:
    Test t;
    int num;
};
void main(){
     Test2 test(10, 20);  
}

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++)!='\0'); //[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”<<endl;
      return -1;
   } //失败退回操作系统
}

文件的打开与关闭

打开：

使用文件流对象的成员函数打开一个磁盘文件。

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 <stdexcept>
易错

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 <iostream>
using namespace std;

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

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

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

template <class T, class T1>
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 <typename <类型参数>> //模板声明

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<arg1,arg2,arg3>::print() {}

类模板使用注意：

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

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

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

类模板名 < 类型实参表 > 对象名表 ；

如：Myclass<int> a;

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

#include <iostream>
using namespace std;	

template <typename T>
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 <int> i (1, 2);
	AnyType <double> d (1.5, 2.7);
	AnyType <char> c ('a', 'b');
	AnyType <char *> 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 <typename T>
class A
{    static int x；
}；
 template < typename T> int A<T>::x=0;
 A<int> a1,a2; // a1和a2共享一个x
 A<double> b1,b2; // b1和b2共享一个x