3. C++对C语言的拓展
3.1 引⽤
3.1.1 变量名
变量名实质上是一段连续存储空间的别名，是一个标号(门牌号)
通过变量来申请并命名内存空间.
通过变量的名字可以使用存储空间.
问题：对一段连续的内存空间只能取一个别名吗？
3.1.2 引用的概念
变量名，本身是一段内存的引用，即别名(alias). 引用可以看作一个已定义变量的别名。
引用的语法：Type& name = var;
用法如下:
#include <iostream>
using namespace std;
int main(void)
{
int a = 10; //c编译器分配4个字节内存, a内存空间的别名
int &b = a; //b就是a的别名
a = 11; //直接赋值
{
int *p = &a;
*p = 12;
cout << a <<endl;
}
b=14;
cout<< "a="<<a <<",b=" <<b <<endl;
return 0;
}
3.1.3 规则
- 引用没有定义,是一种关系型声明。声明它和原有某一变量(实体)的关 系。故而类型与原类型保持一致,且不分配内存。与被引用的变量有相同的地 址。
- 声明的时候必须初始化,一经声明,不可变更。
- 可对引用,再次引用。多次引用的结果,是某一变量具有多个别名。
- &符号前有数据类型时,是引用。其它皆为取地址。
int main(void)
{
int a,b;
int &r = a;
int &r = b; //错误,不可更改原有的引⽤关系
float &rr = b; //错误,引⽤类型不匹配 cout<<&a<<&r<<endl; //变量与引⽤具有相>同
的地址。
int &ra = r; //可对引⽤更次引⽤,表⽰ a 变量有两个别名,分别是 r 和 ra
return 0;
}
3.1.4 引用作为函数参数
普通引用在声明时必须用其它的变量进行初始化，引用作为函数参数声明时不进行初始化。
#include
using namespa
ce std;
struct Teacher
{
char name[64];
int age ;
};
void printfT(Teacher *pT)
{
cout<< pT->age <<endl;
}
//pT是t1的别名 ,相当于修改了t1
void printfT2(Teacher &pT)
{
pT.age = 33;
cout<<pT.age<<endl;
}
//pT和t1的是两个不同的变量
void printfT3(Teacher pT)
{
cout<<pT.age<<endl;
pT.age = 45; //只会修改pT变量 ,不会修改t1变量
}
int main(void)
{
Teacher t1;
t1.age = 35;
printfT(&t1);
printfT2(t1); //pT是t1的别名
printf("t1.age:%d \n", t1.age); //33
printfT3(t1) ;// pT是形参 ,t1 copy⼀份数据 给pT
printf("t1.age:%d \n", t1.age); //33
return 0;
}
3.1.5 引用的意义
1）引用作为其它变量的别名而存在，因此在一些场合可以代替指针
2）引用相对于指针来说具有更好的可读性和实用性
void swap(int a, int b); //⽆法实现两数据的交换
void swap(int *p, int *q); //开辟了两个指针空间实现交换
void swap(int &a, int &b){
int tmp;
tmp = a; a = b;
b = tmp;
}
int main()
{
int a = 3,b = 5;
cout<<"a="<<a<<"b="<<b<<endl;
swap(a,b);
cout<<"a="<<a<<"b="<<b<<endl;
return 0;
}
c++中引入引用后,可以用引用解决的问题。避免用指针来解决。
3.1.6 引用的本质
#include <iostream>
int main()
{
int a = 10;
int &b = a; // 注意： 单独定义的引⽤时，必须初始化。
b = 11;
printf("a:%d\n", a);
printf("b:%d\n", b);
printf("&a:%p\n", &a);
printf("&b:%p\n", &b);
return 0;
}
思考1：C++编译器定义引用时，背后做了什么工作？
#include <iostream>
struct Teacher {
int &a;
int &b;
};
int main()
{
printf("sizeof(Teacher) %d\n",sizeof(Teacher));
return 0;
}
思考2：普通引用有自己的空间吗？
1）引用在C++中的内部实现是一个常指针
Type& name <===> Type* const name
2）C++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同。
3）从使用的角度，引用会让人误会其只是一个别名，没有自己的存储空间。这是C++为了实用性而做出的细节隐藏。
void func(int &a)
{
a = 5;
}
void func(int *const a)
{
*a = 5;
}
int main()
{
int x = 10;
func(x);
return 0;
}
间接赋值的3各必要条件
1、定义两个变量 （一个实参一个形参）
2、建立关联 实参取地址传给形参
3、*p形参去间接的修改实参的值
引用在实现上，只不过是把：间接赋值成立的三个条件的后两步和二为一.
当实参传给形参引用的时候，只不过是c++编译器帮我们程序员手工取了一个实参地址，传给了形参引用（常量指针）。
3.1.7 引用作为函数的返回值（引用当左值）
I. 当函数返回值为引用时,
若返回栈变量:
不能成为其它引用的初始值（不能作为左值使用）
include <iostream>
using namespace std;
int getA1()
{
int a;
a = 10;
return a;
}
int& getA2()
{
int a;
a = 10;
return a;
}
int main(void)
{
int a1 = 0;
int a2 = 0;
//值拷⻉
a1 = getA1();
//将⼀个引⽤赋给⼀个变量，会有拷⻉动作
//理解： 编译器类似做了如下隐藏操作，a2 = *(getA2())
a2 = getA2();
//将⼀个引⽤赋给另⼀个引⽤作为初始值，由于是栈的引⽤，内存⾮法
int &a3 = getA2();
cout <<"a1 = " <<a1<<endl;
cout <<"a2 = " <<a2<<endl;
cout <<"a3 = " <<a3<<endl;
return 0;
}
II. 当函数返回值为引用时,
若返回静态变量或全局变量
可以成为其他引用的初始值（可作为右值使用，也可作为左值使用）
#include <iostream>
using namespace std;
int getA1()
{
static int a;
a = 10;
return a;
}
int& getA2()
{
static int a;
a = 10;
return a;
}
int main(void)
{
int a1 = 0;
int a2 = 0;
//值拷⻉
a1 = getA1();
//将⼀个引⽤赋给⼀个变量，会有拷⻉动作
//理解： 编译器类似做了如下隐藏操作，a2 = *(getA2())
a2 = getA2();
//将⼀个引⽤赋给另⼀个引⽤作为初始值，由于是静态区域，内存合法
int &a3 = getA2();
cout <<"a1 = " <<a1<<endl;
cout <<"a2 = " <<a2<<endl;
cout <<"a3 = " <<a3<<endl;
return 0;
}
引用作为函数返回值，
如果返回值为引用可以当左值，
如果返回值为普通变量不可以当左值。
#include <iostream>
using namespace std;
//函数当左值
//返回变量的值
int func1()
{
static int a1 = 10;
return a1;
}
//返回变量本⾝ ,
int& func2()
{
static int a2 = 10;
return a2;
}
int main(void)
{
//函数当右值
int c1 = func1();
cout << "c1 = " << c1 <<endl;
int c2 = func2(); //函数返回值是⼀个引⽤,并且当右值
cout << "c2 = " << c2 <<endl;
//函数当左值
//func1() = 100; //error
func2() = 100; //函数返回值是⼀个引⽤,并且当左值
c2 = func2();
cout << "c2 = " << c2 <<endl;
return 0;
}
3.1.8 指针引用
#include <iostream>
using namespace std;
stru
ct Teacher
{
char name[64];
int age ;
};
//在被调⽤函数 获取资源
int getTeacher(Teacher **p)
{
Teacher *tmp = NULL;
if (p == NULL)
{
return -1;
}
tmp =(Teacher*)malloc(sizeof(Teacher));
if (tmp == NULL)
{
return -2;
}
tmp->age = 33;
// p是实参的地址 *实参的地址 去间接的修改实参的值
*p = tmp;
return 0;
}
//指针的引⽤ 做函数参数
int getTeacher2(Teacher* &myp)
{
//给myp赋值 相当于给main函数中的pT1赋值
myp = (Teacher *)malloc(sizeof(Teacher));
if (myp == NULL)
{
return -1;
}
myp->age = 36;
return 0;
}
void FreeTeacher(Teacher *pT1)
{
if (pT1 == NULL)
{
return ;
}
free(pT1);
}
int main(void)
{
Teacher *pT1 = NULL;
//1 c语⾔中的⼆级指针
getTeacher(&pT1);
cout<<"age:"<<pT1->age<<endl;
FreeTeacher(pT1);
//2 c++中的引⽤ （指针的引⽤）
//引⽤的本质 间接赋值后2个条件 让c++编译器帮我们程序员做了。
getTeacher2(pT1);
cout<<"age:"<<pT1->age<<endl;
FreeTeacher(pT1);
return 0;
}
3.1.9 const 引用
const 引用有较多使用。它可以防止对象的值被随意修改。因而具有一些特性。
(1)**const 对象的引用必须是 const 的,将普通引用绑定到 const 对象是不合法的。**这个原因比较简单。既然对象是 const 的,表示不能被修改,引用当然也不 能修改,必须使用 const 引用。实际上,
const int a=1;
int &b=a;
这种写法是不合法 的,编译不过。
(2)const 引用可使用相关类型的对象(常量,非同类型的变量或表达式)初始化。这个是 const 引用与普通引用最大的区别。
const int &a=2;
是合法的。
double x=3.14;
const int &b=a;
也是合法的。
#include <iostream>
using namespace std;
int main(void)
{
//普通引⽤
int a = 10;
int &b = a;
cout << "b = " << b << endl;
//常引⽤
int x = 20;
const int &y = x; //常引⽤是限制变量为只读 不能通过y去修改x了
//y = 21; /error
return 0;
}
3.1.10 const引用的原理
const 引用的目的是,禁止通过修改引用值来改变被引用的对象。const 引用的 初始化特性较为微妙,可通过如下代码说明:
double val = 3.14;
const int &ref = val;
double & ref2 = val;
cout<<ref<<" "<<ref2<<endl;
val = 4.14;
cout<<ref<<" "<<ref2<<endl;
上述输出结果为 3 3.14 和 3 4.14。因为 ref 是 const 的,在初始化的过程中已经给定值,不允许修改。而被引用的对象是 val,是非 const 的,所以 val 的修改并未 影响 ref 的值,而 ref2 的值发生了相应的改变。
那么,为什么非 const 的引用不能使用相关类型初始化呢?实际上,const 引用 使用相关类型对象初始化时发生了如下过程:
int temp = val;
const int &ref = temp;
如果 ref 不是 const 的,那么改变 ref 值,修改的是 temp,而不是 val。期望对 ref 的赋值会修改 val 的程序员会发现 val 实际并未修改。
#include <iostream>
using namespace std;
int main(void)
{
//1> ⽤变量 初始化 常引⽤
int x1 = 30;
const int &y1 = x1; //⽤x1变量去初始化 常引⽤
//2> ⽤字⾯量 初始化 常量引⽤
const int a = 40; //c++编译器把a放在符号表中
//int &m = 41; //error , 普通引⽤ 引⽤⼀个字⾯量 请问字⾯量有没有内存地址
const int &m = 43; //c++编译器 会 分配内存空间
// int temp = 43
// const int &m = temp;
return 0;
}
#include <iostream>
using namespace std;
struct Teacher
{
char name[64];
int age ;
};
void printTeacher(const Teacher &myt)
{
//常引⽤ 让 实参变量 拥有只读属性
//myt.age = 33;
printf("myt.age:%d \n", myt.age);
}
int main(void)
{
Teacher t1;
t1.age = 36;
printTeacher(t1);
return 0;
}
结论：
1）const int & e 相当于 const int * const e
2）普通引用 相当于 int *const e
3）当使用常量（字面量）对const引用进行初始化时，C++编译器会为常量值分配空间，并将引用名作为这段空间的别名
4）使用字面量对const引用初始化后，将生成一个只读变量
3.2 inline内联函数
c 语言中有宏函数的概念。宏函数的特点是内嵌到调用代码中去,避免了函数调用的开销。但是由于宏函数的处理发生在预处理阶段,缺了语法检测和有可能带来的语 意差错。
3.2.1 内联函数基本概念
C++提供了 inline 关键字,实现了真正的内嵌。
#include <iostream>
using namespace std;
inline void func(int a)
{
a = 20;
cout << a <<endl;
}
int main(void)
{
func(10);
/*
//编译器将内联函数的函数体直接展开
{
a = 20;
cout << a <<endl;
}
*/
return 0;
}
特点：
1）内联函数声明时inline关键字必须和函数定义结合在一起，否则编译器会直
接忽略内联请求。
2）C++编译器直接将函数体插入在函数调用的地方 。
3）内联函数没有普通函数调用时的额外开销(压栈，跳转，返回)。
4）内联函数是一种特殊的函数，具有普通函数的特征（参数检查，返回类型
等）。
5） 内联函数由 编译器处理，直接将编译后的函数体插入调用的地方，
宏代码片段 由预处理器处理， 进行简单的文本替换，没有任何编译过程。
6）C++中内联编译的限制：
不能存在任何形式的循环语句
不能存在过多的条件判断语句
函数体不能过于庞大
不能对函数进行取址操作
函数内联声明必须在调用语句之前
7）编译器对于内联函数的限制并不是绝对的，内联函数相对于普通函数的优势只是省去了函数调用时压栈，跳转和返回的开销。因此，当函数体的执行开销远大于压栈，跳转和返回所用的开销时，那么内联将无意义。
3.2.2 内联函数 vs 宏函数
#include <iostream>
#include <string.h>
using namespace std;
#if 0
优点: 内嵌代码,辟免压栈与出栈的开销
缺点: 代码替换,易使⽣成代码体积变⼤,易产⽣逻辑错误。
#endif
#define SQR(x) ((x)*(x))
#if 0
优点: ⾼度抽象,避免重复开发
缺点: 压栈与出栈,带来开销
#endif
inline int sqr(int x)
{
return x*x;
}
int main()
{
int i=0;
while(i<5)
{
// printf("%d\n",SQR(i++));
printf("%d\n",sqr(i++));
}
return 0;
}
3.2.3 内联函数总结
优点:避免调用时的额外开销(入栈与出栈操作)
代价:由于内联函数的函数体在代码段中会出现多个“副本”,因此会增加代码段的空间。
本质:以牺牲代码段空间为代价,提高程序的运行时间的效率。
适用场景:函数体很“小”,且被“频繁”调用。
3.3 默认参数和占位参数
通常情况下,函数在调用时,形参从实参那里取得值。对于多次调用用一函数同一 实参时,C++给出了更简单的处理办法。给形参以默认值,这样就不用从实参那里取值了。
3.3.1 单个默认参数
//1 若 你填写参数,使⽤你填写的,不填写默认
void myPrint(int x = 3)
{
cout<<"x: “<<x<< endl;
}
3.3.2 多个默认参数
//2 在默认参数规则 ，如果默认参数出现，那么右边的都必须有默认参数
float volume(float length, float weight = 4,float high = 5)
{
return length*weight*high;
}
int main()
{
float v = volume(10);
float v1 = volume(10,20);
float v2 = volume(10,20,30);
cout<<v<<endl;
cout<<v1<<endl;
cout<<v2<<endl;
return 0;
}
3.3.3 默认参数规则
只有参数列表后面部分的参数才可以提供默认参数值
一旦在一个函数调用中开始使用默认参数值，那么这个参数后的所有参数都必须使用默认参数值
3.3.4 占位参数
#include <iostream>
/*
函数占位参数
占位参数只有参数类型声明，⽽没有参数名声明
⼀般情况下，在函数体内部⽆法使⽤占位参数
*/
int func(int a, int b, int)
{
return a + b;
}
int main()
{
func(1, 2); //error, 必须把最后⼀个占位参数补上。
//好悲剧的语法 -_-!
printf("func(1, 2, 3) = %d\n", func(1, 2, 3));
return 0;
}
#include <iostream>
/*
可以将占位参数与默认参数结合起来使⽤
意义
为以后程序的扩展留下线索
兼容C语⾔程序中可能出现的不规范写法
*/
//C++可以声明占位符参数，占位符参数⼀般⽤于程序扩展和对C代码的兼容
int func2(int a, int b, int = 0)
{
return a + b;
}
int main()
{
//如果默认参数和占位参数在⼀起，都能调⽤起来
func2(1, 2);
func2(1, 2, 3);
return 0;
}
/*
结论：如果默认参数和占位参数在⼀起，都能调⽤起来
*/
3.4 函数重载
函数重载(Function Overload)：用同一个函数名定义不同的函数，当函
数名和不同的参数搭配时函数的含义不同。
3.4.1 重载规则
1,函数名相同。
2,参数个数不同,参数的类型不同,参数顺序不同,均可构成重载。
3,返回值类型不同则不可以构成重载。
void func(int a); //ok
void func(char a); //ok
void func(char a,int b); //ok
void func(int a, char b); //ok
char func(int a); //与第⼀个函数有冲突
3.4.2 调用准则
1,严格匹配,找到则调用。
2,通过隐式转换寻求一个匹配,找到则调用。
#include <iostream>
using namespace std;
void print(double a){
cout<<a<<endl;
}
void print(int a){
cout<<a<<endl;
}
int main()
{
print(1); // print(int)
print(1.1); // print(double)
print('a'); // print(int)
print(1.11f); // print(double)
return 0;
}
编译器调用重载函数的准则:
1.将所有同名函数作为候选者
2.尝试寻找可行的候选函数
3.精确匹配实参
4.通过默认参数能够匹配实参
5.通过默认类型转换匹配实参
6.匹配失败
7.最终寻找到的可行候选函数不唯一，则出现二义性，编译失败。
8.无法匹配所有候选者，函数未定义，编译失败。
3.4.3 重载底层实现（name mangling）
C++利用 name mangling(倾轧)技术,来改名函数名,区分参数不同的同
名函数。
实现原理:用 v c i f l d 表示 void char int float long double 及其引
用。
void func(char a); // func_c(char a)
void func(char a, int b, double c); //func_cid(char a, int b, double c)
3.4.4 函数重载与函数默认参数
一个函数,不能既作重载,又作默认参数的函数。当你少写一个参数时,系统 无法确认是重载还是默认参数。
#include <iostream>
using namespace std;
int func(int a, int b, int c = 0)
{
return a * b * c;
}
int func(int a, int b)
{
return a + b;
}
int func(int a)
{
return a;
}
int main()
{
int c = 0;
c = func(1, 2); //error. 存在⼆义性，调⽤失败，编译不能通过
printf("c = %d\n", c);
return 0;
}
3.4.5 函数重载和函数指针结合
/*
函数重载与函数指针
当使⽤重载函数名对函数指针进⾏赋值时
根据重载规则挑选与函数指针参数列表⼀致的候选者
严格匹配候选者的函数类型与函数指针的函数类型
*/
#include <iostream>
using namespace std;
int func(int x) // int(int a)
{
return x;
}
int func(int a, int b)
{
return a + b;
}
int func(const char* s)
{
return strlen(s);
}
typedef int(*PFUNC)(int a); // int(*)(int a)
typedef int(*PFUNC2)(int a, int b); // int(*)(int a, int b)
int main()
{
int c = 0;
PFUNC p = func;
c = p(1);
printf("c = %d\n", c);
PFUNC2 p2 = func;
c = p2(1, 2);
printf("c = %d\n", c);
return 0;
}
函数指针基本语法
//⽅法⼀：
//声明⼀个函数类型
typedef void (myTypeFunc)(int a,int b);
//定义⼀个函数指针
myTypeFunc *myfuncp = NULL; //定义⼀个函数指针 这个指针指向函数的⼊⼝地址
//⽅法⼆：
//声明⼀个函数指针类型
typedef void (*myPTypeFunc)(int a,int b) ; //声明了⼀个指针的数据类型
//定义⼀个函数指针
myPTypeFunc fp = NULL; //通过 函数指针类型 定义了 ⼀个函数指针 ,
//⽅法三：
//定义⼀个函数指针 变量
void (*myVarPFunc)(int a, int b);
3.4.6 函数重载总结
重载函数在本质上是相互独立的不同函数。
函数的函数类型是不同的
函数返回值不能作为函数重载的依据
函数重载是由函数名和参数列表决定的。