入门C++这一篇就够了
●个人主页:你帅你先说.
●欢迎点赞关注收藏
●既选择了远方，便只顾风雨兼程。
●欢迎大家有问题随时私信我！
●版权：本文由[你帅你先说.]原创，CSDN首发，侵权必究。
Let's party!
- 1.C++关键字
- 2.命名空间
-
- 2.1 命名空间的定义
- ️2.2 命名空间的使用
- 3. C++输入&输出
- 4.缺省参数
- 5.函数重载
-
- 5.1函数重载概念
- 5.2extern C
- 6.引用
-
- 6.1 引用概念
- 6.2 引用特性
- 6.3使用场景
- 6.4传值、传引用效率比较
- 6.5常引用
- 6.6指针和引用的区别
- 7.内联函数
-
- 7.1内联函数概念
- 7.2内联函数特性
- 8.auto关键字(C++11)
-
- 8.1auto简介
- 8.2auto使用细则
- 8.3 auto不能推导的场景
- 9.基于范围的for循环(C++11)
- 10.指针空值nullptr(C++11)
1.C++关键字
相比于32个关键字的C语言，C++提供了63个关键字。
| asm | do | if | return | try | continue |
|---|---|---|---|---|---|
| auto | double | inline | short | typedef | for |
| bool | dynamic_cast | int | signed | typeid | public |
| break | else | long | sizeof | typename | throw |
| case | enum | mutable | static | union | wchar_t |
| catch | explicit | namespace | static_cast | unsigned | default |
| char | export | new | struct | using | friend |
| class | extern | operator | switch | virtual | register |
| const | false | private | template | void | true |
| const_cast | float | protected | this | volatile | while |
| delete | goto | reinterpret_cast |
我们发现，里面的有些关键字在C语言阶段我们已经学过了。
2.命名空间
2.1 命名空间的定义
在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。
1.命名空间的使用
举个:
int rand = 0;
这段代码这样写一点问题都没有
但如果我们引入头文件
#include系统就会报出rand重定义的错误。
简单来说就是你命名的变量和函数库的变量重名了，针对于这个问题，C语言没办法很好的解决这个问题。所以C++就有了命名空间来解决这个问题。
刚刚我们讲的关键字里我们注意到有一个叫namespace的关键字，也就是命名空间。
有了命名空间我们对上面的代码进行修改
#include此时rand和库里的rand形成了一层屏障，相当于是一个域。编译器自己不会去访问这个域，只有我们手动才能访问到域里的内容。
printf("%d",MY::rand);
此时才可以访问到域里的内容。
如果::左边为空,那就默认到全局域里去找。即可通过这种方式访问全局变量。虽然这些变量是在域里，但域里的变量还是属于全局变量，放在静态区。
:命名空间只能定义在全局。
2.与函数不同，命名空间是可以嵌套定义的。
namespace m
{
int rand = 0;
namespace n
{
int random = 0;
}
}
//此时如果要访问random
printf("%d",m::n::rand);
3.同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成在一个命名空间中。
️2.2 命名空间的使用
命名空间的使用有三种方式：
●加命名空间名称及作用域限定符:
int main()
{
printf("%d\n", MY::rand);
return 0;
}
●使用using将命名空间中成员引入
using MY::b;
int main()
{
printf("%d\n", rand);
return 0;
}
●使用using namespace 命名空间名称引入
using namespce MY;//将命名空间里的内容全部展开
int main()
{
printf("%d\n", rand);
return 0;
}
第三种方式将命名空间里的内容全部展开，虽然方便了，但命名空间形成的屏障就消失了。所以在大型项目中，这种方法要慎用。
3. C++输入&输出
C++的第一行代码:
#include输入流
int main()
{
int a
cin>>a;//>>流提取
}
相比于scanf，cin可以自动识别类型，不需要%d，%c等来区别变量类型。
输出流
int main()
{
int a
cin>>a;
cout<<a<<endl;//endl等价于"\n"
//<<流插入
}
与cin类似，相比于printf，cout也可以自动识别类型。
:使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含< iostream >头文件以及std标准命名空间
4.缺省参数
缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参
void TestFunc(int a = 0)
{
cout<<a<<endl;
}
int main()
{
TestFunc(); // 没有传参时，使用参数的默认值，输出0
TestFunc(10); // 传参时，使用指定的实参，输出10
}
像这种函数的每个参数都有缺省值的我们叫它全缺省参数
void Fun(int a = 10,int b = 5,int c = 1)
{
cout<<a<<b<<c<<endl;
}
既然有了全缺省，对应的就会有半缺省，但半缺省不是缺省不是缺省一半，而是部分缺省，且必须从右往左连续缺省。
void Fun(int a,int b,int c = 1)
{
cout<<a<<b<<c<<endl;
}
:
1.缺省参数不能在函数声明和定义中同时出现
2.缺省参数必须是常量或者全局变量
3.C语言不支持缺省参数
5.函数重载
5.1函数重载概念
函数重载是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表 (参数个数 或 类型 或 顺序) 必须不同，常用来处理实现功能类似数据类型不同的问题。
//1.参数类型不同
int Add(int left, int right)
{
return left+right;
}
double Add(double left, double right)
{
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;
}
:不能通过返回值的不同来构成重载
举个:
void fun(int a)
{
cout<<a<<endl;
}
int fun(int a)
{
return a;
}
此时如果你调用fun(1)，系统无法区分你要调用的是哪个。
只有满足以上三个条件中的任何一个才能构成重载，其余情况均不构成重载。
那么C语言支持函数重载吗?
答案是不支持。
为什么呢？
这一块要涉及到的知识比较复杂，在这边先简单的讲一下。
C语言区分函数只是简单的从函数名来区分，而C++则是通过函数名长度、函数名、函数参数来区分函数的，比如f()函数，(linux环境)系统中是这样来标识的 _Z1fv 1是函数名长度，f是函数名，v是函数参数首字母，v就是void，再举个例子，func(int i,double x)，系统中就是 _Z4funcid这样来标识。
讲完了知识点我们来道题巩固一下
这道题很明显是选B，刚刚讲过参数个数不同可以构成重载。但这题我想说的远不止这些，这题我要是在主函数中f(10)调用函数可以吗？可能很多人会想传了一个参数那调用的就是void f(int)这个声明对应的函数，但你没有注意到第一个函数的第二个参数是缺省参数，当你f(10)调用函数时编译器他不知道该调用哪个函数,因为你有缺省参数，传一个值也是可以的。所以这道题虽然定义正确，函数也可以重载，但却会造成二义性，这也提醒我们，不是函数能重载就没问题了，还得看可不可以正常调用。
5.2extern C
有时候在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern “C”，意思是告诉编译器，将该函数按照C语言规则来编译。比如：tcmalloc是google用C++实现的一个项目，他提供tcmallc()和tcfree两个接口来使用，但如果是C项目就没办法使用，那么他就使用extern “C”来解决。
6.引用
6.1 引用概念
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
:
void TestRef()
{
int a = 10;
int& aa = a;//<====定义引用类型
printf("%p\n", &a);
printf("%p\n", &aa);
}
:引用类型必须和引用实体是同种类型的。
6.2 引用特性
1. 引用在定义时必须初始化
int a = 10;
int& b;//error
int& b = a;//正确用法
2. 一个变量可以有多个引用
int a = 10;
int& b = a;
int& c = a;
int& d = b;//这样也可以
3. 引用一旦引用一个实体，再不能引用其他实体
int a = 10;
int& b = a;
int c = 20;
b = c;//这段代码的含义是将c的值赋给b，不是把b变成c的别名
到目前为止，swap函数我们已经学了三种方法
void swap(int* p1, int* p2) // 传地址
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
void swap(int& r1, int& r2) // 传引用
{
int tmp = r1;
r1 = r2;
r2 = tmp;
}
void swap(int r1, int r2) // 传值
{
int tmp = r1;
r1 = r2;
r2 = tmp;
}
// 它们三个构成函数重载
// 但是swap(x, y)调用时存在歧义，他不知道调用传值还是传引用
6.3使用场景
1. 做参数
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}
2. 做返回值
我们先来回顾一下函数传值返回的过程
int add(int a,int b)
{
int c = a+b;
return c;
}
int main()
{
int ret = add(1,3);
cout<<ret<<endl;
return 0;
}
当函数返回值的时候，不是把c的值赋给ret，换句话说不是把c给返回，而是把c的拷贝给返回。什么意思呢？当函数返回值时，会把c的值放在一个临时变量中，再通过这个临时变量把值赋给ret。这个时候你是否有疑惑这个临时变量是什么？实际上，这个临时变量在c比较小时一般是寄存器充当，如果c较大，临时变量放在调用Add函数的栈帧中。
那么如果引用做返回值，这段程序会发生什么？
int& add(int a,int b)
{
int c = a+b;
return c;
}
int main()
{
int ret = add(1,3);
cout<<ret<<endl;
return 0;
}
在这里引用返回的意思就是不会生成c的拷贝返回，直接返回c的引用。
这样就会导致一下两个问题:
1.存在非法访问，因为add(1,3)的返回值是c的引用，所以add栈帧销毁了以后，会去访问c位置空间。
2.如果add函数栈帧销毁，清理空间，那么取c值的时候就是取到随机值，给ret就是随机值。
说了这么多，无非就是想告诉你引用返回适用于出 了函数作用域，返回对象还没被销毁的情况。
:
int& Count()
{
static int n = 0；
n++;
return n;
}
n是个静态变量，放在静态区，出了函数作用域不会被销毁，此时就可以用引用返回。
我们再来看一个引用的应用
const int N = 10;
int& At(int i)
{
static int a[N];
return a[i];
}
int main()
{
for(int i = 0;i<N;i++)
{
At(i) = 10+i;//写入
}
for(int i = 0;i<N;i++)
{
cout<<At(i)<<" ";//读出
}
cout<<endl;
}
这样写相当于给函数写入值。但如果把At函数里的&去掉就会出错，因为去掉后At(i)的值就是个临时变量，临时变量具有常属性，是右值。
6.4传值、传引用效率比较
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
所以当要处理的数据很多的情况下，用引用传参和传返回值的效率更高。
6.5常引用
//权限放大
const int a = 10;
int& b = a;
这段代码有没有问题？
答案是有。
a已经被赋予了常属性，再让b变成a的引用，只要类型前面没有const就是默认可以修改的，所以要在int前再加一个const。
//权限不变
const int a = 10;
const int& b = a;
这段代码的意思是a、b的值都是10且b是a的常引用，且都不可更改。
这种情况也是支持的
//权限缩小
int c = 10;
const int& d = c;
常属性这还有一块需要注意的
//1.
double d = 11.98;
int i = d;
//2.
double d = 11.98;
int& i = d;
//3.
double d = 11.98;
const int& i = d;
这三种写法有什么区别呢?
首先我们先看第一种，将double类型的d赋值给int类型的d，我们C语言学过，这是允许的，只是d会发生截断，那这个截断过程是什么样的呢?实际上是会把d的截断部分先存在一个临时变量里再赋值给i。这样你就会发现第二种写法是有问题的，为什么呢？同样是把截断部分存在临时变量里让i作为临时变量的引用，但临时变量具有常属性，是不能被修改的，所以第三种写法才是正确的。(临时变量不是局部变量，这是两个完全不同的概念)
学到这我们发现const Type& 是通吃所有类型的，可以接收任何类型的变量。
所以我们建议如果函数函数中不改变参数的值，建议使用const&。
学到这，可能有人会有疑惑
int a = 10;
int& b = a;
b存在哪呢？
我们知道临时变量是存在栈区的。有的人就会以为存在栈里是这样的
这样想就错了。
不管是a还是b它都不会存在栈区，栈区存的是值，而a和b是属于符号，是存在符号表里的，通过符号表里的地址标识去访问栈区。
6.6指针和引用的区别
- 引用在定义时必须初始化，指针没有要求
- 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
- 没有NULL引用，但有NULL指针
- 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占
4个字节) - 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
- 有多级指针，但是没有多级引用
- 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
- 引用比指针使用起来相对更安全
从底层来看，我们来讨论一下它们的区别。
你会发现，指针和引用是两个完全不同的概念，指针是开辟空间，存储变量地址，而引用不开辟空间，仅仅是对变量取别名，但它们的底层实现是完全一样的。底层这一块大家只需了解一下就行，平时在用的时候不要去想底层。
7.内联函数
7.1内联函数概念
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率。
举个:
inline int Add(int x,int y)
{
ret = x+y;
return ret;
}
int main()
{
int ret = Add(1,2);
cout<<ret<<endl;
}
此时编译器不会调用函数，也就是不会创建栈帧，而是把函数里的内容进行展开，这有点类似于宏的替换。
有了inline函数，我们就不需要用C的宏，因为宏很复杂，很容易出错。
7.2内联函数特性
- inline是一种以空间换时间的做法，省去调用函数额开销。 所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
- inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等，编译器优化时会忽略掉内联。
- inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。
8.auto关键字(C++11)
8.1auto简介
在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但后来我们发现我们正常定义变量，它也是具有自动存储器的局部变量，所以就没有人用它。
C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。
什么意思呢？
int a = 0;
char b = 'b';
double c = 3.14;
//自动推导类型
auto d = a;//推导出类型为int
auto e = b;//推导出类型为char
auto f = c;//推导出类型为double
我们用程序去验证
8.2auto使用细则
- auto与指针和引用结合起来使用
用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
int main()
{
int x = 10;
auto a = &x;
auto* b = &x;
auto& c = x;
cout << typeid(a).name() << endl;
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;
*a = 20;
*b = 30;
c = 40;
return 0;
}
2. 在同一行定义多个变量
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
void TestAuto()
{
auto a = 1, b = 2;
auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}
8.3 auto不能推导的场景
1.auto不能作为函数的参数
// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}
2.auto不能直接用来声明数组
void TestAuto()
{
int a[] = {1,2,3};
auto b[] = {4，5，6};
}
9.基于范围的for循环(C++11)
在C++98中如果要遍历一个数组，可以按照以下方式进行：
int main()
{
int array[] = { 1, 2, 3, 4, 5 };
//C/C++ 遍历数组
for (int i = 0; i < sizeof(array) / sizeof(int); ++i)
{
cout << array[i] << endl;
}
}
对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。（这个我们也俗称语法糖）
int main()
{
int array[] = { 1, 2, 3, 4, 5 };
for (auto e : array)//auto也可以换成其它类型，但一般用auto
{
cout << e << endl;
}
}
还可以用范围for给数组每个元素+1
int main()
{
int array[] = { 1, 2, 3, 4, 5 };
for (auto& e : array)//auto也可以换成其它类型，但一般用auto
{
e++;
}
//array必须是数组名，不能是一个指针
}
10.指针空值nullptr(C++11)
在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：
int main()
{
int* p1 = NULL;
int* p2 = 0;
return 0;
}
NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如
void f(int)
{
cout<<"f(int)"<<endl;
}
void f(int*)
{
cout<<"f(int*)"<<endl;
}
int main()
{
f(0);
f(NULL);
f((int*)NULL);
return 0;
}
程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强制类型转换(void*)0。
:
1.在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
2.在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
3.为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。
看到这，恭喜你，你已经成功入门了。
这样的文章你还不快点赞关注收藏⭐
:悄悄告诉你长按⭐️可一键三连！