【C++】-1-C++入门基础（1）：C++入门基础，C++参考文档，C++的重要性，C++学习建议和书籍推荐，C++的第一个程序，命名空间，C++输入&输出，问题与总结

---

🦆 个人主页：深邃-

❄️专栏传送门：《C语言》《数据结构与算法》《Web安全》《C++》
🌟Gitee仓库：《C语言》《数据结构与算法》《C++》

---

C++入门基础

1. C++发展历史

C++的起源可以追溯到1979年，当时Bjarne Stroustrup(本贾尼·斯特劳斯特卢普，这个翻译的名字不同的地方可能有差异)在贝尔实验室从事计算机科学和软件工程的研究工作。面对项目中复杂的软件开发任务，特别是模拟和操作系统的开发工作，他感受到了现有语言（如C语言）在表达能力、可维护性和可扩展性方面的不足。

1983年，Bjarne Stroustrup在C语言的基础上添加了面向对象编程的特性，设计出了C++语言的雏形，此时的C++已经有了类、封装、继承等核心概念，为后来的面向对象编程奠定了基础。这一年该语言被正式命名为C++。

在随后的几年中，C++在学术界和工业界的应用逐渐增多。一些大学和研究所开始将C++作为教学和研究的首选语言，而一些公司也开始在产品开发中尝试使用C++。这一时期，C++的标准库和模板等特性也得到了进一步的完善和发展。

C++的标准化工作于1989年开始，并成立了一个ANSI和ISO（International Standards Organization）国际标准化组织的联合标准化委员会。1994年标准化委员会提出了第一个标准化草案。在该草案中，委员会在保持斯特劳斯特卢普最初定义的所有特征的同时，还增加了部分新特征。

在完成C++标准化的第一个草案后不久，STL（Standard Template Library）是惠普实验室开发的一系列软件的统称。它是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室工作时所开发出来的。在通过了标准化第一个草案之后，联合标准化委员会投票并通过了将STL包含到C++标准中的提议。STL对C++的扩展超出C++的最初定义范围。虽然在标准中增加STL是个很重要的决定，但也因此延缓了C++标准化的进程。

1997年11月14日，联合标准化委员会通过了该标准的最终草案。1998年，C++的ANSI/ISO标准被投入使用。

1.1 C++版本更新

时间	阶段	内容
1998年	C++98	C++官方第一个版本,绝大多数编译器都支持,得到了国际标准化组织(ISO)和美协会认可,以模板方式重写C++标准库,引入了STL(标准模板库)
2003年	C++03	这是C++标准的一个重大修订,主要聚焦于语言的稳定性和兼容性。C++03修复了+98标准中的错误和漏洞,同时引入了一些新的特性和功能,如tr1库(Technica 1)
2011年	C++11	这是一次革命性的更新,增加了大量的新特性和功能,使得C++更像一种新语言, lambda、范围for、右值引用和移动语义、边长模版参数、STL的容器和核心接口能指针、标准线程库等
2014年	C++14	对C++11的扩展,主要是修复C++11中漏洞以及改进,比如:泛型的lambda表达的返回值类型推导,二进制字面常量等
2017年	C++17	C++17进一步增强了C++的功能和表达能力。这次更新引入了if constexpr、结构折叠表达式等语法特性,同时改进了标准库中的多个组件,如string、filesystem
2020年	C++20	C++20是C++历史上的又一个重要里程碑。这次更新引入了一系列新特性和改进,(Coroutines)、概念(Concepts)、模块化(Modules)等,为C++的未来发坚实的基础。
2023年	C++23	C++23是一个小版本更新,进一步完善和改进现有特性,增加了if consteval、显数、falt_map,import std导入标准库等
2026年	C++26	制定中

1.2 关于C++23的一个小故事：

C++一直被诟病的一个地方就是一直没出网络库(networking)，networking之前是在C++23的计划中的，现在C++23已经发布了，但是没有networking，网上引发了一系列的吃瓜和吐槽。中间过程就像发生了宫斗剧一样。

P2452R0 2021 October Library Evolution and Concurrency Networking and Executors PollOutcomes
C++23的⽬标

2. C++参考文档

https://legacy.cplusplus.com/reference/

https://zh.cppreference.com/w/cpp

https://en.cppreference.com/w/

