跳到主要内容 C++ 入门基础 | 极客日志
C++
C++ 入门基础 介绍 C++ 入门基础知识，涵盖 C++ 发展历程、基本程序结构、命名空间作用域管理、标准输入输出流用法、缺省参数规则、函数重载机制、引用的概念与特征（含常引用）、内联函数优化原理以及 nullptr 空指针替代方案。内容旨在帮助初学者掌握 C++ 核心语法特性，规避命名冲突、类型转换及空指针歧义等常见问题。
PhpPioneer 发布于 2026/3/21 更新于 2026/4/18 前言
C++ 是在 C 语言的基础上发展而来的一种面向对象编程语言，它在保留 C 语言强大功能的同时，引入了许多新的特性。比如面向对象编程 (OOP) ：类、封装、继承、多态 四大件，引用 (Reference)、模板 (Template)、命名空间 (Namespace)、异常处理 (Exception Handling)、标准模板库 (STL) 。
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 标准被投入使用。
2. C++ 的第一个程序
#include <stdio.h>
int main () printf ("hello world\n" );
return 0 ;
}
C++ 兼容 C 语言绝大多数的语法 ，所以 C 语言实现的 hello world 依旧可以运行，C++ 中需要把定义文件代码后缀改为.cpp，VS 编译器看到是.cpp 就会调用 C++ 编译器编译 ，linux 下要用 g++ 编译，不再是 gcc。
当然 C++ 有一套自己的输入输出，严格说 C++ 版本的 hello world 应该是这样写的
#include <iostream>
using namespace std;
微信扫一扫，关注极客日志 微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
相关免费在线工具 Base64 字符串编码/解码 将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
Base64 文件转换器 将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
Markdown转HTML 将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
HTML转Markdown 将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
JSON 压缩 通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online
JSON美化和格式化 将JSON字符串修饰为友好的可读格式。 在线工具，JSON美化和格式化在线工具，online
int main ()
"hello world\n"
return
0
这里的 std、cout 等我们都看不懂，没关系，下面我们会依次讲解。
3. 命名空间
3.1 namespace 的价值 在 C/C++ 中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace 关键字的出现就是针对这种问题的。
C 语言项目类似下面程序这样的命名冲突是普遍存在的问题，C++ 引入 namespace 就是为了更好的解决这样的问题。
在没有包含<stdlib.h>时程序是可以运行的，但是如果包含了<stdlib.h>，程序还能正常运行吗？
答案显而易见，是不可以的，rand() 函数是在头文件<stdlib.h>中的，它的作用是产生一个随机数 。因为将头文件<stdlib.h>展开的话就会有 rand() 函数与全局变量 rand 重名，此时它们都在全局域内，这就会产生重定义。所以命名空间 namespace 就应运而生了。
3.2 namespace 的定义 定义命名空间 ，需要使用到namespace 关键字 ，后面跟命名空间的名字 ，然后接一对 {} 即可，{} 中即为命名空间的成员 。命名空间中可以定义变量/函数/类型 等。
namespace 本质是定义出一个域，这个域跟全局域各自独立，不同的域可以定义同名变量，所以下面的 rand 不在冲突了。
C++ 中域有函数局部域 ，全局域 ，命名空间域 ，类域 ；域影响的是编译时语法查找一个变量/函数/类型出处 (声明或定义) 的逻辑，所有有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不影响变量生命周期。
namespace 只能定义在全局 ，当然他还可以嵌套定义 。
项目工程中多文件中定义的同名 namespace 会认为是一个 namespace，不会冲突。
C++ 标准库都放在一个叫 std(standard) 的命名空间中。
#include <stdio.h>
#include <stdlib.h>
namespace test {
int rand = 10 ;
}
int main () printf ("%d\n" , rand);
printf ("%d\n" , test::rand);
return 0 ;
}
3.3 命名空间的嵌套 C++ 中namespace（命名空间）支持 嵌套定义 ，即在一个命名空间内部可以定义另一个命名空间，形成层级化的域结构，能进一步细化名字的隔离范围，避免不同模块间的名字冲突。
嵌套命名空间的域是完全独立的：内外层命名空间中可定义同名变量/函数，不会冲突；
内层访问外层成员：需通过外层命名空间名::成员名显式指定，否则默认访问内层自身成员；
#include <stdio.h>
using namespace std;
namespace OuterNS {
int a = 10 ;
namespace InnerNS {
int a = 20 ;
void show () printf ("InnerNS::a = %d\n " ,OuterNS::a);
printf ("OuterNS::a = %d\n " ,OuterNS::a);
}
}
}
int main () show ();
printf ("直接访问 InnerNS::a: %d\n " ,OuterNS::InnerNS::a);
using OuterNS::InnerNS::a;
printf ("using 后访问 a: %d\n " ,a);
using namespace OuterNS::InnerNS;
show ();
return 0 ;
}
多文件中可以定义同名 namespace，他们会默认合并到一起，就像同一个 namespace 一样。
#pragma once
#include <stdio.h>
namespace MyNS {
void func1 () void func2 () #include "myns.h"
namespace MyNS {
int num1 = 100 ;
void func1 () printf ("这是 MyNS 中的 func1，num1 = %d\n" , num1);
}
}
#include "myns.h"
namespace MyNS {
int num2 = 200 ;
void func2 () printf ("这是 MyNS 中的 func2，num2 = %d\n" , num2);
}
}
#include "myns.h"
int main () printf ("访问 MyNS::num1 = %d\n" , MyNS::num1);
printf ("访问 MyNS::num2 = %d\n" , MyNS::num2);
MyNS::func1 ();
MyNS::func2 ();
return 0 ;
}
3.4 命名空间使用 编译查找一个变量的声明/定义时，默认只会在局部 或者全局 查找，不会到命名空间 里面去查找。所以下面程序会编译报错。所以我们要使用命名空间中定义的变量/函数，有三种方式：
指定命名空间访问 ，项目中推荐这种方式。using 将命名空间中某个成员展开 ，项目中经常访问的不存在冲突的成员推荐这种方式。展开命名空间中全部成员 ，项目不推荐，冲突风险很大，日常小练习程序为了方便推荐使用。
int main () printf ("%d\n" , N::a);
return 0 ;
}
using N::b;
int main () printf ("%d\n" , N::a);
printf ("%d\n" , b);
return 0 ;
}
using namespace N;
int main () printf ("%d\n" , a);
printf ("%d\n" , b);
return 0 ;
}
4. C++ 输入和输出 <iostream> 是 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>
using namespace std;
int main () int a;
double b;
char c;
cout << "Hello World\n" << endl;
cin >> a >> b >> c;
cout << a << " " << b << " " << c << endl;
return 0 ;
}
5. 缺省参数
缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参 则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。（有些地方把 缺省参数也叫默认参数）
全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。
带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。
函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。
#include <iostream>
using namespace std;
void Func (int n = 0 )
void Func1 (int a = 10 , int b = 20 , int c = 30 )
"a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl << endl;
}
void Func2 (int a, int b = 10 , int c = 20 )
"a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl << endl;
}
int main () Func ();
Func (10 );
Func1 ();
Func1 (1 );
Func1 (1 , 2 );
Func1 (1 , 2 , 3 );
Func2 (100 );
Func2 (100 , 200 );
Func2 (100 , 200 , 300 );
return 0 ;
}
函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须在函数声明中给缺省值 。因为如果缺省参数在函数声明和定义中同时出现并且给的缺省值都不同的话，编译器就无法确定缺省值到底是哪一个。
全缺省就是全部形参给缺省值。
半缺省就是部分形参给缺省值。
半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。
6. 函数重载 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;
}
int main () Add (1 , 2 ) << endl;
cout << Add (1.1 , 2.2 ) << endl;
return 0 ;
}
注意 ：当两个函数的函数名相同时，如果两个函数的参数列表相同而返回类型不同，这种情况也不会构成函数重载。因为函数在被调用时，编译器不知道调用哪一个。
#include <iostream>
using namespace std;
void f1 () "f()" << endl;
}
void f1 (int a = 10 ) "f(int a)" << endl;
}
int main () f1 (1 );
return 0 ;
}
上面两个函数构成重载，但调用 f1() 时，会报错，存在歧义，编译器不知道调用谁。
注意 ：在不同的作用域 中，两个函数就算同名，参数列表相同还有返回类型相同，那也是不同的两个函数，不会造成冲突。
#include <iostream>
using namespace std;
void f () "f()" << endl;
}
namespace MY {
void f () "f()" << endl;
}
}
int main () f ();
MY::f ();
return 0 ;
}
7. 引用
7.1 引用的概念和定义 概念：引用不是新定义一个变量，而是给已存在变量取了一个别名 ，编译器不会为引用变量开辟内存空间 ，它和它引用的变量共用同一块内存空间。比如：水浒传中李逵，宋江叫'铁牛'，江湖上人称'黑旋风'；林冲，外号豹子头；
C++ 中为了避免引入太多的运算符，会复用 C 语言的一些符号，比如前面的<< 和 >>，这里引用也和取地址使用了同一个符号&。
#include <iostream>
using namespace std;
int main () int a = 0 ;
int & b = a;
int & c = a;
int & d = b;
++d;
cout << &a << endl;
cout << &b << endl;
cout << &c << endl;
cout << &d << endl;
return 0 ;
}
7.2 引用的特征
引用在定义时必须初始化
一个变量可以有多个引用
引用一旦引用一个实体 ，再不能引用其他实体
#include <iostream>
using namespace std;
int main () int a = 10 ;
int & b = a;
int c = 20 ;
b = c;
cout << &a << endl;
cout << &b << endl;
cout << &c << endl;
return 0 ;
}
7.3 引用的使用
引用在实践中主要是于引用传参和引用做返回值中减少拷贝 提高效率和改变引用对象时同时改变被引用对象。
引用传参跟指针传参功能是类似的，引用传参相对更方便一些。
引用返回值的场景相对比较复杂，我们在这里简单讲了一下场景，还有一些内容后续类和对象章节 中会继续深入讲解。
引用和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。
C++ 的引用跟其他语言的引用 (如 Java) 是有很大的区别的，除了用法，最大的点，C++ 引用定义后不能改变指向，Java 的引用可以改变指向。
#include <iostream>
using namespace std;
void Swap (int & rx, int & ry) int tmp = rx;
rx = ry;
ry = tmp;
}
int main () int x = 0 , y = 1 ;
cout << x <<" " << y << endl;
Swap (x, y);
cout << x << " " << y << endl;
return 0 ;
}
#include <iostream>
using namespace std;
int main () int num = 100 ;
int * p = #
int *& rp = p;
*rp = 200 ;
cout << "num = " << num << endl;
int new_num = 300 ;
rp = &new_num;
cout << "*p = " << *p << endl;
return 0 ;
}
7.4 const 引用 (常引用) 可以引用一个 const 对象，但是必须用 const 引用。const 引用也可以引用普通对象，因为对象的访问权限在引用过程中可以缩小，但是不能放大。
int& rb = a*3;
double d = 12.34;
int& rd = d;
这样一些场景下 a*3 的和结果保存在一个临时对象 中，int& rd = d 也是类似，在类型转换 中会产生临时对象存储中间值，也就是时，rb 和 rd 引用的都是临时对象，而 C++ 规定临时对象具有常性 ，所以这里就触发了权限放大，必须要用常引用才可以。
所谓临时对象就是编译器需要一个空间暂存表达式的求值结果时临时创建的一个未命名的对象，C++ 中把这个未命名对象叫做临时对象。
int main () const int a = 10 ;
const int & ra = a;
int b = 20 ;
const int & rb = b;
return 0 ;
}
注意 ：可以引用一个 const 对象，但是必须用 const 引用。const 引用也可以引用普通对象，因为对象的访问权限在引用过程中可以缩小，但是不能放大。
#include <iostream>
using namespace std;
int main () int a = 10 ;
const int & ra = 30 ;
const int & rb = a*3 ;
double d = 12.34 ;
const int & rd = d;
return 0 ;
}
为什么 int& rb = a * 3;是不合法的，需要改成 const int& rb = a*3;才合法？
a * 3 是一个表达式，它计算 a 和 3 的乘积，并产生一个临时对象来存储临时的整型值 （在这个例子中是 30）。这个临时对象没有持久的内存地址，它在表达式求值完成后就会被丢弃。因此，你不能将一个引用绑定到一个临时对象上，因为引用需要绑定到一个持久的、可以唯一标识的实体上。
常量引用有一个重要的用途：它可以延长临时对象的生命周期。在 C++ 中，通常临时对象的生命周期仅限于包含它们的完整表达式。但是，如果你将一个临时对象绑定到一个常量引用 上，那么这个临时对象的生命周期就会被延长，直到引用它的常量引用超出作用域或被重新绑定到另一个对象上。
为什么 int& rd = d;是不合法的，需要改成 const int& rd = d;才合法？
int 和 double 是两种底层存储结构完全不同的类型，将 double 转换为 int 时会发生数值截断 （比如 double 类型的 12.34 转换为 int 会丢失小数部分，仅保留 12）；若允许非 const 引用绑定，后续通过 int 引用修改的值会基于截断后的 int 存储规则写入，这会直接破坏原始 double 对象的内存结构（double 占用 8 字节、int 占用 4 字节，存储格式也不同），导致程序出现不可预测的运行错误。
编译器在处理跨类型绑定引用时，会先执行隐式类型转换并生成一个临时的 int 对象 来存储截断后的值；而 C++ 语法明确规定，普通的非 const 引用不能绑定到临时对， 因为临时对象的生命周期极短，若允许绑定，引用修改的只是临时对象而非原始 d，会导致代码逻辑完全偏离预期。
也就是，当试图把 double 的 d 绑定到 int 引用时，编译器会先把 d 转换成 int 类型（截断小数），并在内存中创建一个临时的 int 对象 来存储这个转换后的值。const 引用支持绑定跨类型转换产生的临时对象（即存储 d 截断后值的 int 临时对象），避免了非 const 引用的'无效修改'问题，const关键字不仅保证了无法通过 rd 修改临时对象（契合'截断后的值仅用于读取'的合理场景），还会将临时对象的生命周期延长至与引用 rd 一致，确保访问时临时对象不会被提前销毁。
7.5 指针和引用的关系
C++ 中指针 和引用 就像两个性格迥异的亲兄弟，指针是哥哥，引用是弟弟，在实践中他们相辅相成，功能有重叠性，但是各有自己的特点，互相不可替代。
语法概念上引用 是一个变量的取别名不开空间 ，指针 是存储一个变量地址，要开空间 。
引用 在定义时必须初始化 ，指针 建议初始化，但是语法上不是必须的。引用 在初始化时引用一个对象后，就不能再引用其他对象 ；而指针 可以不断地改变指向对象 引用 可以直接访问指向对象，指针 需要解引用 才是访问指向对象。sizeof中含义不同，引用 结果为引用类型的大小，但指针 始终是地址空间所占字节个数（32 位平台下占 4 个字节，64 位下是 8byte）。指针 很容易出现空指针 和野指针 的问题，引用 很少出现，引用使用起来相对更安全一些。 #include <iostream>
using namespace std;
int main () int a = 10 , b = 20 ;
int & ra = a;
int * p;
p = &a;
p = &b;
cout << "引用访问：" << ra << endl;
cout << "指针访问：" << *p << endl;
cout << "sizeof(引用)：" << sizeof (ra) << endl;
cout << "sizeof(指针)：" << sizeof (p) << endl;
return 0 ;
}
8. inline 用 inline 修饰的函数 叫做内联函数 ，编译时 C++ 编译器会在调用的地方展开内联函数，这样调用内联函数就不需要建立栈帧了，就可以提高效率。
inline 对于编译器而言只是一个建议性关键字 ，也就是说，即便你给函数加上 inline，编译器也可以选择不在调用位置将其展开；不同编译器对 inline 函数的展开规则各不相同，因为 C++ 标准并未强制规定展开的具体场景。inline 仅适用于频繁调用的短小函数 ，对于递归函数、代码量较多的函数，即便加上 inline 也会被编译器忽略。
C 语言的宏函数 会在预处理阶段 直接替换展开 ，但宏函数的实现逻辑复杂、极易出错，且无法调试，C++ 设计 inline 的核心目的，就是替代 C 语言的宏函数，既保留'代码展开'的效率优势，又解决宏函数的缺陷。
VS 编译器在 Debug 调试版本 下默认不展开 inline 函数（便于调试），若想在 Debug 版本中让 inline 生效，需要手动设置两个配置项。
inline 函数不建议将声明和定义分离到两个文件 （如声明在.h、定义在.cpp），这种分离会导致链接错误 —— 因为 inline 函数被编译器展开后，不会生成函数的地址符号，链接阶段找不到对应函数地址就会报错。
#include <iostream>
using namespace std;
inline int Add (int x, int y) int ret = x + y;
ret += 1 ;
ret += 1 ;
ret += 1 ;
return ret;
}
int main () int ret = Add (1 , 2 );
cout << Add (1 , 2 ) * 5 << endl;
return 0 ;
}
我们可以通过汇编观察内联函数是否展开，有 call 语句就是没有展开，没有就是展开了
9. nullptr NULL 实际是一个宏，在传统的 C 头文件 (stddef.h) 中，可以看到如下代码：
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
在 C++ 中，NULL 的定义存在两种常见形式：要么被定义为字面常量 0 ，要么沿用 C 语言的定义无类型指针 (void*) 的常量 。无论采用哪种定义，使用 NULL 表示空指针时都会引发问题：例如原本希望通过 f(NULL) 调用指针版本的 f(int*) 函数，但由于 NULL 本质被解析为 0，编译器会优先匹配 f(int x) 重载函数，完全违背程序设计初衷；即便尝试用 f((void*)NULL) 强制调用指针版本，也会直接触发编译报错。
C++11 标准专门引入了关键字 nullptr 来解决 NULL 的缺陷：nullptr 是一种特殊类型的字面量，它仅能被隐式转换为任意指针类型，但无法转换为整数类型。使用 nullptr 定义空指针可彻底规避类型混淆问题 ，比如调用 f(nullptr) 时，编译器会精准匹配 f(int*) 指针版本的函数，而非 f(int x) 整数版本，完全符合程序的设计意图。
#include <iostream>
using namespace std;
void f (int x) "f(int x)" << endl;
}
void f (int * ptr) "f(int* ptr)" << endl;
}
int main () f (0 );
f (NULL );
f ((int *)NULL );
f (nullptr );
return 0 ;
}
