程序设计与算法（三）C++面向对象程序设计 第一周 从C到C++ 笔记

笔记按照中国大学MOOC上北京大学郭炜老师主讲的程序设计与算法（三）C++面向对象程序设计所作，B站上也有资源。原课程链接如下：

程序设计与算法（三）C++面向对象程序设计

其他各章节链接如下：

程序设计与算法（三）C++面向对象程序设计笔记 第一周 从C到C++

程序设计与算法（三）C++面向对象程序设计笔记 第二周 类和对象基础

程序设计与算法（三）C++面向对象程序设计笔记 第三周 类和对象提高

程序设计与算法（三）C++面向对象程序设计笔记 第四周 运算符重载

程序设计与算法（三）C++面向对象程序设计笔记 第五周 继承

程序设计与算法（三）C++面向对象程序设计笔记 第六周 多态

程序设计与算法（三）C++面向对象程序设计笔记 第七周 输入输出和模板

程序设计与算法（三）C++面向对象程序设计笔记 第八周 标准模板库STL（一）

程序设计与算法（三）C++面向对象程序设计笔记 第九周 标准模板库STL（二）

程序设计与算法（三）C++面向对象程序设计笔记 第十周 C++11新特性和C++高级主题

其他各科笔记汇总

从 C 到 C++

“引用”的概念和应用

引用的概念

下面的写法定义了一个引用，并将其初始化为引用某个变量

类型名 & 引用名 = 某变量名;
1

int n = 4;
int & r = n; // r引用了 n, r的类型是 int &
1
2

 

某个变量的引用，等价于这个变量，相当于该变量的一个别名

下面改变 n 的值会改变 r 的值，改变 r 的值也会改变 n 的值，二者绑定

int n = 4;
int & r = n;
r = 4;
cout << r; //输出 4
cout << n; //输出 4
n = 5;
cout << r; //输出5
1
2
3
4
5
6
7

 

定义引用时一定要将其初始化为引用某个变量

初始化后，它就一直引用该变量，不会再引用别的变量了

引用只能引用变量，不能引用常量和表达式

int n = 4;
int & r = n * 5;      //error
1
2

double a = 4, b = 5;
double & r1 = a;
double & r2 = r1; // r2也引用 a
r2 = 10;
cout << a << endl; // 输出 10
r1 = b; // r1并没有引用b
cout << a << endl; //输出 5
1
2
3
4
5
6
7

引用应用的简单示例

编写交换两个整型变量值的函数

void swap( int & a, int & b)
{
    int tmp;
    tmp = a; a = b; b = tmp;
}
int n1, n2;
swap(n1,n2) ; // n1,n2的值被交换
1
2
3
4
5
6
7

引用作为函数的返回值

int n = 4;
int & SetValue() { return n; }
int main()
{
    SetValue() = 40;
    cout << n;
    return 0;
} //： 输出： 40
1
2
3
4
5
6
7
8

这样能够带来什么样的好处呢？

可以把函数调用写在赋值号的左边，对一个函数调用返回的结果可以进行赋值

返回值是引用，引用全局变量 n，所以对 SetValue() 的返回值进行赋值等价于对 n 进行赋值

常引用

定义引用时，前面加 const 关键字，即为”常引用“

int n;
const int & r = n;
1
2

r 的类型是 const int &

 

不能通过常引用去修改其引用的内容

int n = 100;
const int & r = n;
r = 200; // 编译错
n = 300; // 没问题
1
2
3
4

常引用和非常引用的转换

const T & 和 T & 是不同的类型！

 

T & 类型的引用或 T 类型的变量可以用来初始化 const T & 类型的引用

const T 类型的常变量和 const T & 类型的引用则不能用来初始化 T & 类型的引用，除非进行强制类型转换

“const” 关键字的用法

1）定义常量

define 也可以用来定义常量，但建议都用 const ，因为 const 有类型，便于类型检查

const int MAX_VAL = 23;
const double Pi = 3.14;
const char * SCHOOL_NAME = "Peking University";
1
2
3

2）定义常量指针

不可通过常量指针修改其指向的内容

int n,m;
const int * p = & n;
* p = 5; // 编译出错
n = 4; //ok
p = &m; //ok, 常量指针的指向可以变化
1
2
3
4
5

 

不能把常量指针赋值给非常量指针，反之可以

