文章目录
引入:建立正确预期
首先,C++并不是“加了几个关键字的”C,如果你已经会写C,学习C++前并不是说要摈弃前面学习的C,相反,C++可以说兼容大部分C的写法,也吸收了C的大量语法和库习惯,但C++和C仍然是两门独立的语言。
C++相比C增加了命名空间、引用、函数重载、面向对象等机制与实现,本篇主要是介绍从C语言学习跨越到C++学习中时需要读懂的一些基础以及转变,为之后C++的深入学习打下基础。
1. 第一个 C++ 程序:从 printf 到 std::cout
对于大部分人的第一个Hello WorldC程序:
#include <stdio.h>
int main()
{
printf("Hello World");
return 0;
}
这个程序对应C++又是如何实现的呢:
#include <iostream>
int main()
{
std::cout << "Hello World";
return 0;
}
可以看到,C++与C的整体代码框架基本一样,都是要包含头文件,然后写主函数main,但同时也有一些方式的改变,比如输出使用的函数 printf 与 std::cout,所以下面开始介绍一些从C到C++的一些基础输入输出改变。
1.1 基础代码执行过程
先看一个完整程序。它读取两个整数并输出它们的和:
#include <iostream>
int main() {
int left = 0;
int right = 0;
std::cout << "请输入两个整数:";
std::cin >> left >> right;
std::cout << "和为:" << left + right << '\n';
return 0;
}
这段代码的运行过程如下:
#include <iostream>让编译器看到标准输入输出流的声明。main是程序入口,局部变量left和right先被初始化为0。std::cout << ...把数据写到标准输出,std::cin >> ...从标准输入读取数据。return 0向操作系统报告程序正常结束。
运行示例:

1.2 C++基本输入输出
代码中的输入输出函数使用的是std::cin与std::cout,它们是定义在 <iostream> 头文件中的函数,而<iostream> (Input Output Steram)是C++中标准的输入、输出流库,定义看标准的输入、输出对象。
- std::cin 是istream类的对象,它主要⾯向窄字符(narrowcharacters(oftypechar))的标准输
入流。 - std::cout 是ostream类的对象,它主要面向窄字符的标准输出流。
然后,其后面接着的<<与>>符号是对应的输入输出符号,<<是流插入运算符,>>是流提取运算符。
C语言中用这两个运算符做位运算左移
<<、右移>>
现在可以把流想成一条数据通道:
std::cout << value:把value放入输出流。std::cin >> value:从输入流取出数据,写入value。
这不是位移运算的新用法,而是 C++ 对运算符进行重载后的表现形式。现在只需要记住它表达的是“流入”和“流出”。
1.3 和C写法的对应关系
| 目的 | C | C++ 基础写法 |
|---|---|---|
| 输出整数 | printf("%d", value) | std::cout << value |
| 读取整数 | scanf("%d", &value) | std::cin >> value |
| 换行 | \n | \n 或 std::endl |
std::cin >> value 不需要手动写 &value,因为输入流运算符已经通过引用参数完成了对变量的修改。
可先简单记住,C++的流接口把格式和地址处理封装进了运算符.
2. 命名空间:解决同名问题
在前面我们看到类似std::的表示方法,这其实就是表示调用std这个命名空间的函数。
2.1 为什么需要命名空间
假设两个库都提供了一个叫 print 的函数:
void print(); // 库 A
void print(); // 库 B
如果它们都暴露在全局作用域,调用 print() 时编译器无法判断你想使用哪一个。此时命名空间就给名字增加了一层范围:
namespace library_a {
void print() {
std::cout << "A\n";
}
}
namespace library_b {
void print() {
std::cout << "B\n";
}
}
int main() {
library_a::print();
library_b::print();
}
library_a::print 中的 :: 可以读成“在 library_a 作用域中寻找 print”,是C++中的域作用操作符,标准库中的输入输出对象就放在 std (standard)命名空间,所以我们写成 std::cout 和 std::cin。
若域作用操作符::左侧没有空间名的话,默认是全局域,也就是当前文件。
2.2 命名空间的三种使用方式
- 直接使用
std::域限定符(显式指定命名空间)
std::cout << "明确写出命名空间\n";
每次使用标准库成员时,都在前面加上std::。
优点:不会污染当前作用域,完全不会产生名字冲突,大型项目、头文件里优先推荐。
缺点:每次写代码都要额外敲上std::,书写稍繁琐。
- using 引入单个名字
using std::cout;
cout << "只引入一个名字\n";
只把std里面指定的这一个名字(这里是cout)引入当前作用域,其他 std 成员仍然需要写std::。
优点:兼顾简洁与安全,只开放需要用到的标识符,名字冲突风险很小。
适合只需要用到少量标准库组件的场景。
- using namespace std; 引入整个命名空间
using namespace std;
cout << "一次引入整个命名空间\n" << endl;
一次性将std命名空间内所有名字全部导入当前作用域。
优点:写代码最省事,学习阶段写小 demo 很方便。
缺点:会把 std 库中成百上千的标识符全部引入,大大增加了名字冲突的概率。
所以不建议在以后的工程项目中使用此种方式。
3. 缺省参数与函数重载:让函数接口更灵活
3.1 缺省参数解决了什么问题
缺省函数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时,如果没有指定实参,则采用该形参的缺省值,否则使用指定的实参。其中缺省参数又分为全缺省和半缺省参数。
- 全缺省就是函数的全部形参都给缺省值,半缺省是部分形参给缺省值。
- 函数的声明和定义分离时,缺省参数不能在函数声明和定义中同时出现,规定必须在函数声明给缺省值。
在 C 中如果想让一个参数“可省略”,通常需要再写一个包装函数。但 C++ 中的缺省参数可以直接给参数指定我们想要的默认值:
#include <iostream>
void show_message(const char* text, int repeat = 1)
{
for (int i = 0; i < repeat; ++i)
{
std::cout << text << '\n';
}
}
int main()
{
show_message("一次"); // repeat 使用默认值 1
show_message("三次", 3); // 显式传入 repeat
}
运行结果:

