C++入门基础初识

什么是C++?

C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。为了解决软件危机，20世纪80年代，计算机界提出了OOP(object oriented programming：面向对象) 思想，支持面向对象的程序设计语言应运而生。
 1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此，C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。

C++的发展史

1979年，贝尔实验室的本贾尼等人试图分析unix内核的时候，试图将内核模块化于是在C语言的基础上进行扩展，增加了类的机制，完成了一个可以运行的预处理程序，称之为C with classes。

语言的发展也是随着时代的进步，在逐步递进的，让我们来看看C++的历史版本：

C++关键字(C++98)

C++中总计有63个关键字（红圈是C学习过的）：

---

命名空间

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

命名空间的定义

定义命名空间，需要使用到 namespace 关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。

1.命名空间的普通定义

namespace pride
{
    //可以定义变量、函数等
    int a;
    int sub(int x, int y)
    {
        return x - y;
    }
}

2.命名空间的嵌套定义 

namespace pride
{
    //可以定义变量、函数等
    int a;
    int sub(int x, int y)
    {
        return x - y;
    }
    namespace puond
    {
        int c;
        double d;
    }
}

3.同一个工程允许存在多个名称相同的命名空间，编译器最后会将其成员合成在同一个命名空间中。（所以同一个名称的命名空间不能有相同的变量成员）

ps:命名空间的出现定义了一个新的作用域，命名空间所有的变量成员局限于此空间。

命名空间的使用

1.加命名空间名称及作用域限定符   （：：在c++中叫做作用域限定符）

int main()
{
    pride::a = 10;
    int ret=pride::sub(2, 1);
    printf("%d %d", pride::a, ret);
}

 2.使用using将命名空间中的成员引入

using pride::a;
using pride::sub;
int main()
{
    a = 10;
    int ret=sub(2, 1);
    printf("%d %d", a, ret);
}

3.使用using namespace 命名空间名称展开

using namespace pride;
int main()
{
    a = 10;
    int ret=sub(2, 1);
    printf("%d %d", a, ret);
}

---

C++中的输入和输出 （cout---cin）

 C语言中有标准输入输出函数scanf和printf，而在C++中有cin标准输入和cout标准输出。在C语言中使用scanf和printf函数，需要包含头文件stdio.h。在C++中使用cin和cout，需要包含头文件iostream以及std标准命名空间的展开。C++的输入输出不需要增加数据格式控制，相比c更加方便。

#include<iostream>
using namespace std;

int main()
{
    int a;
    double d;
    cin >> a;
    cin >> d;
    cout << a << " " << d << endl;
    return 0;
}

---

缺省参数

概念：缺省参数是指在声明或定义函数时，为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参。

int add(int x = 10, int y = 20)
{
    return x + y;
}
int main()
{
    int ret1 = add();//没传实参，使用函数的默认形参，值为30
    int ret2 = add(1, 2);//传实参1和2，值为3
    cout << ret1 << " " << ret2 << endl;
}

缺省参数分类

全缺省参数

int add(int x = 10, int y = 20, int z = 3)
{
    return x + y + z;
}

 半缺省参数（函数的参数不全为缺省参数）

int add(int x, int y, int z = 3)
{
    return x + y + z;
}

注意：

1.半缺省参数必须从右往左依次给出，不能间隔。 

2.缺省参数不能在函数声明和定义中同时出现。

int add(int x, int y, int z = 3);//声明有缺省参数
int add(int x, int y, int z)
{
    return x + y + z;
}

int add(int x, int y, int z);
int add(int x, int y, int z = 3)//定义有缺省参数
{
    return x + y + z;
}

//不能同时出现缺省参数

3.缺省值必须是常量或者全局变量。

 int a = 3;//a是全局变量
int add(int x, int y, int z = a)
{
    return x + y + z;
}

---

函数重载 

概念：C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表必须不同。函数重载常用来处理实现功能类似，而数据类型不同的问题。

形参列表三不同即构成重载：1.参数类型不同  2.参数个数不同  3.参数顺序不同 

返回值不同不能作为重载依据。

int add(int x, int y)
{
    return x + y;
}
double add(double x, double y)
{
    return x + y;
}
int main()
{
    cout << add(1, 2) << endl;
    cout << add(1.1, 2.2) << endl;
    return 0;
}

函数重载的原理

一个C/C++程序要运行起来都需要经历以下几个阶段：预处理-编译-汇编-链接

编译阶段会将程序中的每个源文件的全局范围的变量符号分别进行汇总。在汇编阶段会给每个源文件汇总出来的符号分配一个地址（若符号只是一个声明，则给其分配一个无意义的地址），然后分别生成一个符号表。最后在链接期间会将每个源文件的符号表进行合并，若不同源文件的符号表中出现了相同的符号，则取合法的地址为合并后的地址（重定位）

在C语言中，汇编阶段进行符号汇总时，一个函数汇总后的符号就是其函数名，所以当汇总时发现多个相同的函数符号时，编译器便会报错。C++在进行符号汇总时，对函数的名字修饰做了改动，函数汇总出的符号不再只是函数的函数名，而是通过其参数的类型和个数以及顺序等信息汇总出 一个符号，这样一来，就算是函数名相同的函数，只要其参数的类型或参数的个数或参数的顺序不同，那么汇总出来的符号也就不同了。（不同的编译器处理不同，但原理一样）