const int * p1; int * p2;
p1 = p2; //ok
p2 = p1; //error
p2 = (int * ) p1; //ok, 强制类型转换
1
2
3
4

我们倾向于尽量不要随便修改一个常量指针指向的地方的内容，如果随便赋给一个非常量的指针，那以后就可以通过修改 p2 指向的内容使得 p1 指向的内容也被修改

 

函数参数为常量指针时，可避免函数内部不小心改变参数指针所指地方的内容

void MyPrintf( const char * p )
{
strcpy( p,"this"); // 编译出错
printf("%s",p);    //ok
}
1
2
3
4
5

strcpy() 函数第一个参数的类型是 char *，而调用时给的参数 p 类型是 const char * ，不能够用一个 const char * 的指针给一个 char * 类型的指针赋值

3）定义常引用

不能通过常引用修改其引用的变量

int n;
const int & r = n;
r = 5; //error
n = 4; //ok
1
2
3
4

动态内存分配

用 new 运算符实现动态内存分配

第一种用法，分配一个变量：

P = new T;
1

T 是任意类型名，P 是类型为 T * 的指针。动态分配出一片大小为 sizeof(T) 字节的内存空间，并且将该内存空间的起始地址赋值给P

int * pn;
pn = new int;
* pn = 5;
1
2
3

 

第二种用法，分配一个数组：

P = new T[N];
1

T : 任意类型名
P : 类型为T* 的指针
N : 要分配的数组元素的个数，可以是整型表达式

动态分配出一片大小为 sizeof(T) * N 字节的内存空间，并且将该内存空间的起始地址赋值给P

int * pn;
int i = 5;
pn = new int[i * 20];
pn[0] = 20;
pn[100] = 30; //编译没问题。运行时导致数组越界
1
2
3
4
5

 

new 运算符的返回值类型

new T 和 new T[N] 这两个表达式返回值的类型都是 T＊

用delete运算符释放动态分配的内存

用 “new” 动态分配的内存空间，一定要用 “delete” 运算符进行释放

delete 指针；//该指针必须指向new出来的空间
1

int * p = new int;
* p = 5;
delete p;
delete p; //导致异常，一片空间不能被delete多次
1
2
3
4

 

用 delete 释放动态分配的数组，要加 ”[]“

delete [ ] 指针；//该指针必须指向new出来的数组
1

int * p = new int[20];
p[0] = 1;
delete [ ] p; 
1
2
3

内联函数 函数重载 函数缺省参数

内联函数

函数调用是有时间开销的。如果函数本身只有几条语句，执行非常快，而且函数被反复执行很多次，相比之下调用函数所产生的这个开销就会显得比较大

为了减少函数调用的开销，引入了内联函数机制。编译器处理对内联函数的调用语句时，是将整个函数的代码插入到调用语句处，而不会产生调用函数的语句

inline int Max(int a,int b)
{
    if( a > b) return a;
    return b;
}
1
2
3
4
5

内联函数会导致可执行程序的体积会增大

函数重载

一个或多个函数，名字相同，然而参数个数或参数类型不相同，这叫做函数的重载

以下三个函数是重载关系：

int Max(double f1,double f2) { }
int Max(int n1,int n2) { }
int Max(int n1,int n2,int n3) { }
1
2
3

函数重载使得函数命名变得简单

编译器根据调用语句中的实参的个数和类型判断应该调用哪个函数

 

Max(3.4,2.5); //调用 (1)
Max(2,4);     //调用 (2)
Max(1,2,3);   //调用 (3)
Max(3,2.4);   //error, 二义性
1
2
3
4

注意两个函数名字和参数都一样，只不过返回值的类型不同，这不叫重载，这叫重复定义

函数的缺省参数

C++中，定义函数的时候可以让最右边的连续若干个参数有缺省值，那么调用函数的时候，若相应位置不写参数，参数就是缺省值

void func( int x1, int x2 = 2, int x3 = 3)
{ }

func(10 ) ;     //等效于 func(10,2,3)
func(10,8) ;    //等效于 func(10,8,3)
func(10, , 8) ; //不行,只能最右边的连续若干个参数缺省
1
2
3
4
5
6

 

函数参数可缺省的目的在于提高程序的可扩充性

可扩充性好 —— 程序功能增加，不需要做很多的修改

即如果某个写好的函数要添加新的参数，而原先那些调用该函数的语句，未必需要使用新增的参数，那么为了避免对原先那些函数调用语句的修改，就可以使用缺省参数