说明：第一个链接不是C++官方文档，标准也只更新到C++11，但是以头文件形式呈现，内容比较易看好懂。后两个链接分别是C++官方文档的中文版和英文版，信息很全，更新到了最新的C++标准，但是相比第一个不那么易看；几个文档各有优势，我们结合着使用。

3. C++的重要性

3.1 编程语言排行榜

TIOBE排行榜是根据互联网上有经验的程序员、课程和第三方厂商的数量，并使用搜索引擎（如Google、Bing、Yahoo!）以及Wikipedia、Amazon、YouTube和Baidu（百度）统计出排名数据，只是反映某个编程语言的热门程度，并不能说明一门编程语言好不好，或者一门语言所编写的代码数量多少。

2026年4月TIOBE发布的编程语言排行榜

Apr 2026	Apr 2025	Change	Programming Language	Ratings	Change
1	1		Python	20.97%	-2.11%
2	3		C	12.34%	+2.39%
3	2		C++	8.03%	-2.30%
4	4		Java	7.79%	-1.84%
5	5		C#	5.98%	+1.59%
6	6		JS JavaScript	3.11%	-0.60%
7	8		VB Visual Basic	3.02%	+0.08%
8	10		SQL	1.75%	-0.44%
9	14		R	1.62%	+0.43%
10	9		Delphi/Object Pascal	1.52%	-1.01%

3.2 C++在工作领域中的应用

C++的应用领域服务器端、游戏（引擎）、机器学习引擎、音视频处理、嵌入式软件、电信设备、金融应用、基础库、操作系统、编译器、基础架构、基础工具、硬件交互等很多方面都有。

1. 大型系统软件开发。如编译器、数据库、操作系统、浏览器等等

2. 音视频处理。常见的音视频开源库和方案有FFmpeg、WebRTC、Mediasoup、ijkplayer，音视频开发最主要的技术栈就是C++。

3. PC客户端开发。一般是开发Windows上的桌面软件，比如WPS之类的，技术栈的话一般是C++和QT，QT是一个跨平台的C++图形用户界面（Graphical User Interface，GUI）程序。

4. 服务端开发。各种大型应用网络连接的高并发后台服务。这块Java也比较多，C++主要用于一些对性能要求比较高的地方。如：游戏服务、流媒体服务、量化高频交易服务等

5. 游戏引擎开发。很多游戏引擎就都是使用C++开发的，游戏开发要掌握C++基础和数据结构，学习图形学知识，掌握游戏引擎和框架，了解引擎实现，引擎源代码可以学习UE4、Cocos2d-x等开源引擎实现

6. 嵌入式开发。嵌入式把具有计算能力的主控板嵌入到机器装置或者电子装置的内部，通过软件能够控制这些装置。比如：智能手环、摄像头、扫地机器人、智能音响、门禁系统、车载系统等等，粗略一点，嵌入式开发主要分为嵌入式应用和嵌入式驱动开发。

7. 机器学习引擎。机器学习底层的很多算法都是用C++实现的，上层用python封装起来。如果你只想准备数据训练模型，那么学会Python基本上就够了，如果你想做机器学习系统的开发，那么需要学会C++。

8. 测试开发/测试。每个公司研发团队，有研发就有测试，测试主要分为测试开发和功能测试，测试开发一般是使用一些测试工具(selenium、Jmeter等)，设计测试用例，然后写一些脚本进行自动化测试，性能测试等，有些还需要自行开发一些测试用具。功能测试主要是根据产品的功能，设计测试用例，然后手动的方式进行测试。

4. C++学习建议和书籍推荐

4.1 C++学习难度

首先第一个问题，C++难学吗？首先在这里告诉大家C++是一个相对难学难精的语言，相比其他一些语言，学习难度要高一些要陡峭一些，这里有历史包袱的问题，也有语言本身设计和发展历史的问题。网上以前一直流传下面这个21天内自学精通C++的梗。当然自学难度很大。

4.2 学习书籍推荐

C++ Primer：主要讲解语法，经典的语法书籍，前后中期都可以看，前期如果自学看可能会有点晦涩难懂，能看懂多少看懂多少，就当预习，学了比特课程后，中后期作为语法字典，非常好用。

