c++入门

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<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这样来标识。
讲完了知识点我们来道题巩固一下

这道题很明显是选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;
1
2
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