C++ 入门：发展史、第一个程序、命名空间与输入输出

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;
}