STL源码剖析：主要从底层实现的角度结合STL源码，庖丁解牛式剖析STL的实现，是侯捷老师的经典之作。可以很好的帮助我们学习别人用语法是如何实现出高效简洁的数据结构和算法代码，如何使用泛型封装等。让我们不再坐井观天，闭门造车，本书课程上一半以后，中后期可以看。

Effective C++: 本书也是侯捷老师翻译的, 本书有的一句评价, 把C++程序员分为看过此书的和没看过此书的。本书主要讲了55个如何正确高效使用C++的条款, 建议中后期可以看一遍, 工作1-2年后再看一遍, 相信会有不一样的收获。

5. C++的第一个程序

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

1    // test.cpp
2    #include<stdio.h>
3
4    int main()
5    {
6    printf("hello world\n");
7
8    return 0;
9 }

当然C++有一套自己的输入输出，严格说C++版本的hello world应该是这样写的。

// 这里的std cout等我们都看不懂，没关系，下面我们会依次讲解
#include<iostream>
using namespace std;

int main()
{
    cout << "hello world\n" << endl;
    return 0;
}

6. 命名空间

6.1 namespace的价值

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

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

1 #include <stdio.h>
#include <stdio.h>
2 #include <stdlib.h>
3 int rand = 10;
4 
5 int main()
6 {
7    // 编译报错：error C2365: “rand”：重定义；以前的定义是“函数”
8    printf("%d\n", rand);
9    return 0;
10 }

6.2 namespace的定义

• 定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。命名空间中可以定义变量/函数/类型等。

• namespace本质是定义出一个域，这个域跟全局域各自独立，不同的域可以定义同名变量，所以下面的rand不在冲突了。

• C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找一个变量/函数/类型出处(声明或定义)的逻辑，所有有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不影响变量生命周期。

• namespace只能定义在全局，当然他还可以嵌套定义。

• 项目工程中多文件中定义的同名namespace会认为是一个namespace，不会冲突。

• C++标准库都放在一个叫std(standard)的命名空间中。

代码块

#include <stdio.h>
#include <stdlib.h>

// 1. 正常的命名空间定义

// bit是命名空间的名字，一般开发中是用项目名字做命名空间名。
// 我们上课用的是bit，大家下去以后自己练习可以考虑用自己名字缩写，如张三：zs
namespace bit
{
    // 命名空间中可以定义变量/函数/类型
    int rand = 10;

    int Add(int left, int right)
    {
    return left + right;
    }

    struct Node
    {
    struct Node* next;
    int val;
    };
}

int main()
{
    // 这里默认是访问的是全局的rand函数指针
    printf("%p\n", rand);
    // 这里指定bit命名空间中的rand
    printf("%d\n", bit::rand);

    return 0;
}

//2. 命名空间可以嵌套
namespace bit
{
    // 鹏哥
    namespace pg
    {
    int rand = 1;
    int Add(int left, int right)
    {
    return left + right;
    }
    }

    // 杭哥
    namespace hg
    {
    int rand = 2;
    int Add(int left, int right)
    {
    return (left + right)*10;
    }
    }
}

int main()
{
    printf("%d\n", bit::pg::rand);
    printf("%d\n", bit::hg::rand);

    printf("%d\n", bit::pg::Add(1, 2));
    printf("%d\n", bit::hg::Add(1, 2));

    return 0;
}

代码块
1 // 多文件中可以定义同名namespace，他们会默认合并到一起，就像同一个namespace一样
2 // Stack.h
3 #pragma once
4 #include<stdio.h>
5 #include<stdlib.h>
6 #include<stdlib.h>
7 #include<assert.h>

namespace bit
{
    typedef int STDataType;
    typedef struct Stack
    {
    STDataType* a;
    int top;
    int capacity;
    }ST;

    void STInit(ST* ps);
    void STDestroy(ST* ps);

    void STPush(ST* ps, STDataType x);
    void STPop(ST* ps);
    STDataType STTop(ST* ps);
    int STSize(ST* ps);
    bool STEmpty(ST* ps);
}

// Stack.cpp
#include"Stack.h"
namespace bit
{
    void STInit(ST* ps)
    {
    assert(ps);

    ps->a = (STDataType*)malloc(4 * sizeof(STDataType));
    ps->top = 0;
    ps->capacity = n;
    }