总结：这就是C不支持函数重载的原因，它无法区分相同的函数名，而C++依靠形参列表的不同，修饰出来的名字能够区分，这样也说明函数重载与返回值没有关系。

extern “C”

有时候会在c++工程中需要用c的风格处理函数或者工程，就需要在相应位置加上extern "C"{}。

---

引用

概念：引用不是定义一个变量，而是已存在的变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

int main()
{
    int a = 10;
    int& b = a;//类型& 引用变量名(对象名) = 引用实体
    b = 20;//改变b等于改变a,同一片空间
    cout << a << endl;//打印20
}

引用类型必须和引用实体是同种类型。

特性：

1.引用在定义时必须被初始化

int a = 10;
int& b = a;

2.一个变量可以有多个引用

int a = 10;
int& b = a;
//int& c;错误写法，没初始化
 int& c = a;

变量a有两个别名（两个引用），分别是b和c。

3.引用一旦有了一个实体，不能在是其他变量的引用。 

int a = 10;
int& b = a;

int c = 20;
int& b = c;//错误，b已经是a的引用

常引用 

我们若用一个普通引用类型去引用其对应的类型，但该类型被const所修饰，那么引用将不会成功。

int main()
{
    const int a = 10;
    //int& b = a;错误，这里权限扩大，a是只读的，而b是可读可写的
    const int& b = a;

     int c = 10;

     const int& d = c;//正确，权限缩小，c可读可写，d只可读，也是对c的一种保护

}

引用的使用场景

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 << " " << b << endl;
}

引用做参数，这里相当于x是a的别名，y是b的别名，改变x和y就是改变a,b。这样不需要指针作为形参。

2.引用做返回值 

注意：做返回值时不能是函数的局部变量，因为这种变量会随着函数栈帧的结束而销毁，这样非法访问这片空间。返回的数据必须是被static修饰或者是动态开辟的或者是全局变量等不会随着函数调用的结束而被销毁的数据。

引用和指针的区别（重要）

1.引用必须初识化，而指针可以不初始化
2.引用一旦引用实体，不能在引用其他实体，指针可以指向任何同类型的其他变量
3.没有空引用，但有空指针
4、在sizeof中的含义不同：引用的结果为引用类型的大小，但指针始终是地址空间所占字节个数
5、引用进行自增操作就相当于实体增加1，而指针进行自增操作是指针向后偏移一个类型的大小。
6、没有多级引用，但是有多级指针。
7、访问实体的方式不同，指针需要解引用显示，而引用是编译器自己处理。
8、引用比指针使用起来相对更安全。

---

内联函数

概念：以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数的使用可以提升程序的运行效率。（就是为了解决简单但是频繁调用的函数，c用宏，但是宏的书写容易出错）

inline int Add(int x, int y)
{
    return x + y;
}
int main()
{
    int ret = Add(1, 2);
    cout << ret << endl;
} 

宏的写法

书写很容易出错，需要谨记替换原则，

#define Add(x,y) ((x)+(y))
int main()
{
    int ret = Add(1, 2);
    cout << ret << endl;
}

特性

1、inline是一种以空间换时间的做法，省了去调用函数的额外开销。由于内联函数会在调用的位置展开，所以代码很长或者有递归的函数不适宜作为内联函数。频繁调用的小函数建议定义成内联函数。
2、inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有递归等，编译器优化时会忽略掉内联。
3、inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了链接就会找不到。
 

---

auto关键字(C++11)

auto简介

在C++11中，标准委员会赋予了auto全新的含义：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

int main()
{
    int a = 10;
    auto b = a;
    auto c = 'a';
    auto d = "pride";
    cout << typeid(b).name() << endl;//打印结果为int
    cout << typeid(c).name() << endl;//打印结果为char
    cout << typeid(d).name() << endl;//打印结果是char const *
}

auto的使用细则 

1.auto与指针和引用结合起来使用（用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时必须加&，否则创建的只是与实体类型相同的普通变量）

2.当在同一行声明多个变量时，这些变量必须是相同的类型

auto不能推导的场景

1.auto不能作为函数的参数 

2.auto不能直接用来声明数组

---

基于范围的for循环(C++11)

C++98中遍历一个数组

int main()
{
    int a[] = { 7,27,1,21,0,5 };
    int len = sizeof(a) / sizeof(int);
    for (int i = 0; i < len; i++)
    {
        printf("%d ", a[i]);
    }
    return 0;
}

C++11中引入了基于范围的for循环。for循环后的括号由冒号分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

int main()
{
    int a[] = { 7,27,1,21,0,5 };
    for (auto i:a)
    {
        printf("%d ", i);
    }
    return 0;
}

for循环迭代的范围必须是确定的

---

C++11中的指针空值

对于C++98中的问题，C++11引入了关键字nullptr

1.在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为关键字引入的。
2.在C++11中，sizeof(nullptr)与sizeof((void*)0)所占的字节数相同。
3.为了提高代码的健壮性，在后序表示指针空值时建议最好使用nullptr。