如果函数声明与定义分开,缺省参数只能写在函数声明里,定义处不能再写默认值:
void show_message(const char* text, int repeat = 1);
void show_message(const char* text, int repeat)
{
// ...
}
注意一些限制条件:
- C++规定半缺省参数必须从右到左依次连续缺省,不能间隔给缺省值。
- 同一个作用域内不要在多次声明中重复指定不同的默认值。
3.2 函数重载解决什么问题
当我们想要定义“操作含义相同,但参数类型和数量不同”时,就可以使用同一个函数名实现函数重载:
void print(int value)
{
std::cout << "整数:" << value << std::endl;
}
void print(double value)
{
std::cout << "小数:" << value << std::endl;
}
int main()
{
print(10); // 调用 print(int)
print(3.14); // 调用 print(double)
return 0;
}
运行结果:

编译器会根据实参类型匹配函数。但是只有返回值不同不能构成重载,因为调用表达式中可能根本没有使用返回值:
// 错误示例:仅返回值不同,无法区分
int calculate(int value);
double calculate(int value);
当缺省参数和重载叠加时要小心调用歧义。例如 f(int) 与 f(int, int = 0) 同时存在,调用 f(1) 就可能匹配两个函数。遇到这种情况,应重新设计接口或显式传入更多参数来避免出错。
4. 引用:给已有对象起别名
引用不是定义新变量,而是给已存在的变量取一个别名,编译器在编译时不会为引用变量开辟内存空间,它和它引用的变量使用的是同一块内存空间。
4.1 引用的基本用法
int score = 95;
int& alias = score;
alias = 100;
std::cout << score << std::endl; // 输出 100
alias 不是一份新的整数,而是 score 的另一个名字。引用声明时必须初始化,且之后不能像普通指针那样改为“绑定到另一个对象”,引用定义后就与原变量共用一块内存空间了,不能随意更换,但可以通过引用来改变原变量的值,这在函数传参时有很大的用处。
4.2 用引用实现 swap
在之前使用C实现两个元素的交换时,由于函数传参的值传递,所以通常在函数传参时传入对应变量的指针,再通过指针的解引用实现交换:
void Swap(int* left, int* right)
{
int temp = *left;
*left = *right;
*right = temp;
}
有了引用之后,我们就可以更加方便的解决:
void Swap(int& left, int& right)
{
int temporary = left;
left = right;
right = temporary;
}
int main()
{
int a = 10;
int b = 20;
std::cout << "交换前" << std::endl;
std::cout << a << ' ' << b << std::endl;
Swap(a, b);
std::cout << "交换后" << std::endl;
std::cout << a << ' ' << b << std::endl; // 20 10
return 0;
}
运行结果:

在 C 中实现时,调用时传入 &a、&b,函数内部还要使用 *left、*right。引用版本仍然修改调用者对象,但调用处更接近“把两个对象交给函数处理”。
4.3 const 引用
const引用可以引用一个使用了const修饰的变量,同时也能引用普通对象,对象的权限可在引用的过程中缩小,但不能放大。
const int a = 10;
const int& ra = a; //可行
int b = 20;
const int& rb = b; //可行
const int c = 30;
int rc& = c; //不可行
函数参数中的只读参数也可以写成 const T&(T为任意类型):
#include <iostream>
void print_name(const int& age)
{
std::cout << "age: " << age << std::endl;
}
这样既避免复制较大的对象,又保证函数不会通过 age 修改调用者数据。
4.4 引用与指针的关系
| 对比点 | 指针 | 引用 |
|---|---|---|
| 是否必须初始化 | 可以暂时不初始化,但这是危险的 | 声明时必须初始化 |
| 是否能表示空状态 | 可以用 nullptr 表示 | 没有常规的空引用 |
| 是否能重新指向 | 可以 | 不能重新绑定 |
| 访问目标对象 | 需要 *p | 直接使用引用名 |
要注意的是,引用并不会让生命周期问题自动消失。下面的函数返回了局部变量的引用,但是函数结束后 local 已经销毁,所以返回结果将悬空:
// 错误示例:不要返回局部变量的引用
int& Wrong()
{
int local = 42;
return local;
}
5. inline 与 nullptr:内联与空指针
5.1 inline 不等于“强制内联”
用inline进行修饰的函数叫内联函数,编译时C++编译器会在调用的地方展开内联函数(参考宏展开,但比宏展开更好写),这样调用内联函数就不需要再另外建立栈帧了,可提高程序执行效率。
但是,并不是所有加了inline的函数都会按标准展开,这取决于编译器的选择,当函数规模较小但需多次调用时,这是编译器会正常按照内联函数进行展开,但一旦函数体代码规模稍微大一点,即使给该函数加了inline标记为内联函数,但是编译器仍然把其当作正常函数处理(建立函数栈帧)。
在 C++ 中,inline 的重要作用是允许这个函数在多个翻译单元中出现相同定义,只要这些定义满足语言规则。它就可以作为“适合放在头文件中的小函数”的信号,但编译器是否真的把函数调用展开,仍由实际情况决定。
因此,不要把 inline 当成“性能开关”,也不要为了追求速度给所有函数都加上它。函数是否值得内联,要结合函数大小、调用频率和编译器优化结果综合判断。
5.2 nullptr 比 NULL 更明确
在C中,对于空指针的表示通常使用NULL,但NULL实际是一个宏,在传统的C头文件(stddef.h)中,我们可以看到如下代码:
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void*)0)
#endif
#endif
C++中NULL可能被定义为字面常量0,或者C中被定义为无类型指针(void*)的常量。不论采取何种
定义,在使用空值的指针时,都不可避免的会遇到⼀些麻烦。比如:
void check(int value)
{
std::cout << "整数版本\n";
}
void check(int* pointer)
{
std::cout << "指针版本\n";
}
int main()
{
check(nullptr); // 明确调用指针版本
check(NULL); // 结果取决于 NULL 的定义,可能产生歧义
}
本想通过check(NULL)调用指针版本的check(int*)函数,但是由于NULL被定义成0,从而调用了check(int a),因此与程序的初衷相悖。
而nullptr 是专门表示空指针的值,不会被当成普通整数参与大多数整数运算。相比于NULL会在使用中更加安全可靠。
6. 扩展练习
6.1 使用命名空间和 iostream
编写程序,读取学生的三门成绩,输出平均分。要求使用 std::cin 和 std::cout,不要使用 using namespace std。
思路:
先声明三个 double 变量用于记录成绩,然后使用连续的输入流读取数据,再用总分除以 3.0。输出时显式写出 std::。
参考答案:
#include <iostream>
int main()
{
double first = 0.0;
double second = 0.0;
double third = 0.0;
std::cout << "请输入三门科目成绩:";
std::cin >> first >> second >> third;
double average = (first + second + third) / 3.0;
std::cout << "平均分是:" << average << std::endl;
return 0;
}
虽然说日常使用中基本不会出现与std库命名冲突的问题,但我仍建议养成完整写出函数命名空间的习惯。
6.2 用引用交换两个数
实现 swap(int& a, int& b)函数,并在 main 中验证交换前后的结果。
思路:
引用参数直接绑定到调用者的两个变量,函数内部使用临时变量完成三步交换。
参考答案:
#include <iostream>
void swap_values(int& a, int& b)
{
int temp = a;
a = b;
b = temp;
}
int main()
{
int a = 3;
int b = 8;
std::cout << "交换前" << std::endl;
std::cout << a << ' ' << b << std::endl;
swap(a, b);
std::cout << "交换后" << std::endl;
std::cout << a << ' ' << b << std::endl;
return 0;
}
6.3 缺省参数使用
设计一个print 函数,设置三个参数分别为“年”、“月”、“日”,功能为打印日期,要求年份默认为“2026”。
#include <iostream>
void print(int month, int date, int year = 2026)
{
std::cout << year << '/' << month << '/' << date << std::endl;
}
int main()
{
print(9, 22);
print(2027, 9, 22);
return 0;
}
注意,缺省参数需从右往左依次写。
7.总结
从 C 进入 C++,最先需要适应的不是大量新语法,而是几种新的表达方式:命名空间让名字有边界,流操作让输入输出更统一,默认参数和重载让函数接口更灵活,引用让“直接操作已有对象”更直观,nullptr 则让空指针表达更清楚。
这些机制都有边界:命名空间不能代替良好的命名,重载可能产生歧义,引用仍然受对象生命周期影响,inline 不是性能保证,nullptr 也不能被解引用。理解这些“为什么”和“什么时候不能用”,比背下语法更重要。接下来再学习类、构造函数和模板时,你会更容易看出它们是在这些基础规则上继续扩展的。


转载自 CSDN-专业IT技术社区
原文链接:https://blog.csdn.net/by20999/article/details/166369351