    // 栈顶
    void STPush(ST* ps, STDataType x)
    {
    assert(ps);

    // 满了，扩容
    if (ps->top == ps->capacity)
    {
    printf("扩容\n");
    int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;

    STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));

if (tmp == NULL)
{
    perror("realloc fail");
    return;
}

ps->a = tmp;
ps->capacity = newcapacity;
}

ps->a[ps->top] = x;
ps->top++;
}

//...
}

// test.cpp
#include"Stack.h"

// 全局定义了一份单独的Stack
typedef struct Stack
{
    int a[10];
    int top;
}ST;

void STInit(ST* ps) {}
void STPush(ST* ps, int x) {}

int main()
{
    // 调用全局的
    ST st1;
    STInit(&st1);
    STPush(&st1, 1);
    STPush(&st1, 2);
    printf("%d\n", sizeof(st1));

    // 调用bit namespace的
    bit::ST st2;
    printf("%d\n", sizeof(st2));
    bit::STInit(&st2);
    bit::STPush(&st2, 1);
    bit::STPush(&st2, 2);

    return 0;

6.3 命名空间使用

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

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

• using将命名空间中某个成员展开，项目中经常访问的不存在冲突的成员推荐这种方式。（在哪个作用域展开就是在哪里展开，比如在main函数里展开就在main函数里生效）

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

代码块
#include<stdio.h>
namespace N
{
    int a = 0;
    int b = 1;
}
int main()
{
    // 编译报错：error C2065：“a”：未声明的标识符
    printf("%d\n", a);
    return 0;
}

代码块
1 // 指定命名空间访问
2 int main()
3 {
4    printf("%d\n", N::a);
5    return 0;
6 }
7
8 // using将命名空间中某个成员展开
9 using N::b;
10 int main()
11 {
12    printf("%d\n", N::a);
13    printf("%d\n", b);
14    return 0;
15 }

// 展开命名空间中全部成员
using namespace N;
int main()
{
    printf("%d\n", a);
    printf("%d\n", b);
    return 0;
}

7. 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系列编译器是这样的，其他编译器可能会报错。

代码块
1 #define _CRT_SECURE_NO_WARNINGS 1
2 #include <iostream>
3 using namespace std;
4
5 int main()
6 {

int a = 0;
double b = 0.1;
char c = 'x';
cout << a << " " << b << " " << c << endl;
std::cout << a << " " << b << " " << c << std::endl;
scanf("%d%lf", &a, &b);
printf("%d %lf\n", a, b);
// 可以自动识别变量的类型
cin >> a;
cin >> b >> c;
cout << a << endl;
cout << b << " " << c << endl;
return 0;

代码块
#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;
}

问题与总结

• 1.头文件中仅定义结构体类型不会分配内存；直接定义全局 int 变量会分配内存，extern 声明变量不会分配内存，头文件内容书写自由，重复引入易造成宏、全局变量等定义的命名冲突，但函数、extern 变量等声明允许多次重复，不会触发冲突。
  
• 2. C语言头文件 与 C++头文件 完整实现、区别、原理

C语言头文件 与 C++头文件 完整实现、区别、原理

一、C 语言头文件实现（.h）

1. 核心作用

只放声明，不放定义（除宏、typedef、常量），给多个 .c 源文件共享接口。

2. 标准实现：头文件保护宏（防止重复包含冲突）

// test.h C语言标准头文件写法
#ifndef TEST\_H   // 如果没有定义TEST\_H
#define TEST\_H   // 立刻定义TEST\_H

// 1. 宏定义
#define MAX\_NUM 100

// 2. 类型声明/定义
typedef struct {
    int x;
    int y;
} Point;

// 3. 函数声明（只有声明，函数实现放.c）
void printPoint(Point p);

// 4. 外部全局变量声明
extern int g\_data;

#endif // TEST\_H

3. 配套 .c 源文件（放实现 / 定义）

// test.c 实现文件
#include "test.h"

// 全局变量定义
int g\_data = 10;

// 函数具体实现
void printPoint(Point p) {
    printf("x=%d y=%d\\n", p.x, p.y);
}

4. C 头文件底层原理

#include "xxx.h" 是文本直接拷贝，预处理器把头文件全部复制到 .c 文件里。
如果没有 #ifndef 保护，同一个头文件被多次 include 会重复定义、报命名冲突。

—

二、C++ 头文件两种实现方式

C++ 兼容 C 写法，但新增 \\#pragma once\\、类、命名空间、模板、标准库无.h 头文件等特性。

方式 1：兼容 C 风格 .h 头文件（老式写法）

// Test.h
#ifndef TEST\_H
#define TEST\_H

#include <iostream>

// 命名空间隔离命名冲突（C没有）
namespace MySpace {
    class Point {
    public:
        int x, y;
        void show(); // 类内函数声明
    };

    void print(int a);
}

#endif

实现文件 .cpp

#include "Test.h"
#include <iostream>
using namespace std;

namespace MySpace {
    void Point::show() {
        cout << x << " " << y << endl;
    }
    void print(int a) {
        cout << a << endl;
    }
}

方式 2：C++ 独有简化保护：#pragma once（现代推荐）

替代 #ifndef，编译器级防重复包含，写法更简洁：

// Test.h
#pragma once  // 一行搞定头文件保护

#include <iostream>

class Point {
public:
    int x,y;
    void show();
};

方式 3：模板 / 内联函数（C++ 特有的，必须写在头文件）

C++ 模板、inline 内联函数、constexpr 常量不能拆分到 cpp，实现直接写在头文件：

#pragma once

// 模板必须放头文件
template<typename T>
T add(T a, T b) {
    return a + b;
}

// 内联函数头文件直接实现
inline void hello() {
    cout << "hello" << endl;
}

4. C++ 标准库头文件特殊规则

1. C++ 标准库不带 .h：#include <iostream>、#include <vector>

2. C 语言标准库在 C++ 中有两套：

   • 老式兼容：#include <stdio.h>
   • C++ 标准推荐：#include <cstdio>（放入 std 命名空间，减少命名污染）

—

三、C 头文件 vs C++ 头文件核心区别总结

1. 重复包含防护

   • C：只能用 #ifndef/#define/#endif 宏保护
   • C++：支持宏保护 + 更简洁 #pragma once

2. 命名隔离

   • C：无命名空间，极易全局命名冲突
   • C++：namespace 划分作用域，解决命名冲突

3. 内容限制

   • C：头文件只适合声明，函数 / 全局变量定义必须放.c
   • C++：模板、inline、constexpr 必须把头文件写完整实现

4. 标准库格式

   • C：标准库带 .h（stdio.h、string.h）
   • C++：现代标准库无后缀（iostream、vector），C 库封装为 cstdio/cstring

一句话总述

C 语言头文件依靠宏防重复包含，仅存放声明、实现统一放在.c；C++ 头文件兼容 C 写法，新增#pragma once、命名空间，模板与内联函数需直接在头文件写实现，标准库头文件不再带.h后缀。

• 3.头文件问题

我们永远在.c文件最顶部写#include “xxx.h”，预处理器把头文件内容粘贴到当前文件顶层，顶层就是全局域，所以你看到所有变量、函数声明都在全局域

//main.c
#include "test.h"
int main(){}

//test.h里写 int num;
//预处理展开后main.c变成：
int num;  // 位于文件顶层 = 全局域
int main(){}

头文件只是一段文本，它没有自带任何作用域：
如果你故意把#include写在函数内部，头文件代码会被粘贴进局部域，不再是全局

int main(){
    #include "test.h" 
    // 这里test.h里的int num; 属于main函数局部域，不是全局
}

• 4.完整三步流程（所有 C/C++ 编译器统一逻辑）、

预处理（单独处理每一个 .cpp/.c）

• 逐个拿你的源文件，执行 #include 复制、宏替换、删除注释。每个文件完全独立处理，互相看不见对方代码。
  比如 a.cpp、b.cpp 分开预处理，互不干扰。
• 编译（单独生成目标文件 obj）
  预处理完的单个文件，单独翻译成机器码，生成独立的.obj 文件。a.cpp → a.obj；b.cpp → b.obj
  两个 obj 完全隔离，此时编译器不会检查跨文件重名问题。
  这一步：每个文件里定义的全局变量、函数，都会在自己的 obj 里占内存。
• 链接（最后一步，把所有 obj 合并到一起）
  收集全部 obj 里所有全局变量、函数名字。
  一旦发现无修饰全局符号（普通 int a） 在多个 obj 重复存在，直接报「多重定义」报错。

转载自 CSDN-专业IT技术社区

原文链接：https://blog.csdn.net/2401_83075246/article/details/163113932