NzN的C++入门必修（一）

一个闪现必杀技

已于 2024-04-02 09:35:30 修改

阅读量921

点赞数 34

分类专栏： C++入门学习文章标签： c++ 开发语言

于 2024-03-29 11:03:03 首次发布

本文链接：https://blog.csdn.net/2301_79676950/article/details/137133439

版权

C++入门学习专栏收录该内容

6 篇文章 2 订阅

订阅专栏

本文介绍了C++的基础知识，包括C++关键字的增加、命名空间的作用与使用方法、标准输入输出的处理、缺省参数的概念及其分类，以及函数重载的原理。

摘要由CSDN通过智能技术生成

是不是大部分学校都不教C++啊，让我来统计一下（辛苦各位去文章末尾投个票吧）。我们学校反正是不教的，只能靠自学了。那今天我的全新栏目C++入门就上线了，三连一下给个支持吧。

C++跟C语言有很多相似之处，因此在学习过程中我们一定要注意他们之间的差别，可别搞混了。那下面我们就开始正文部分吧！

一、C++关键字

在C语言里，我们一共学习过32个关键字。而 C++的关键字就比较多了，一共有63个关键字。下面就是我们在C++学习过程中要接触到的63个关键字。大家能看到好几个关键字全是C语言的老相识了。

这里我们只是先简单了解一下，后面使用的时候我们再来详细学习吧。

二、命名空间

1. 命名空间定义

#include<stdio.h>
#include<stdlib.h>
int rand = 1;
int main()
{
	printf("%d\n", rand);
	return 0;
}

我们下来一起看一下上面这段代码，我们定义了一个全局变量rand=1，在main函数中打印rand这个值，那这段代码的执行结果应该是输出1这个值。

但实际上，这段代码会报错。因为rand实际上是<stdlib.h>这个库里的一个函数，因此这个时候就会与全局变量这个名字产生冲突。

在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。因此就诞生了命名空间。

使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或产生名字污染，而namespace关键字的出现就是针对这种问题。

#include<stdio.h>
#include<stdlib.h>
//命名空间域
namespace bit 
{
	int rand = 1;
}
int main()
{
	printf("%d\n",rand);//取到的是<stdlib.h>库里的rand
	printf("%d\n",bit::rand);//取到的是命名空间里的rand
    //::这个操作符下面会讲解，这里只是为了看到执行结果
	return 0;
}

查找变量的原则：先在当前局部域里查找，没找到再从全局域里查找。未指定时，默认不会从命名空间域里查找。

命名空间里支持定义多种类型的变量。

//命名空间中可以定义变量/函数/结构体类型
namespace bit
{
	int a = 1;
	int Add(int left, int right)
	{
		return left + right;
	}
	struct Node
	{
		struct Node* next;
		int val;
	};
}

注意：

命名空间可以嵌套。

namespace N1
{
	int a;
	int b;
	int Add(int left, int right)
	{
		return left + right;
	}
	namespace N2
	{
		int c;
		int d;
		int Sub(int left, int right)
		{
			return left - right;
		}
	}
}

同一个工程中允许存在多个相同名称的命名空间，编译器最后会将他们合并成一个。

//test.h文件中定义命名空间N1
namespace N1
{
	int Mul(int left, int right)
	{
		return left * right;
	}
}

//在test.cpp里也定义一个命名空间N1
namespace N1
{
	int a;
	int b;
	int Add(int left, int right)
	{
		return left + right;
	}
}

2. 命名空间的使用

第一种方法是使用: :（域作用操作符），左边是命名空间，右边是命名空间里的变量。

namespace bit
{
	int a = 1;
	int Add(int left, int right)
	{
		return left + right;
	}
	struct Node
	{
		struct Node* next;
		int val;
	};
}
int main()
{
	printf("%d\n", bit::a);
	printf("%d\n", bit::Add(1,2));
	//访问命名空间里的结构体时，命名空间加在结构体类型名的前面
	struct bit::Node pnode;
	return 0;
}

第二种方法是using + 命名空间::命名空间里的变量。

namespace bit
{
	int a = 1;
	int Add(int left, int right)
	{
		return left + right;
	}
}
using bit::a;
using bit::Add;
int main()
{
	printf("%d\n", a);
	return 0;
}

第三种方法是展开命名空间，即使用using namespace+命名空间名/命名空间::命名空间里的变量。

