C++入门基础：逐步剖析核心语法

项目中多文件中定义的同名namespace会认为是一个namespace，不会冲突。C++标准库都放在一个叫std(standard)的命名空间中。

3. 命名空间的使用

编译查找一个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间里面去查找。所以要使用命名空间中定义的变量/函数，有三种方式：

1. 指定命名空间访问，项目中推荐这种方式

#include<iostream>
using namespace std;
namespace jzx {
    int grade = 100;
    int time = 10;
}
int main() {
    int x;
    x = jzx::time; // 指定命名空间访问
    return 0;
}

2. using将命名空间中某个成员展开，项目中经常访问的不存在冲突的成员推荐这种方式。

#include<iostream>
using namespace std;
namespace jzx {
    int grade = 100;
    int time = 10;
}
using jzx::grade;
int main() {
    int x;
    x = jzx::time;
    int y = grade; // using将命名空间中某个成员展开
    return 0;
}

3. 展开命名空间中全部成员，项目不推荐，冲突风险很大，日常小练习程序为了方便推荐使用。

#include<iostream>
using namespace std;
namespace jzx {
    int grade = 100;
    int time = 10;
}
using jzx::grade;
using namespace jzx;
int main() {
    int x;
    x = jzx::time;
    int y = grade;
    return 0;
}

三、C++输入与输出

• 是Input Output Stream的缩写，是标准的输入、输出流库，定义了标准的输入、输出对象。
• std::cin是istream类的对象，它主要面向窄字符（narrow characters of type char）的标准输入流。
• std::cout是ostream类的对象，它主要面向窄字符的标准输出流。
• std::endl是一个函数，流插入输出时，相当于插入一个换行字符加刷新缓冲区。
• >>是流提取运算符。（C语言还用这两个运算符做位运算左移/右移）
• 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动指定格式，C++的输入输出可以自动识别变量类型 (本质是通过函数重载实现的)，其实最重要的是C++的流能更好的支持自定义类型对象的输入输出。
• IO流涉及类和对象，运算符重载、继承等很多面向对象的知识，这些知识我们还没有讲解，所以这里我们只能简单认识一下C++IO流的用法，后面我们会有专门的一个章节来细节IO流库。
• cout/cin/endl等都属于C++标准库，C++标准库都放在一个叫std(standard)的命名空间中，所以要通过命名空间的使用方式去用他们。
• 一般日常练习中我们可以using namespace std，实际项目开发中不建议using namespace std。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
int main() {
    int i;
    char ch;
    double d;
    cin >> i >> ch >> d;
    cout << i << ' ' << ch << ' ' << d << endl;
    scanf("%d %c%lf", &i, &ch, &d);
    printf("%d %c %.2lf", i, ch, d);
    return 0;
}

这样我们在使用的时候就顺手多了，但是当我们想要控制输出的几位小数或者占多少位置的时候我们C++也可以实现但是太过于麻烦，相比之下我们还是使用C语言的。

四、缺省参数

• 缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。（有些地方把缺省参数也叫默认参数）
• 全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。
• 带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。
• 函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。

#include<iostream>
using namespace std;
void fun(int a = 0) {
    cout << a << endl;
}
int main() {
    fun(); // 缺省
    fun(111);
    return 0;
}

全缺省示例：

#include<iostream>
using namespace std;
void fun(int a = 0) {
    cout << a << endl;
}
void fun1(int x = 1, int y = 2, int z = 3) {
    cout << x << " " << y << ' ' << z << endl;
}
int main() {
    fun(); // 缺省
    fun(111);
    fun1();
    fun1(11, 11, 11);
    return 0;
}

如果我们这样定义函数：

void fun1(int x = 1, int y, int z = 3) {
    cout << x << " " << y << ' ' << z << endl;
}

编译器将会报错，因为我们跳跃式的给缺省参数。我们必须从右到左的给缺省值。

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

当我们给函数的声明和定义都给了缺省值的时候我们的编译器也会报错。

五、函数重载

C++支持在同一作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同。这样C++函数调用就表现出了多态行为，使用更灵活。C语言是不支持同一作用域中出现同名函数的。

#include<iostream>
using namespace std;
// 参数类型不同
int add(int x, int y) {
    return x + y;
}
double add(double x, double y) {
    return x + y;
}
// 参数的个数不同
void f() {
    cout << "f()" << endl;
}
void f(int x) {
    cout << "f()" << endl;
}
int main() {
    return 0;
}

但是返回值不同的不能作为函数的重载。

还有一种特例：

void f1(int x = 1) {
    cout << 'f' << endl;
}
void f1() {
    cout << "f()" << endl;
}
int main() {
    f1();
    return 0;
}

因为第一个函数重载了，所以在调用函数的时候就会产生歧义，导致报错。

六、引用

1.引用的概念和定义

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

类型&引用别名=引用对象; C++中为了避免引入太多的运算符，会复用C语言的一些符号，比如前面的>，这里引用也和取地址使用了同一个符号**&**，大家使用方法角度区分就可以。

#include<iostream>
using namespace std;
int main() {
    int x = 10;
    int& a = x;
    int& b = x;
    cout << &a << endl;
    cout << &x << endl;
    cout << &b << endl;
    return 0;
}

在这里a ,b就是x的别名，他们的地址是相同的。

