命名空间
定义:命名空间需要用到namespace关键字,其后跟着命名空间的名字(自定义),再接着就是一对花括号,花括号里的内容可以是定义的变量,函数或者结构体
//对命名空间的定义
namespace fun
{
int a = 1;
int add(int left,int right)
{
return left + right;
}
struct Node
{
int data;
int* next;
}
}
int main()
{
// ...
return 0;
}
作用: 命名空间只能使用在全局域中,要知道,不同的域可以定义同一个变量,但在同一个域中不能定义同一个变量,防止在定义某个变量时与全局域产生冲突,空间命名在全局域中就起到了隔离的作用,其在全局域中形成一个命名空间域,该域与全局域互不干涉
若不使用命名空间,在编译时,系统就会出现下面的报错:
产生冲突时,命名空间就起到了作用:
可看到,rang成功打印,并未与在全局域中头文件中的rand产生冲突。在访问命名空间的成员时,需要用到" : : " 域作用限定操作符,在该操作符前添上自定义的命名空间名,在其后添上所要访问的成员即可。对于全局域中变量的访问,也可以用此操作符,在该操作符前的位置不添任何东西即可
命名空间中定义的变量,函数或结构体作用的范围是全局
可以看到在全局域中定义的函数,也可使用命名空间中定义的变量
- 命名空间的嵌套定义
一个命名空间中可以有多个子命名空间:
编译查找一个变量/声明时,默认只会在局部和全局域查找,所以想要查找命名空间里的变量/声明的话,有三种方式:
- 指定访问命名空间
namespace fun
{
int a = 10;
int add(int x, int y)
{
return x + y;
}
}
int main()
{
printf("%d\n",fun::a); // 指定访问命名空间中的变量a
return 0;
}
- 全部展开
namespace fun
{
int a = 22;
int b = 10;
}
using namespace fun; //将命名空间域全部展开成全局域
int main()
{
printf("%d\n",a); // 展开之后命名空间中的变量可当成全局域使用
printf("%d\n",b);
return 0;
}
全部展开相当于将命名空间中的成员全部暴露在全局域中,这样的方式一般不适用于多人合作时使用,一般适用于个人做一些练习或简单程序时
- 部分展开
namespace fun
{
int x = 1;
int y = 0;
}
unsing fun::x; // 只对命名空间中的x进行展开
int main()
{
printf("%d\n",x);
printf("%d\n",fun::y);
return 0;
}
- C++标准库都放在一个叫std(stdandar)的命名空间中
- 当项目工程中多文件中定义了同名的namespace,编译器会自动认为是同一个namespace,不会产生冲突
输入与输出
与C语言相比,C++的输入和输出会更加的灵活,来看下面的代码:
- ”iostream“是标准输入,输出流的库,因为C++的标准库都被放在std的命名空间中,所以在访问库时须以访问命名空间的方式,来对库进行访问
- std::cin 是istream类的对象,主要是面向窄字符的标准输入流
- std::cout 是ostream类的对象,主要是面向窄字符的标准输出流
- std::endl 是一个函数,相当于一个换行符加刷新缓冲区
- << 是流的插入/输出运算符,>> 是流的提取/输入运算符
与C语言相比,C++的输入和输出不用一个指定格式或者多个格式,在写代码时,更加的方便
int main()
{
int i = 10;
char b = 'A';
std::cout << i << std::endl << b << std::endl; // 不同类型的变量进行同时输出
return 0;
}
缺省参数
概念:缺省参数是在声明或定义函数时,为函数设定一个缺省值(默认值),在调用函数时,若没有指定实参,则该函数就默认使用设定好的缺省值;若指定了实参,则使用实参的值
例:
可知,当第一次调用函数时,没有指定实参,a的值默认为缺省值4;当第二次调用函数时,指定了实参44,a的值为指定的实参
分类:
- 全缺省:函数中有多个参数,每个参数都指定一个缺省值
调用全缺省参数时,传参只能从左往右传,不可跳跃传参
- 半缺省:函数中有多个参数,参数中至少有一个以上设定有缺省值
设定缺省参数时,只能从右往左依次设定缺省值,不可跳跃设定
注:在设定缺省参数时,若函数的定义与声明是分离的,那么只能在函数声明时给定缺省值
函数重载
概念:C++支持在同一作用域中出现同名的函数,但要求函数的参数类型不同,或者函数的参数个数不同,这样的同名函数就被称作函数重载,函数重载弥补了C语言中出现的功能相同,但不能定义为同名函数的现象
分类:
-
参数类型不同
可见,两次都调用了同名的add函数,但实质上这两个函数并不相同,只是功能上相同 -
参数个数不同
- 参数顺序不同
顺序不同,本质上其实也是类型不同
引用和const引用
概念:引用就是给变量取别名
定义:
int main()
{
int i = 10;
int& ri = i;
return 0;
}
从上面的代码来看,ri就是 i 的别名, i 是被引用的变量,而 ri 是引用变量,编译器不会给引用变量另外开辟空间,而是与它所引用的变量公用同一个空间,由此可推出,ri 与 i 共用一个空间,若引用变量改变则被引用变量也会改变,反之,亦如此
引用的特性:
- 定义引用变量时必须初始化
- 一个变量可以有多个引用
- 一个引用变量一旦引用了一个变量,就不可再引用其他变量了(C++的引用不能改变指向)
从上面的代码来看,将e赋值给了b,但是b的地址也不会改变,b已经有了引用变量a,便不会再引用其他变量
引用的使用方式:
- 作参数
我们知道,通常实现两个数交换的函数,实参传的是地址,需要用指针接收,然后再对指针进行解引用,而上面的代码,传的是值,分别用引用变量来进行接收,然后进行两个数的交换,体现了改变引用变量就会改变被引用变量这一个特点
- 指针的引用
typedef struct Node
{
int data;
struct Node* next;
}SL,*phead;
void SeqListInit(phead& plist,int x)
//这里的引用相当于 phead& plist = list
{
SL* tmp = (SL*)malloc(sizeof(SL));
if (tmp == NULL)
{
perror("malloc fail!");
exit(-1);
}
tmp->data = x;
tmp->next = NULL;
plist = tmp;
}
int main()
{
phead plist = NULL;//plist用来存放链表头结点的地址
//对链表进行初始化
SeqListInit(plist, 4);
return 0;
}
代码结果:
我们知道,在对链表进行初始化时,想要改变一级指针的指向就需要取一级指针的地址,然后用二级指针来接收,通过对二级指针的解引用,就可改变一级指针的指向。但是使用C++的引用,就可以代替指针传参,也可以改变一级指针的指向,这样可较好的简化程序,避免指针混淆
- 作返回值
用栈顶元素来举个例子:
系统在进行编译时,会有返回值的临时拷贝,并非直接将要返回的对象(st.arr[st.top-1])直接返回,所以在返回值的类型为int时,系统会为返回值开辟一个空间作为临时对象,来存储返回值,然后再返回临时对象(相当于返回的是要返回的对象的临时拷贝),所以在实行++StackTop(st)的操作时,其实是对临时对象进行++,而临时对象具有常性不能对其进行++的操作;而如果引用作为返回值,则相当于返回的是 st.arr[st.top-1] 的别名,即可以直接对别名进行修改,不会对其进行报错,系统在编译时也不会对其进行拷贝和开辟一个临时空间,
但是并不是任何场景都能用引用返回的,例如 :
调用fun()这个函数,在该函数中创建了临时变量 i ,而当调用结束,函数销毁时,该临时变量 i 也会被销毁,而对引用了 i 的别名进行修改,会造成越界访问,所以引用临时变量不可作为返回值
注:引用和指针是相辅相成的,二者皆不可替代,指针可以改变指向的对象,但引用改变不了,C++使用引用能简化程序,避免使用复杂的指针
const引用
概念:被const修饰的变量会受到权限,不可修改,有const的对象必须用const引用
int main()
{
const int x = 10;
const int& rx = x; //x受到const的修饰,所以rx也必须用const
return 0;
}
在使用const的过程中需要注意:不可放大const对象的权限,但可以缩小没有const对象的权限,缩小了之后,被引用的对象可修改,引用对象不可修改
- 不可放大权限
上述代码中的x受到了const的权限,当定义x的别名rx时,因为别名是不开辟空间的,与被引用对象共用同一块空间,x的空间受到限制,那么定义的x的别名rx也应受到限制,不可放大x空间的权限
- 可以缩小权限
可看到,第二条指令被const修饰,缩小了rx的权限,所以rx不可修改,但是x并未受到权限的影响,所以x可修改
对const运用的延伸
int main()
{
const int x = 10;
int y = x;
return 0;
}
上述代码是正确的,不存在权限的放大,const修饰的是x的这块空间,而将x赋给y是一种赋值拷贝,y也不与x共用同一块空间,所以不存在权限的放大
int main()
{
const int a = 10;
const int* p1 = &a;
int* p2 = p1;
return 0;
}
上述代码是错误的,这属于权限的放大,第二条指令中,const修饰的不是p1本身,修饰的是p1所指向的空间a不可被修改,且a受到了const的修饰,而将p1赋值给p2时,p2也应受到const的限制
int main()
{
int b = 20;
const int* p1 = &b;
const int* p2 = p1;
return 0;
}
上述代码正确,属于权限的缩小,变量b可读可写,将b的地址赋给p1后,p1又受到了const的权限,所以p2也应受到const的权限
int main()
{
int c = 30;
int* const p1 = &c;
int* p2 = p1;
return 0;
}
上述代码时正确的,不存在权限的放大,const修饰p1本身,并非其指向的空间c,p2 = p1相当于一个赋值拷贝,不影响p2对空间c的读写
指针和引用的关系
- 引用不开辟空间,指针需要开辟空间来存储变量的地址
- 引用必须初始化,而指针可不初始化
- 引用的指向一旦确定则不再修改,而指针的指向可随时修改
- 引用了直接访问指向的对象,而指针需解引用才可访问
- 引用的大小根据所指向的对象的类型决定,指针的大小在32位平台下是4字节,在64位平台下是8字节
- 引用的安全性较高于指针
注:引用在语法上是不开辟空间的,但在汇编底层中,其实跟指针是一样的,也需要开辟空间:
int main()
{
int x = 10;
int& rx = x;
rx += 1;
int* px = &x;
*px += 1;
return 0;
}
上述代码的汇编层如下:
可以看到,底层的汇编指令一模一样,所以引用的底层实现,与指针的实现是一样的
inline(内联函数)
概念:inline放在返回值的前面,用来修饰函数。编译器会对调用的inline函数进行展开,展开之后就不需要再建立函数栈帧,可提高程序的效率,inline函数的出现其实就是代替C语言中的宏,宏的使用直接在预处理阶段直接展开,可提高效率,但是宏的坑太多,所以就有了inline的出现
例如:
#include <iostream>
using std::cout;
using std::endl;
inline int add(int x,int y)
{
int ret = x + y;
return ret;
}
int main()
{
int sum = add(1,2);
cout << sum << endl;
return 0;
}
不展开的汇编指令如下:
不展开时,会有一条call指令,编译器会进入到call指令中,然后跳转到函数中,创建函数栈帧
展开的汇编指令如下:
显然展开后是没有call指令的,直接将实现函数的指令展开,也不会去建立函数栈帧
注:inline的使用对编译器来说只是一种建议,对函数的展开与否还是取决于编译器,一般来说,对于内联函数,若是短小的函数,编译器会对其进行展开,若函数过大,编译器就不会对其进行展开
在debug版本下,内联函数默认是不展开的(需要手动设置)