namespace bit
{
	int a = 1;
	int Add(int left, int right)
	{
		return left + right;
	}
}
using namespace bit;
int main()
{
	printf("%d\n", a);
	return 0;
}

这种方法扩充了查找变量的原则：先在当前局部域里查找，没找到再从全局域或者命名空间里查找。

注意：展开命名空间后，全局域和命名空间处于同一优先级，会在这两个域里同时查找，因此全局域和命名空间如果存在同名变量/函数等，就不能展开命名空间。

命名空间主要解决名字冲突，其作用就是定义一个新的作用域。

但是当多个命名空间中都存在同名变量，且都通过using namespace展开命名空间，如果不对变量指定命名空间，系统就会报错。

namespace bit
{
	int a = 1;
}
namespace dit
{
	int a = 2;
}
using namespace bit;
using namespace dit;
int main()
{
	printf("%d\n", a);//a的指向不明确1，因此会报错
	return 0;
}

注意：局部域和全局域会影响生命周期，但命名空间不会。

三、C++的输入和输出

使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件，以及按命名空间使用方法使用std。

cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含<iostream >头文件中。<<是流插入运算符，>>是流提取运算符。

#include<iostream>//输入输出流
//std是C++标准库的命名空间名，C++标准库的定义实现都在这个命名空间中
using namespace std;
int main()
{
	cout << "Hello world!!!" << endl;
	return 0;
}

C++的输入输出可以自动识别变量类型，不需要像printf/scanf手动控制格式。

int main()
{
	int a;
	double b;
	char c;
	//可以自动识别变量的类型
	cin >> a;//输入a
	cin >> b >> c;//输入b和c
	cout << a << endl;//输出a
	cout << b << " " << c << endl;//输出b c
	return 0;
}

std是C++标准库的命名空间，std命名空间的使用惯例如下：

日常练习中，我们就可以直接使用using namespace std，一般不会有啥问题。
但是当我们在做一些项目的时候，如果使用using namespace std，就会将标准库全部暴露出来了。但是如果我们定义了跟库重名的类型/对象/函数，就会产生冲突。因此建议在项目开发中使用上面介绍的第二种命名空间的使用方法，即using std::cout这种展开常用的库对象/类型等方式。

【说明】

早期标准库将所有功能都在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持<iostream.h>格式，后续编译器已不支持，因此推荐使用<iostream>+std的方式。

关于cout和cin还有很多更复杂的用法，比如控制浮点数输出精度，控制整形输出进制格式等。因为C++兼容C语言的用法，这些又用得很少，这里先不展开学习，如果想要实现这几种功能完全可以使用更简单的printf函数。

四、缺省参数

1. 缺省参数概念

缺省参数是声明/定义函数时，给函数的参数指定一个缺省值(默认值)。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。

#include<iostream>
using namespace std;
void Func(int a = 0)
{
	cout << a << endl;
}
int main()
{
	Func();//没有传参时，使用参数的默认值0
	Func(10);//传参时，使用指定的实参10
	return 0;
}

2. 缺省参数分类

[1] 全缺省参数

//函数定义中的所有形参都指定初始值
void Func(int a = 10, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

注意：调用函数，给形参传值时，不能跳跃传值。

void Func(int a = 10, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}
int main()
{
	Func(1, 2, 3);//全部指定传参
	Func(1, 2);//a和b传参，c使用参数默认值
	Func(1, , 2);//注意：必须按顺序传参，不可以跳跃传递a和c
}

[2] 半缺省参数

//不是所有形参都给定默认值
void Func(int a, int b = 10, int c = 20)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

注意：

半缺省参数必须从右往左依次给出（调用函数时，必须要给没有默认值的形参传指定值）

缺省值必须是常量或者全局变量，不能声明和定义同时给缺省值（一般在声明给）

缺省参数不能在函数声明和定义中同时出现

//a.h
void Func(int a = 10);
// a.cpp
void Func(int a = 20)
{}
//如果声明与定义位置都给形参赋值，但是这两个值不同
//那编译器就无法确定到底该用哪个缺省值

【上述代码说明】

在C++中，当一个函数有缺省参数（默认参数）时，这个规则确保了程序的清晰性与一致性，避免了潜在的混淆。缺省参数意味着在函数调用中，如果没有提供某些参数，那么将自动使用这些参数的默认值。但是要注意不能在函数的声明和定义同时给缺省值。

想要理解这句话，关键在于区分函数声明和定义的概念。

函数声明：告诉编译器函数的名称、返回类型以及参数列表（类型、顺序和数量），但不涉及函数的具体实现。函数声明经常出现在头文件（.h）中

函数定义：提供了函数的实际实现，它包括函数的主体，即函数被调用时将执行的具体代码。函数定义包含了函数声明的所有信息，并加上了函数体。

如果在函数声明和定义中都指定缺省参数，且两个参数不一致，对于理解和维护代码就会很困难，编译器也不能确定应该使用哪一个默认值，尤其是当声明和定义位于不同的文件。

为了避免这种情况，C++标准规定了缺省参数应当只在一个地方指定。如果函数声明在头文件中，那么就在头文件中的声明处指定缺省参数；如果函数没有在头文件中声明，直接在.cpp文件中实现，那么就在函数定义处指定缺省参数。

五、函数重载

1. 函数重载概念

函数重载： C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数/参数的顺序、个数、类型)不同，常用来处理实现功能类似数据类型不同的问题。

