C++ 入门：发展历史、命名空间与输入输出详解

2. 学习书籍推荐

• C++ Primer：主要讲解语法，经典的语法书籍，前后中期都可以看，前期如果自学看可能会有点晦涩难懂，能看懂多少看懂多少，中后期作为语法字典，非常好用。
• STL 源码剖析：主要从底层实现的角度结合 STL 源码，庖丁解牛式剖析 STL 的实现，是侯捷老师的经典之作。可以很好的帮助我们学习别人用语法是如何实现出高效简洁的数据结构和算法代码，如何使用泛型封装等。让我们不再坐井观天，闭门造车，本书课程上一半以后，中后期可以看。
• Effective C++：这本书也是侯捷老师翻译的，本书有的⼀句评价，把 C++ 程序员分为看过此书的和没看过此书的。本书主要讲了 55 个如何正确高效使用 C++ 的条款，建议中后期可以看一遍，工作 1-2 年后再看一遍，相信会有不一样的收获。

C++ 的第一个程序

C++ 兼容 C 语言绝大多数的语法，所以 C 语言实现的 hello world 依旧可以运行，C++ 中需要把定义文件代码后缀改为.cpp，vs 编译器看到是.cpp 就会调用 C++ 编译器编译，linux 下要用 g++ 编译，不再是 gcc。

// 这里使用的是 test.cpp
#include<stdio.h>
int main() {
    printf("Hello World\n");
    return 0;
}

然而 C++ 有自己的一套输入输出设备，所以在 C++ 中的 hello world 应该是这样：

#include<iostream>
using namespace std;
int main() {
    cout << "hello world\n" << endl;
    return 0;
}

命名空间

1. namespace 的价值

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

C 语言项目类似下面程序这样的命名冲突是普遍存在的问题，C++ 引入 namespace 就是为了更好的解决这样的问题。

// 命名冲突
#include<stdio.h>
#include<stdlib.h>
int rand = 10;
int main() {
    // 编译报错：error C2365: 'rand': 重定义；以前的定义是'函数'
    printf("%d", rand);
    return 0;
}

报错如图：

因为库函数 stdlib.h 中已经定义了 rand，所以 C 语言就无法运行这串代码了。但在 C++ 的输入输出中就可以用 namespace 来解决这个问题。

2. namespace 的定义

• 定义命名空间，需要使用到 namespace 关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。命名空间中可以定义变量/函数/类型等。
• namespace 本质是定义出一个域，这个域跟全局域各自独立，不同的域可以定义同名变量，所以下面的 rand 不在冲突了。
• C++ 中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找一个变量/函数/类型出处 (声明或定义) 的逻辑，所有有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不影响变量生命周期。
• namespace 只能定义在全局，当然他还可以嵌套定义。
• 项目工程中多文件中定义的同名 namespace 会认为是⼀个 namespace，不会冲突。
• C++ 标准库都放在⼀个叫 std(standard) 的命名空间中。

1）使用 namespace 来命名空间，以及使用命名空间

#include<stdio.h>
#include<stdlib.h>
namespace A //A 是命名空间的名字，一般开发中是用项目名字做命名空间名
{
    // 命名空间中可以定义变量/函数/类型
    int rand = 10;
    int ADD(int a,int b) {
        return a + b;
    }
    struct Node {
        struct Node* next;
        int val;
    };
}//注意这里没有分号！！
int a = 1;
int main() {
    //编译器语法查找确认规则是默认先局部查找->全局查找->没有找到就报未声明的标识符这个错误
    //::域作用限定符，这里指定作用域，就直接按这个域去找->没有找到就报未声明的标识符这个错误
    int a = 0;
    printf("%d\n", a);
    printf("%d\n", ::a);//::前面不加域就是默认全局域！不会到命名空间里查找！
    printf("%p\n", rand);//这里的 rand 是 stdlib.h 中的指针，要用%p 访问
    printf("%d\n", A::rand);//这里访问的就是 A 域中的 rand
    printf("%p\n", A::ADD);
    printf("%d\n", A::ADD(1, 2));//这里是直接调用该函数
    //A::struct Node node;//这是错误的
    struct A::Node node;
    return 0;
}

这个程序的运行结果如下：

！！！这里需要注意的是命名空间域不会影响变量的生命周期（是一个全局的生命周期）。

2）命名空间的嵌套使用

#include<stdio.h>
#include<stdlib.h>
//命名空间的嵌套使用
namespace A {
    namespace a {
        int rand = 10;
        int ADD(int a,int b) {
            return a + b;
        }
    }
    namespace b {
        int rand = 20;
        int ADD(int a, int b) {
            return (a + b) * 10;
        }
    }
}
int main() {
    printf("%d\n", A::a::rand);
    printf("%d\n", A::b::rand);
    printf("%d\n", A::a::ADD(1, 2));
    printf("%d\n", A::b::ADD(1, 2));
    return 0;
}

