by20999头像
从C语言走进C++:先基本看懂命名空间、输入输出、重载与引用封面图

从C语言走进C++:先基本看懂命名空间、输入输出、重载与引用

引入:建立正确预期


首先,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;
}

这段代码的运行过程如下:

  1. #include <iostream> 让编译器看到标准输入输出流的声明。
  2. main 是程序入口,局部变量 left 和 right 先被初始化为 0。
  3. std::cout << ... 把数据写到标准输出,std::cin >> ... 从标准输入读取数据。
  4. 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写法的对应关系

目的CC++ 基础写法
输出整数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 命名空间的三种使用方式

  1. 直接使用std::域限定符(显式指定命名空间)
std::cout << "明确写出命名空间\n";

每次使用标准库成员时,都在前面加上std::。
优点:不会污染当前作用域,完全不会产生名字冲突,大型项目、头文件里优先推荐。
缺点:每次写代码都要额外敲上std::,书写稍繁琐。

  1. using 引入单个名字
using std::cout;
cout << "只引入一个名字\n";

只把std里面指定的这一个名字(这里是cout)引入当前作用域,其他 std 成员仍然需要写std::。
优点:兼顾简洁与安全,只开放需要用到的标识符,名字冲突风险很小。
适合只需要用到少量标准库组件的场景。

  1. 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

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--