// 1、参数类型不同
int Add(int left, int right)
{
	cout << "int Add(int left, int right)" << endl;
	return left + right;
}
double Add(double left, double right)
{
	cout << "double Add(double left, double right)" << endl;
	return left + right;
}
// 2、参数个数不同
void f()
{
	cout << "f()" << endl;
}
void f(int a)
{
	cout << "f(int a)" << endl;
}
// 3、参数类型顺序不同
void f(int a, char b)
{
	cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
	cout << "f(char b, int a)" << endl;
}

注意：如果两个同名函数只是返回类型不同，但是参数列表一样是不构成函数重载的。

int Add(int left, int right)
{
	cout << "int Add(int left, int right)" << endl;
	return left + right;
}
double Add(int left, int right)
{
	cout << "double Add(int left, int right)" << endl;
	return left + right;
}
//这段代码会直接报错

注意：

在不同命名空间域下，允许有同名函数，且他们的参数列表可以完全一致，但是不能算函数重载，因为函数重载发生在同一作用域。

函数的缺省参数不同也不构成重载。

2. 名字修饰

C++支持函数重载的原理：名字修饰(name Mangling)。

在C/C++中，一个程序要运行起来，需要经历：预处理、编译、汇编、链接。

实际项目通常是由多个头文件和多个源文件构成，假设存在Stack.h和Test.cpp两个文件。Test.cpp 里只有函数声明，这里不会报错，因为语法检查时匹配，但是函数声明不会产生地址。函数在Stack.cpp里定义，函数定义才能产生汇编指令，函数定义的第一句就是函数的地址，由Stack.cpp生成的Stack.o文件里才有函数的地址。

Test.cpp生成Test.o，但是此时Test.o里仍旧没有函数地址，这时链接器就会到Stack.o的符号表中寻找函数地址，然后链接到一起。那么链接时，面对Add函数，链接器会使用哪个名字去找呢？这里每个编译器都有自己的函数名修饰规则。

由于Windows下vs的修饰规则过于复杂，而Linux下g++的修饰规则简单易懂，下面我们使用g++演示这个修饰后的名字。

结论：在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变。

结论：在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息添加到修改后的名字中。

对比Linux会发现，Windows下vs编译器对函数名字修饰规则相对复杂难懂，但道理都是类似的，我们就不做细致的研究了。

扩展学习：C/C++函数调用约定和名字修饰规则

这样我们就能理解C语言不能支持重载，因为C语言是通过函数名进行查找的，这样就无法区分同名函数。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不同。如果两个函数的函数名和参数完全一样，即使返回值不同，这两个函数也是不构成重载的，因为函数修饰规则是依靠参数不同，因此调用时编译器没办法区分这两个函数。

以上便是本文的全部内容，快快三连鼓励一下小编吧！！！

一个闪现必杀技

关注

34
点赞
踩
20

收藏

觉得还不错? 一键收藏
9
评论
NzN的C++入门必修（一）

我们下来一起看一下上面这段代码，我们定义了一个全局变量rand=1，在main函数中打印rand这个值，那这段代码的执行结果应该是输出1这个值。但实际上，这段代码会报错。因为rand实际上是这个库里的一个函数，因此这个时候就会与全局变量这个名字产生冲突。在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。因此就诞生了命名空间。
复制链接

扫一扫

专栏目录