程序的运行结果如下：

命名空间的嵌套可以嵌套很多层，但是不推荐，因为那样写起来也很不方便~

我们在项目中经常会用到命名空间的嵌套，大家可以看下面的图片来理解一下

3）多文件定义的命名空间问题

多文件中可以定义同名 namespace，他们会默认合并在一起，就像同一个 namespace 一样。下面给大家简单演示一下~

test.cpp

#include<stdio.h>
#include<stdlib.h>
#include"Stack.h"
#include"Queue.h"
int main() {
    st::stack s1;
    st::Init(&s1);
    st::Push(&s1, 1);
    st::Push(&s1, 2);
    st::Pop(&s1);
    queue::Queue q1;
    queue::Init(&q1);
    queue::Push(&q1, 1);
    queue::Push(&q1, 2);
    queue::Pop(&q1);
    return 0;
}

stack.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
namespace st {
    typedef int STDataType;
    typedef struct stack {
        STDataType* arr;
        int top;
        int capacity;
    }stack;
    void Init(stack* ps);
    void Push(stack* ps, STDataType x);
    void Pop(stack* ps);
}

stack.cpp

#include"Stack.h"
namespace st {
    void Init(stack* ps) {
        //......
    }
    void Push(stack* ps, STDataType x) {
        //...
    }
    void Pop(stack* ps) {
        //...
    }
}

queue.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
namespace queue {
    typedef int QDataType;
    typedef struct QueueNode {
        QDataType data;
        struct QueueNode* next;
    }QueueNode;
    typedef struct Queue {
        QueueNode* phead;
        QueueNode* ptail;
    }Queue;
    void Init(Queue* pq);
    void Push(Queue* pq, QDataType x);
    void Pop(Queue* pq);
}

queue.cpp

#include"Queue.h"
namespace queue {
    void Init(Queue* pq) {
        //......
    }
    void Push(Queue* pq, QDataType x) {
        //...
    }
    void Pop(Queue* pq) {
        //...
    }
}

3. namespace 命名空间的使用

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

• 指定命名空间访问，项目中推荐这种方式。
• using 将命名空间中某个成员展开，项目中经常访问的不存在冲突的成员推荐这种方式。
• 展开命名空间中全部成员，项目不推荐，冲突风险很大，日常小练习程序为了方便推荐使用。

1）指定命名空间访问

#include<iostream>//C++ 中不需要带.h
#include<algorithm>
int main() {
    int a[5] = { 4,1,2,5 };
    // 指定命名空间访问
    std::sort(a, a + 4);
    return 0;
}

2）using 将命名空间中某个成员展开

#include<iostream>
#include<algorithm>
//命名空间中成员部分展开
using std::cout;
using std::cin;
int main() {
    int a, b;
    cin >> a >> b;//输入
    cout << a << " " << b << '\n';//输出
    return 0;
}

在这里我们可以看到部分展开了之后 cout 就不需要在前面加东西了，但是 cin 前面还是需要加 std 的。这个展开方式还是推荐在大型项目中使用的~

3）展开命名空间中全部成员

#include<iostream>
#include<algorithm>
//命名空间中成员全部展开
using namespace std;
int main() {
    int a, b;
    cin >> a >> b;//输入
    cout << a << " " << b << '\n';//输出
    return 0;
}

这里就是把 std 中的所有成员全部展开，在做算法题或者小程序没有命名冲突的情况下可以使用，而且使用起来比较方便，但是在大型项目中就不推荐使用了~

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。
• 这里我们没有包含 <stdio.h>，也可以使用 printf 和 scanf，在包含间接包含了。vs 系列编译器是这样的，其他编译器可能会报错。

举例说明：

#include<iostream>
int main() {
    int i = 100;
    double b = 1.11000;
    //任何变量都会转换成字符串，插入到流中
    //cout 会自动识别
    std::cout << i << "\n";
    std::cout << b << "\n";
    std::cout << "hello world" << std::endl;//end line
    std::cout << "hello" << " " << "world" << std::endl;
    std::cin >> i >> b;//cin 是输入
    std::cout << i << " " << b << std::endl;//cout 是输出
    return 0;
}

换行用 '\n' 的效率会比使用 endl 更高，除此以外，cout 和 cin 的效率其实也是不如 printf 和 scanf 的，但是 printf 和 scanf 不能处理类（也就是更复杂的类型），而 C++ 的 IO 流支持复杂类型的输入输出。在 C++ 的 IO 流中我们可以通过取消同步流的操作来解决这个问题，代码如下：

#include<iostream>
using namespace std;
int main() {
    // 在 io 需求比较高的地方，如部分大量输入的竞赛题中，加上以下 3 行代码
    // 可以提高 C++IO 效率
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    return 0;
}