我们来对其中一个进行操作：

我们可以看到这个对他的别名的操作是会影响全部的，这实际上很容易理解，因为周树人和鲁迅都是同一个人。

2.引用的特性

• 引用在定义时必须初始化
• 一个变量可以有多个引用
• 引用一旦引用一个实体，再不能引用其他实体

#include<iostream>
using namespace std;
int main() {
    int a = 10;
    // 编译报错：'ra': 必须初始化引用
    //int& ra;
    int& b = a;
    int c = 20;
    // 这里并非让b引用c，因为C++引用不能改变指向，
    // 这里是一个赋值
    b = c;
    cout << &a << endl;
    cout << &b << endl;
    cout << &c << endl;
    return 0;
}

3.引用的使用

• 引用在实践中主要是于引用传参和引用做返回值中减少拷贝提高效率以及改变引用对象时同时改变被引用对象。
• 引用传参跟指针传参功能是类似的，引用传参相对更方便一些。
• 引用返回值的场景相对比较复杂，我们在这里简单讲了一下场景，还有一些内容后续类和对象章节中会继续深入讲解。
• 引用和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。C++的引用跟其他语言的引用 (如Java)是有很大的区别的，除了用法，最大的点，C++引用定义后不能改变指向，Java的引用可以改变指向。
• 一些主要用C代码实现版本数据结构教材中，使用C++引用替代指针传参，目的是简化程序，避开复杂的指针，但是很多同学没学过引用，导致一头雾水。

4.const引用

可以引用一个const对象，但是必须用const引用。const引用也可以引用普通对象，因为对象的访问权限在引用过程中可以缩小，但是不能放大。

因为我们本来的n就是只读不能修改的，你试想通过一个引用来改变这个值是不允许的，我们只能也用const的引用才行。

int b = 10;
const int& a = b;

这样是可以的，这就是我们所说的权限的缩小。

需要注意的是类似 int& rb = a*3; double d = 12.34; int& rd = d; 这样一些场景下a*3的和结果保存在一个临时对象中，int& rd = d也是类似，在类型转换中会产生临时对象存储中间值，也就是时，rb和rd引用的都是临时对象，而C++规定临时对象具有常性，所以这里就触发了权限放大，必须要用常引用才可以。

类型转化的时候也会创建临时常量。

5.指针和引用的关系

C++中指针和引用就像两个性格迥异的亲兄弟，指针是哥哥，引用是弟弟，在实践中他们相辅相成，功能有重叠性，但是各有自己的特点，互相不可替代。

• 语法概念上引用是一个变量的取别名不开空间，指针是存储一个变量地址，要开空间。
• 引用在定义时必须初始化，指针建议初始化，但是语法上不是必须的。
• 引用在初始化时引用一个对象后，就不能再引用其他对象；而指针可以在不断地改变指向对象。
• 引用可以直接访问指向对象，指针需要解引用才是访问指向对象。
• sizeof中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数 (32位平台下占4个字节，64位下是8byte)
• 指针很容易出现空指针和野指针的问题，引用很少出现，引用使用起来相对更安全一些。

七、内联函数

• 用inline修饰的函数叫做内联函数，编译时C++编译器会在调用的地方展开内联函数，这样调用内联函数就不需要建立栈帧了，就可以提高效率。
• inline对于编译器而言只是一个建议，也就是说，你加了inline编译器也可以选择在不展开，不同编译器关于inline什么情况展开各不相同，因为C++标准没有规定这个。inline适用于频繁调用的小函数，对于递归函数，代码相对多一些的函数，加上inline也会被编译器忽略。
• C语言实现宏函数也会在预处理时替换展开，但是宏函数实现很复杂很容易出错的，且不方便调试，C++设计了inline目的就是替代C的宏函数。
• VS编译器debug版本下面默认是不展开inline的，这样方便调试，debug版本想展开需要设置一下以下两个地方。
• inline不建议声明和定义分离到两个文件，分离会导致链接错误。因为inline被展开，就没有函数地址，链接时会出现报错。

因为我们在写宏定义的时候太过于繁琐，我们还容易写错，所以我们就可以使用C++中的inline函数。

当我们的代码量小的时候他会直接展开，不建立栈帧，当我们的代码量大的时候他还会像普通的函数一样进行。

#include<iostream>
using namespace std;
inline int add(int x, int y) {
    return x + y;
}
int main() {
    const int n = 10;
    //int& x = n;
    const int& x = n;
    int b = 10;
    const int& a = b;
    const int& y = b * 2;
    return 0;
}

在我们的inline函数的帮助下我们的宏定义就实现了进化，因为这个简单的a+b的问题在我们的宏定义中我们需要这么写：

#define add(x,y) ((x)+(y))

我们太容易丢失括号了。所以我们就舍弃了他。

八、nullptr

• C++中NULL可能被定义为字面常量0，或者C中被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，本想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，调用了f(intx)，因此与程序的初衷相悖。f((void*)NULL); 调用会报错。
• C++11中引入nullptr，nullptr是一个特殊的关键字，nullptr是一种特殊类型的字面量，它可以转换成任意其他类型的指针类型。使用nullptr定义空指针可以避免类型转换的问题，因为nullptr只能被隐式地转换为指针类型，而不能被转换为整数类型。

所以我们在C++中的空指针变成了nullptr。