入门C++这一篇就够了

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内联函数特性
🥳1.C++关键字
相比于32个关键字的C语言，C++提供了63个关键字。

我们发现，里面的有些关键字在C语言阶段我们已经学过了。

🎤2.命名空间
🎶2.1 命名空间的定义
在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

1.命名空间的使用
举个🌰:

int rand = 0;

这段代码这样写一点问题都没有
但如果我们引入头文件

#include<stdlib.h>

系统就会报出rand重定义的错误。
简单来说就是你命名的变量和函数库的变量重名了，针对于这个问题，C语言没办法很好的解决这个问题。所以C++就有了命名空间来解决这个问题。
刚刚我们讲的关键字里我们注意到有一个叫namespace的关键字，也就是命名空间。
有了命名空间我们对上面的代码进行修改

#include<stdlib.h>
namespace MY
{
    int rand = 0;
}

此时rand和库里的rand形成了一层屏障，相当于是一个域。编译器自己不会去访问这个域，只有我们手动才能访问到域里的内容。

printf("%d",MY::rand);
1
此时才可以访问到域里的内容。
如果::左边为空,那就默认到全局域里去找。即可通过这种方式访问全局变量。虽然这些变量是在域里，但域里的变量还是属于全局变量，放在静态区。
💡:命名空间只能定义在全局。
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<iostream>//C++的库 输入输出流
using namespace std;//C++库的实现定义在一个叫std的命名空间中
int main()
{
    cout<<"hello world"<<endl;
    return 0;
}

输入流

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这样来标识。

💐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&。

🎊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被展开，就没有函数地址了，链接就会找不到。
看到这，恭喜你，你已经成功入门了。
————————————————
版权声明：本文为CSDN博主「你帅你先说.」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_52363432/article/details/121531583