文章目录
一、 C++关键字
C++总计63个关键字,C语言32个关键字
下面我们只是看一下C++有多少关键字,不对关键字进行具体的讲解。
二、命名空间
在C/C++中,变量、函数和后面要学到的类都是大量存在的,这些变量、函数和类的名称将都存在于全局作用域中,可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化,以避免命名冲突或名字污染,namespace关键字的出现就是针对这种问题的。
比如:
#include<stdio.h>
int rand = 0;
int main()
{
printf("%d\n", rand);
return 0;
}
这个代码会输出rand的值吗?
我们再包含一个头文件:
#include<stdio.h>
#include<stdlib.h>
int rand = 0;
int main()
{
printf("%d\n", rand);
return 0;
}
此时我们编译发现就会出错:
这是因为<stdlib.h>里面定义了rand这个函数,我们再定会rand这个名字就会报错。
2.1 命名空间定义
定义命名空间,需要使用到namespace关键字,后面跟命名空间的名字,然后接一对{}即可,{}中即为命名空间的成员。
比如:
1. 普通的命名空间
#include<stdio.h>
#include<stdlib.h>
namespace ts
{
int rand = 0;
}
int main()
{
printf("%d\n", rand);
return 0;
}
此时我们打印rand就不会报错。因为rand是个函数,所以用函数名打印就是这个函数的地址。
那么我们想用我们定义的rand该怎么使用呢?
此时我们这样使用就可以完美避开名字冲突的问题了。
看下面代码:
namespace ts1
{
int Add(int left, int right)
{
return left + right;
}
}
namespace ts2
{
int Add(int left, int right)
{
return left + right;
}
}
int main()
{
printf("%d\n", ts1::Add(1, 2));
printf("%d\n", ts2::Add(10, 20));
return 0;
}
看输出结果:
2. 命名空间可以嵌套
看下面的代码:
namespace N2
{
int a = 1;
int b = 2;
int Add(int left, int right)
{
return left + right;
}
namespace N3
{
int c = 3;
int d = 4;
int Sub(int left, int right)
{
return left - right;
}
}
}
int main()
{
printf("%d\n", N2::a);
printf("%d\n", N2::b);
printf("%d\n", N2::N3::c);
printf("%d\n", N2::N3::d);
return 0;
}
也会输出结果:
3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
这是什么意思呢?
一个命名空间就定义了一个新的作用域,命名空间中的所有内容都局限于该命名空间中
2.1 命名空间的使用
命名空间的使用有三种方式:
1.加命名空间名称及作用域限定符::
2.使用using namespace 命名空间名称引入
我们使用ts作为前缀有点麻烦,可不可以不要ts呢?
此时ts里面的定义的所有变量就暴露出来了,就可能会与其他名字发生冲突
namespace ts
{
int a = 1;
int b = 2;
int Add(int left, int right)
{
return left + right;
}
}
using namespace ts;
int a = 10;
int main()
{
printf("%d\n", a);
return 0;
}
编译就会出错:
3.使用using将命名空间中成员引入
而没有引入的其他成员就不能使用
而在这三种方法里面我们推荐使用的是第一种和第三种方法。因为第二种使用起来虽然很方便,但是极不安全。
三、C++输入&输出
新生婴儿会以自己独特的方式向这个崭新的世界打招呼,C++刚出来后,也算是一个新事物,
那C++是否也应该向这个美好的世界来声问候呢?我们来看下C++是如何来实现问候的。
很多人在学C++的时候就直接写using namespace std; 好像就是必须要这么写,但是不知道为什么要这么写,相信大家看完上面就知道了吧!但是不推荐这么写,平时我们练习的时候可以这样写,方便些,但是在做项目的时候就不能这么写了。
说明:
-
使用cout标准输出(控制台)和cin标准输入(键盘)时,必须包含< iostream >头文件以及std标准命名空间。
注意:早期标准库将所有功能在全局域中实现,声明在.h后缀的头文件中,使用时只需包含对应头文件即可,后来将其实现在std命名空间下,为了和C头文件区分,也为了正确使用命名空间,规定C++头文件不带.h;旧编译器(vc 6.0)中还支持<iostream.h>格式,后续编译器已不支持,因此推荐使用+std的方式。 -
使用C++输入输出更方便,不需增加数据格式控制,比如:整形–%d,字符–%c
比如:
输入用cin
是不是我们使用起来就更方便了呢?但是我们是不是就不用C语言的输入输出呢?也不是,怎么用方便怎么用比如现在有一个结构体:
我们用C++的输出就很麻烦,我们用C语言的输出看一下:
此时我们发现用C语言反而更方便,所以我们要辩证看待。
四、缺省参数
大家知道什么是备胎吗?
C++中函数的参数也可以配备胎。
4.1 缺省参数概念
缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时,如果没有指定实参则采用该默认值,否则使用指定的实参.。
我们在C语言的传参的时候是是不是下面这样呢?
#include<iostream>
using namespace std;
void TestFunc(int a)
{
cout << a << endl;
}
int main()
{
TestFunc(1);
return 0;
}
此时会输出1
但是如果我们可不可以不传参呢?C++是可以的。
4.2 缺省参数分类
全缺省参数
所有参数都给缺省值
半缺省参数
一部分参数给缺省值
注意:
- 半缺省参数必须从右往左依次来给出,不能间隔着给
- 缺省参数不能在函数声明和定义中同时出现
- 缺省值必须是常量或者全局变量
- C语言不支持(编译器不支持)
比如说我们现在间着给
编译就会出错,所以我们在使用的时候要按照定义来给参数。
定义和声明不能同时出现是什么意思呢?
这是Add函数声明:
这是Add函数定义:
我们此时再调用它,那么会用那个缺省值呢?
编译就会报错!!
五、 函数重载
自然语言中,一个词可以有多重含义,人们可以通过上下文来判断该词真实的含义,即该词被重载了。
比如:以前有一个笑话,国有两个体育项目大家根本不用看,也不用担心。一个是乒乓球,一个是男足。前者是“谁也赢不了!”,后者是“谁也赢不了!”
5.1 函数重载概念
函数重载:是函数的一种特殊情况,C++允许在同一作用域中声明几个功能类似的同名函数,这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须不同,常用来处理实现功能类似数据类型不同的问题
1.参数类型不同:
参数顺序不同:
3.参数顺序不同:
那么大家看一下下面这个代码能编译成功吗?
#include<iostream>
using namespace std;
void f(int a)
{
}
void f(int a = 1)
{
}
int main()
{
return 0;
}
编译直接就报错了。那么接下来这个代码呢?
#include<iostream>
using namespace std;
void f()
{
}
void f(int a = 1)
{
}
int main()
{
return 0;
}
编译就不会报错。
下面两个函数属于函数重载吗?
short Add(short left, short right)
{
return left+right;
}
int Add(short left, short right)
{
return left+right;
}
通过概念判断很快就能判断出这个不是函数重载,因为函数重载必须是参数顺序、类型或者个数任意一个不同就满足,而不能通过返回值来判断。我们编译也可以验证:
5.2 名字修饰(name Mangling)
为什么C++支持函数重载,而C语言不支持函数重载呢?
在C/C++中,一个程序要运行起来,需要经历以下几个阶段:预处理、编译、汇编、链接。
- 实际我们的项目通常是由多个头文件和多个源文件构成,而通过我们C语言阶段学习的编译链接,我们可以知道,【当前a.cpp中调用了b.cpp中定义的Add函数时】,编译后链接前,a.o的目标文件中没有Add的函数地址,因为Add是在b.cpp中定义的,所以Add的地址在b.o中。那么怎么办呢?
- 所以链接阶段就是专门处理这种问题,链接器看到a.o调用Add,但是没有Add的地址,就会到b.o的符号表中找Add的地址,然后链接到一起。
- 那么链接时,面对Add函数,连接器会使用哪个名字去找呢?这里每个编译器都有自己的函数名修饰规则。
- 由于Windows下vs的修饰规则过于复杂,而Linux下gcc的修饰规则简单易懂,下面我们使用了gcc演示了这个修饰后的名字。
- 通过下面我们可以看出gcc的函数修饰后名字不变。而g++的函数修饰后变成【_Z+函数长度+函数名+类型首字母】。
采用C语言编译器编译后结果
结论:在linux下,采用gcc编译完成后,函数名字的修饰没有发生改变
采用C++编译器编译后结果
结论:在linux下,采用g++编译完成后,函数名字的修饰发生改变,编译器将函数参数类型信息添加到修改后的名字中
Windows下名字修饰规则
我们先看一下在Windows下链接不上会怎么报错:
这个链接报错是不是很复杂呢?
对比Linux会发现,windows下C++编译器对函数名字修饰非常诡异,但道理都是一样的。
6. 通过这里就理解了C语言没办法支持重载,因为同名函数没办法区分。而C++是通过函数修饰规则来区分,只要参数不同,修饰出来的名字就不一样,就支持了重载
7. 另外我们也理解了,为什么函数重载要求参数不同!而跟返回值没关系。
六、引用
6.1 引用概念
引用不是新定义一个变量,而是给已存在变量取了一个别名,编译器不会为引用变量开辟内存空间,它和它引用的变量共用同一块内存空间。
比如:李逵,在家称为"铁牛",江湖上人称"黑旋风"。
类型& 引用变量名(对象名) = 引用实体;
我们将地址打印出来看一下:
地址是完全一样的,所以此时相当于b是a的别名,它们所代表的同一块空间:
通过上面打印的地址我们也已经知道它们的地址都是一样的。那我们改变值是不是也会发生改变呢?
打印的值都是20。
注意:引用类型必须和引用实体是同种类型的
6.2 引用特性
- 引用在定义时必须初始化
- 一个变量可以有多个引用
相当于一个人有多个外号,取多个别名是不会影响的。 - 引用一旦引用一个实体,再不能引用其他实体
我们画图理解:
6.3 常引用
这是什么意思呢?
a被const修饰,所以不可以直接被修改,而b作为a的别名,把a的权限扩大了,所以就会报错。我们怎么修改呢?
此时b的权限就和a的权限一样了。那么权限可以缩小吗?
我们再来看一个例子:
这个容易理解:会发生隐式类型转化,d会被截断。所以输出的是1
此时为什么会报错呢?
那么我们怎么更改呢?
加上const修饰就可以了。此时我们就会发现const在任何情况下都可以使用。
建议:使用引用传参,如果函数中不改变参数的值,我们就使用const&,举个例子:
6.4 使用场景
- 做参数
我们现在要交换两个数:
而就必须要传地址了:
我们使用引用也可以:
看下面代码:
#include<iostream>
using namespace std;
void Swap(int x, int y)
{
int tmp = x;
x = y;
y = tmp;
}
void Swap(int* x, int* y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}
//1. 做参数
void Swap(int& x, int& y)
{
int tmp = x;
x = y;
y = tmp;
}
int main()
{
int a = 10;
int b = 20;
//传值:
Swap(a, b);
cout << a << endl;
cout << b << endl << endl;
//传址
Swap(&a, &b);
cout << a << endl;
cout << b << endl << endl;
}
这三个swap构成函数重载,因为它们类型不一样,但是调用会出错,因为调用不明确,如果是传地址的话,就不会报错,因为接受参数类型是int*;但是如果是传值的话就不知道是调用哪个Swap函数,就会报错。
- 做返回值
大家看代码:
#include<iostream>
using namespace std;
//做返回值
int Add(int x, int y)
{
return x + y;
}
int main()
{
int a = 10;
int b = 20;
int ret = Add(a, b);
cout << ret << endl;
return 0;
}
这个输出结果相信大家都能看懂。但是我们从函数栈帧的过程去分析它:
我们发现这个返回的过程就是形成了值拷贝,我们能不能不形成值拷贝呢?
int& Add(int x, int y)
{
int c = x + y;
return c;
}
int main()
{
int a = 10;
int b = 20;
int& ret = Add(a, b);
cout << ret << endl;
return 0;
}
同样也可以输出。
但是这里有一个问题就是此时Add函数栈帧已经销毁了,已经还给操作系统了,但是还会去访问c,所以就会非法访问内存,所以这个用法是错误的。
举个例子:
此时ret的值就会被改变。我们也画图来分析:
所以ret的值会被改变。再看一个例子:
前面两个我们都能看懂,第三个为什么是这样呢?
这是我的理解!!那么有没有正确的使用方式呢?
这里就是正确的使用方式。
注意:如果函数返回时,出了函数作用域,如果返回对象还未还给系统,则可以使用引用返回,如果已经还给系统了,则必须使用传值返回。
6.5 传值、传引用效率比较
以值作为参数或者返回值类型,在传参和返回期间,函数不会直接传递实参或者将变量本身直接返回,而是传递实参或者返回变量的一份临时的拷贝,因此用值作为参数或者返回值类型,效率是非常低下的,尤其是当参数或者返回值类型非常大时,效率就更低。
例如:
#include <iostream>
#include <time.h>
using namespace std;
struct A
{
int a[10000];
};
void TestFunc1(A a)
{
}
void TestFunc2(A& a)
{
}
void TestRefAndValue()
{
A a;
size_t begin1 = clock();
for (int i = 0; i < 100000; i++)
{
TestFunc1(a);//将a整个结构体传过去,会形成值拷贝
}
size_t end1 = clock();
size_t begin2 = clock();
for (int i = 0; i < 100000; i++)
{
TestFunc2(a);//引用结构体传参,不会形成值拷贝
}
size_t end2 = clock();
cout << "TestFunc1 time:" << end1 - begin1 << endl;
cout << "TestFunc1 time:" << end2 - begin2 << endl;
}
int main()
{
TestRefAndValue();
return 0;
}
跑出来的时间就不一样的。传的结构体越大,值拷贝就越大,消耗的时间也越多。
总结:引用的作用主要体现在传参和传返回值
1.引用传参和传返回值,有些场景下面可以提高性能。(大对象+深浅拷贝)
2.引用传参和传返回值,输出型参数和输出型参数返回值。通俗的说,有些场景下面,形参的改变可以改变实参,有些场景下,引用返回,可以改变返回对象。
6.6 引用和指针的区别
在语法概念上引用就是一个别名,没有独立空间,和其引用实体共用同一块空间。
在底层实现上实际是有空间的,因为引用是按照指针方式来实现的。
引用和指针的不同点:
- 引用在定义时必须初始化,指针没有要求
- 引用在初始化时引用一个实体后,就不能再引用其他实体,而指针可以在任何时候指向任何一个同类型实体
- 没有NULL引用,但有NULL指针
- 在sizeof中含义不同:引用结果为引用类型的大小,但指针始终是地址空间所占字节个数(32位平台下占
4个字节) - 引用自加即引用的实体增加1,指针自加即指针向后偏移一个类型的大小
- 有多级指针,但是没有多级引用
- 访问实体方式不同,指针需要显式解引用,引用编译器自己处理
- 引用比指针使用起来相对更安全