在C/C++中,变量、函数和后面要学到的类都是大量存在的,这些变量、函数和类的名称将都存在于全局作用域中,可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化,以避免命名冲突或名字污染,namespace关键字的出现就是针对这种问题的
比如:这里我想定义一个rand变量,但与库中的函数rand重名,C语言里就直接报错,没有办法。那C++有什么办法吗?有的,就是namespace关键字!
这里我们就直接来展示下:
这里就相当于于直接访问了我们设置的空间里的rand,非常准确,避免了和库里的函数rand命名冲突
上面就简单举了两个例子来说明了一下,接下来我们就进一步学习namespace关键字:
namespace C
{
//变量:
int a = 10;
//函数:
int Add(int left, int right)
{
return left + right;
}
//类型:结构体
struct Node
{
struct Node* next;
int val;
};
}
namespace C1
{
//变量:
int a = 10;
//函数:
int Add(int left, int right)
{
return left + right;
}
//嵌套命名空间:
namespace C2
{
int a=20;
}
}
C1::C2::a
在一个工程中,比如在test.cpp和test.h文件中都有N1命名空间,那么会将两个文件的同名空间整合
如图,我们用了using引入了C中的b,就可以直接访问量
同样可以实现直接访问变量b。
了解了上面的知识,确实这样写就不大好了,当然如果是竞赛,全部展开还会影响代码速度。
#include
// std是C++标准库的命名空间名,C++将标准库的定义实现都放到这个命名空间中
using namespace std;
int main()
{
cout<<"Hello world!!!"<<endl;
return 0;
}
这里就不如单独展开,或者单独访问
#include
using std::cout;
using std::endl;
int main()
{
cout<<"Hello world!!!"<<endl;
std::cout<<"Hello world!!!"<<std::endl;
return 0;
}
说明:
void Func(int a = 10, int b = 20, int c = 30)
{
cout<<"a = "<<a<<endl;
cout<<"b = "<<b<<endl;
cout<<"c = "<<c<<endl;
}
void Func(int a, int b = 10, int c = 20)
{
cout<<"a = "<<a<<endl;
cout<<"b = "<<b<<endl;
cout<<"c = "<<c<<endl;
}
注意:
半缺省参数必须从右往左依次来给出,不能间隔着给
解释:我们函数输入参数是按照从左向右的顺序,如果半缺省参数也从左向右的顺序来,那么就很有可能后面的参数没有默认值,导致参数缺少;
缺省参数不能在函数声明和定义中同时出现,在声明给缺省。
理由:在预处理阶段—编译阶段我们都只能看到声明文件,不包含定义文件,所以如果是声明没有给缺省,我们传入参数数量若少于声明参数数量则会报错。所以我们就在声明给缺省。
缺省值必须是常量或者全局变量
C语言不支持(编译器不支持)
函数重载: 是函数的一种特殊情况,C++允许在同一作用域中声明几个功能类似的同名函数,这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同,常用来处理实现功能类似数据类型不同的问题。
#include
using namespace std;
// 1、参数类型不同
int Add(int left, int right)
{
cout << "int Add(int left, int right)" << endl;
return left + right;
}
double Add(double left, double right)
{
cout << "double Add(double left, double right)" << endl;
return left + right;
}
// 2、参数个数不同
void f()
{
cout << "f()" << endl;
}
void f(int a)
{
cout << "f(int a)" << endl;
}
// 3、参数类型顺序不同
void f(int a, char b)
{
cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
cout << "f(char b, int a)" << endl;
}
int main()
{
Add(10, 20);
Add(10.1, 20.2);
f();
f(10);
f(10, 'a');
f('a', 10);
return 0;
}
引用不是新定义一个变量,而是给已存在变量取了一个别名,编译器不会为引用变量开辟内存空间,它和它引用的变量共用同一块内存空间。
比如:李逵,在家称为 铁牛 ,江湖上人称黑旋风。只是别名。
在代码中引用的格式:类型& 引用变量名(对象名) = 引用实体;
#include
int main()
{
int a = 10;
int b = 20;
//int& b;这里会报错,原因引用必须初始化
int& ra = a;//这里就是定义ra为a的别名
int& rra = a;//一个变量可以有多个引用
//int& ra=b;//这里会报错,引用只能引用一个引用实体,引用在C++中是不能更改的;
printf("%d %d %d\n", a, ra,rra);
//打印结果为:10 10 10
printf("%p %p %p\n", &a, &ra,&rra);
//打印结果为:00B3F70C 00B3F70C 00B3F70C
ra=b;//赋值操作,a.ra.rra为同一空间,一个改变其他肯定改变,值是统一的,只是称呼不同罢了
printf("%d %d %d\n", a, ra,rra);
//打印结果为:20 20 20
}
从上面代码我们可以得出引用的特性:
#include
int main()
{
//引用过程中权限不能扩大,但可以平移和缩小
const int a = 10;
//int& ra = a; // 该语句编译时会出错,a为常量--权限扩大(x)
int c = 20;
const int& rc = c;//权限缩小
const int& ra = a;//权限平移
}
// int& b = 10; // 该语句编译时会出错,b为常量--权限扩大(x)
const int& b = 10;
double d = 12.34;
//int& rd = d; // 该语句编译时会出错,类型不同--权限扩大(x)
const int& rd = d;//为什么不报错呢?为什么加个const就可以了
再看这个例子,const int& rd = d;//为什么不报错呢?为什么加个const就可以了?
其实这个对比上面局的b的例子或许能得出答案;
- 10是一个常量,类型可以看做为const int类型,所以第一句是权限扩大,会报错。所以加const修饰就可以,实现权限平移,不会报错
- 第二个是会发生强制类型转化,但转换过程中会用到中间临时变量,临时变量具有常性,为一个常量,所以理由同上;
int func1()
{
int x = 10;
return x;
}
int& func2()
{
int x = 10;
return x;
}
int main()
{
int ret = func1();//拷贝
//int& ret = func1();报错,权限扩大(x)
const int& ret = func1; //和上面一样,返回值的话是需要通过临时变量的,也就同上
int& ret = func2();//这就没有问题,这里的func2()相当于对x的取别名,这里就相当于再次取别名
const int& ret = func2();//权限的缩小;
}
//拿交换函数来举个例子:
void Swap(int& left,int& right)
{
int tem = left ;
left = right;
right =tem;
}
Swap(a,b);
在上述代码中,其实我们传入的a,b就不在是a,b的值拷贝了,而是a,b的别名,所以更改left,right就可以实现更改a,b;
这里可以对比一下值传参和引用传参的效率比较: 以值作为参数或者返回值类型,在传参和返回期间,函数不会直接传递实参或者将变量本身直接返回,而是传递实参或者返回变量的一份临时的拷贝,因此用值作为参数或者返回值类型,效率是非常低下的,尤其是当参数或者返回值类型非常大时,效率就更低
//传值返回
#include
#include
using namespace std;
int& count(int x)//返回一个n的别名
{
int n = x;
n++;
return n;
}
int main()
{
int& ret = count(10);//别名的多层复用
cout << ret << endl;//运行结果:11
count(20);
rand();
cout << ret << endl;//运行结果:随机值
}
为什么这里会出现错误,而不是和我们上面所说的一样,n一改变其他别名也会改变呢?其实这里依旧是这个原理,但不一样的是这里的n为局部变量,n在调用过后栈区间会清除(并非销毁空间,归还区间访问权,清理该区间的数据)。那问题来了,为什么第一个答案是11是正确的呢,这可能跟编译器有关,编译器没有在清除该区域,只是收回了访问权(比如:指针就无法访问到这片空间,但值或许没变),但在调用rand()函数或者随机一个函数时,会开辟空间,就可能会利用到n那片空间,系统在栈帧操作过程中,就会有赋值,所以当我们引用继续访问时,发现值已经改变;
总结:传参引用都可以使用,但作为返回值需要考虑传回参数是否会出作用域后被清除。
概念:以inline修饰的函数叫做内联函数,编译时C++编译器会在调用内联函数的地方展开,没有函数调用建立栈帧的开销,内联函数提升程序运行的效率。
如果在上述函数前增加inline关键字将其改成内联函数,在编译期间编译器会用函数体替换函数的调用。查看方式: