C++入门基础

最新推荐文章于 2026-06-26 18:45:00 发布

原创最新推荐文章于 2026-06-26 18:45:00 发布 · 700 阅读

21 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#c++

1. C++第一个程序

2. 命名空间

2.1 C程序的第一个缺陷 -- 命名冲突

1. C++第一个程序

C++兼容C语言绝大多数语法，所以C语言实现的hello world依旧可以运行，C++中需要把定义文件代码后缀改为.pp，这时候VS看到.cpp就会调用C++编译器编译。

#include <stdio.h>
int main()
{
	printf("hell world!");
	return 0;
}

这是我们之前在C程序中写的代码，在C++程序中仍然可以运行。

当然C++也有自己的一套输入输出，C++版本的hello world程序如下：

#include <iostream>
using namespace std;

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

	return 0;
}

不理解或者看不懂是没有关系的，后面我们是会详细说明的。可以看出，C++程序和C程序有了不小的差异。

2. 命名空间

2.1 C程序的第一个缺陷 -- 命名冲突

在C/C++中，变量，函数和后面要学习的类都是大量存在的，这些变量、函数和类的名称都将存在于全局域中，可能会导致很多冲突。

举一个例子，由于C++兼容C所以我们直接在C++中演示

在这段代码中，我们定义了全局变量rand，同时包含了一个库，这个库中有一个rand函数，这样就造成了命名冲突，C程序报错，但我们把24行注释掉，程序就可以正常运行。

看到了吧，这就是我们在引入外部库经常报一堆错的原因之一。我们知晓了缺陷，所以C++就做出了调整，使用namespace对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

2.2 namespace定义

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

现在，我们来定义一个命名空间。

// namespace 定义
namespace zt
{
	// 命名空间可以定义变量/函数/类型等
	int rand = 10;

	int Add(int x, int y)
	{
		return x + y;
	}

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

注意：命名空间后面是不加分号的。

我们现在有了一个命名空间，使用一下它。在使用它之前，我们看一下它的本质：

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

我们先来看一段代码，了解一个符号。

int a = 1;

int main()
{
	int a = 0;
	printf("%d\n", a);
	return 0;
}

这段代码会打印出来哪个a的值？ -- 屏幕上会打印 0

这是因为局部优先原则。编译器语法查找确认，默认是先局部查找 -- 全局查找 -- 没有找到就报错未声明的标识符。

那么我们非要访问全局的这个变量a呢？这就得用到 -- :: 域作用限定符。我们来看看实际效果。

在使用域作用限定符的时候，前面啥都不加，就像上图一样，就表示作用在全局域中。

聪明的你一下就想到了在使用命名空间的时候就是在域作用限定符的前面加上命名空间的名字。也就是如下代码段（我们仍然使用前面定义的命名空间作为例子）

int a = 1;

int main()
{
	int const a = 0;
	printf("%d\n", a);
	// ::域作用限定符
	printf("%d\n", ::a);

	printf("%d\n", zt::rand);
	printf("%p\n", zt::Add);
	printf("%d\n", zt::Add(1, 2));  // 使用函数
	struct zt::Node s;  // 定义一个结构体变量
	return 0;
}

我们已经学会命名空间的初步使用，这样子命名冲突的问题就可以得到解决了。

C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找一个变量/函数/类型出处（声明或定义）的逻辑，所有有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不影响变量生命周期。
namespace只能定义在全局，当然他可以嵌套定义。
项目工程中多文件定义的同名namespace会认为是一个namespace，不会冲突。
C++标准库都放在一个叫std（standard）的命名空间中。

2.3 命名空间的使用

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

我们学习命名空间的使用会和下面的 C++输入&输出结合在一起学习，也就是它们俩个一起看。

指定命名空间访问，项目中推荐这种方式。
using将命名空间中某个成员展开，项目中经常访问的不存在冲突的成员推荐这种方式，
展开命名空间中全部成员，项目不推荐，冲突分线很大，经常使用在小练习中，方便。

3. C++输入&输出

这里只是简单的介绍一下，因为这里面牵扯到类和对象，我们会在学习完继承的时候，详细了解IO流。

<iostream>是Input Output Stream 的缩写，是标准的输入、输出流库，定义了标准的输入、输出对象。
std::cin 是 istream 类的对象，它主要面向窄字符的标准输入流。
std::cout 是 ostream 类的对象，它主要面向窄字符的标准输出流。
std::endl 是操纵符，底层实现是一个函数，流插入输出时，相当于一个换行字符刷新缓冲区。
<<是流插入运算符，>>是流提取运算符。（C语言还用这两个运算符做位运算左移/右移）

代码演示：

#include <iostream>
// C++输入&输出
int main()
{
	int i = 10000;
	// 位操作（C++包容C）
	i << 5;

	double d = 1.1;

	// 任何变量转换为字符串，插入到流中。
	std::cout << i << '\n' << "\n"; // 流输出 换行
	std::cout << i << "hello world" << std::endl; // end line 换行 会刷新缓冲区
	std::cout << i << ' ' << d << std::endl;

	// 再来看看cin
	std::cin >> i >> d;
	std::cout << i << ' ' << d << std::endl;

	return 0;
}

从上面这段代码中，我们一直在使用std:: ，感觉好烦呀，能不能不加std::？答案是可以的，我们可以使用2.3中的第3点 -- 展开全部命名空间。

也就是：

#include <iostream>
using namespace std;  
// C++输入&输出
int main()
{
	int i = 10000;
	// 位操作（C++包容C）
	i << 5;

	double d = 1.1;

	// 任何变量转换为字符串，插入到流中。
	cout << i << '\n' << "\n"; // 流输出 换行
	cout << i << "hello world" << endl; // end line 换行 会刷新缓冲区
	cout << i << ' ' << d << endl;

	// 再来看看cin
	cin >> i >> d;
	cout << i << ' ' << d << endl;

	return 0;
}

这样子写就是相当于把标准库展开在全局中，然后编译器默认方式查找。当然这也会导致一个问题，我们仍然会遇见命名冲突问题。所以使用在小练习中。

有没有折中的方法 -- 部分展开。

using std::cout;

这样展开即可。

使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动指定格式，C++的输入输出可以自动识别变量类型（本质是通过函数重载实现的，这个以后会学习到），其实最重要的是C++的流能更好的支持自定义类型对象的输入输出。
IO流涉及类和对象，运算符重载、继承等很多面向对象的知识，这些知识我们还没有学习到，所以我们就简单的认识一下C++IO流的用法。
cout/cin/endl等都属于C++标准库，C++标准库都放在一个叫std的命名空间中，所以要通过命名空间的使用方式去用他们，
一般日常练习中我们可以使用using namespace std，实际项目开发中不建议直接使用它展开。
这里我们没有包含<stdio.h>，也可以使用printf/scanf，在包含<iostream>间接包含了，VS系列的编译器是这样的，其他编译器可能会报错。

4. 缺省参数（默认参数）

缺省参数是声明或定义函数时为函数指定一个缺省值。在调用函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。

// c++入门
#include <iostream>
using namespace std;

void Fun(int a = 0)
{
	cout << a << endl;
}
int main()
{
	Fun(1);
	Fun();
	return 0;
}

// 缺省参数
void Fun(int a = 0)
{
	cout << a << endl;
}

// 全缺省
void Func(int a = 10, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
}
int main()
{
	Fun(1);
	Fun();

	Func(1, 2, 3);
	Func(1, 2);
	Func(1);
	Func();
	return 0;
}

全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。

// 半缺省
void Fun(int a, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}
int main()
{
	Fun(1);
	Fun(1,2,3);
	Fun(1, 2);

	return 0;
}

带缺省参数的函数调用，C++规定必须次从左到右依次给实参，不能跳跃给实参。否则会编译错误。
函数声明和定义分离时，缺省参数不能再函数声明和定义中同时出现，规定必须函数声明给缺省值。

比如说我们定义一个顺序表，如果数据量比较庞大，我们就需要扩容，扩容是需要占用资源的，所以我们可以在声明的时候，加入参数n，这样我们需要多大空间，我们就键入多少，当然，这是你知道需要多大空间的时候，当我们不知道需要多大空间的时候，我们就可以定义缺省参数，当然是在声明的时候给，如果我们在定义的时候又进行了缺省参数的定义，那么就会报错，因为我们如果在声明的时候给了4，但是在定义的时候给了8，那我们该使用哪个值，为了不出现这样的错误，我们就规定函数声明和定义分离时，缺省参数不能再函数声明和定义中同时出现，规定必须函数声明给缺省值。

5. 函数重载

C++支持在同一作用域中出现的同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同。这样C++函数调用就表现出了多态行为，使用更加灵活。C语言不支持同一作用域中出现同名函数的。

// 函数重载
#include <iostream>
using namespace std;

// 类型不同
int Add(int left, int right)
{
	cout << "Add(int left, int right)" << endl;
	return left + right;
}

double Add(double left, double right)
{
	cout << "Add(double left, double right)" << endl;
	return left + right;
}

// 参数个数不同
void fun()
{
	cout << "fun()" << endl;

}

void fun(int a)
{
	cout << "fun(int a)" << endl;
}

int main()
{
	cout << Add(1, 2) << endl;
	cout << Add(1.1, 1.2) << endl;

	fun();
	fun(1);


	return 0;
}

以上的函数重载是没有问题的，但是下面俩个的函数重载是有问题的。大家在使用的时候要注意。

#include <iostream>
using namespace std;

// 函数返回值不同

int f()
{
	return 1;
}
int f()
{
	return 2;
}

// 函数缺省参数
int f1()
{
	return 1;
}
int f1(int a = 0)
{
	return 2;
}

int main()
{
	cout << f() << endl;
	cout << f() << endl;
	// 无法分析函数重载

	cout << f1(1) << endl;
	cout << f1() << endl; // 无法确定使用哪个函数
	return 0;
}

就是一些简单的例子，代码可以说是特别简单。主要是了解函数重载的概念。

6. 引用

6.1 引用的概念和定义

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

相当于你自己的小名或者外号，家长叫你小名，同学叫你外号的时候，你会答应，这是一个道理。

我们来看个例子：

// 引用
#include <iostream>	
using namespace std;

int main()
{
	int i = 0;
	cout << &i << endl;
	int& j = i;
	cout << &j << endl;
	return 0;
}

二者打印的地址是一样的。

6.2 引用的特性

引用在定义时必须要初始化。

int main()
{
	int& x;
	x = i;
	return 0;
}

这样是不行的，也就是引用必须要初始化。

一个变量可以有多个引用。

通俗一点讲就是你可以多个小名或者外号。

引用一旦引用一个实体，再不能引用另一个实体。

int main()
{
	int i = 0;
	int& j = i;
	int m = 20;
	j = m;
	return 0;
}

把m的值赋给j。

6.3 引用的使用

引用在实践中主要用于引用传参和传引用返回中减少拷贝提高效率和改变引用对象时同时改变被引用

示例1：

我们之前在学习C语言的时候，使用交换函数来交换俩个数的值，使用的是指针，因为直接传参是交换不了的，所以用地址进行交换。这里我们使用引用来进行交换。

// 引用的使用 -- 传参
void swap(int* rx, int* ry)
{
	int temp = 0;
	temp = *rx;
	*rx = *ry;
	*ry = temp;
}
void swap1(int& rx, int& ry)
{
	int temp = 0;
	temp = rx;
	rx = ry;
	ry = temp;
}
int main()
{
	int x = 10; 
	int y = 20;
	// 之前的交换方式
	cout << x << ' ' << y << ' ' << endl;
	swap(&x, &y);
	cout << x << ' ' << y << ' ' << endl;
	// 使用引用来交换
	swap1(x, y);
	cout << x << ' ' << y << ' ' << endl;

	return 0;
}

示例2：

结构体传参

typedef struct SeqList
{
	// ...
}SL;
void SLInit(SL& psl, int n = 4)
{
	
}

int main()
{
	SL s;
	SLInit(s);

	return 0;
}

示例3：

传指针

我们之前使用指针调换的时候是传地址使用二级指针：

void Swap(int** pp1, int** pp2)
{
	int* temp = *pp1;
	*pp1 = *pp2;
	*pp2 = temp;
}

现在我们使用引用：

void Swap(int*& p1, int*& p2)
{
	int* temp = p1;
	p1 = p2;
	p2 = temp;
}

直接传指针即可。使用起来更加方便，也更容易懂，不像二级指针那么绕。

引用传参跟指针传参功能是类似的，引用传参相对更方便一些。

我们上边的场景体现的很明显。

传值返回会产生临时对象作为函数调用表达式的返回值，传引用返回的本质是返回返回对象的引用（别名），从而提高了效率，同时可以改变返回对象。（不是所有场景都可以传引用返回，如果是一个返回值是当前函数的局部对象，传引用返回是有风险的。）

我们先看一个场景：传值返回

int fun()
{
	int ret = 0;
	// ...
	return ret;
}

int main()
{
	int x = fun();

	return 0;
}

你们说这里是不是把ret赋给x，答案是不是，为什么？

实际上是把ret的临时变量赋给x而且这个变量是类似于被const修饰的是不可以修改的。

接下来我们看传引用返回：

int& fun()
{
	int ret = 0;
	// ...
	return ret;
}

int main()
{
	int x = fun();

	return 0;
}

这样引用是错误的，因为ret出了函数就会被销毁，相当于访问了一个空间，所以我们在ret前面加上stantic就可以了，这样ret出了函数还是存在的。

引用和指针在实践中相辅相成，功能具有叠加性，但是各有特点，互相不可代替。C++的引用跟其他语言的引用有很大区别，除了用法，最大的点，C++引用定义后不能改变指向，Java的引用可以改变指向。

6.4 const引用

可以引用一个const对象，但是必须用const引用。const引用也可以引用普通对象，因为对象的访问权限在引用过程中可以缩小，但是不能放大。

代码演示：

// const引用
#include <iostream>
using namespace std;

int main()

{
	//权限缩小，可以引用
	int a = 0;
	const int& b = a;

	// 权限放大，不可以引用
	const int c = 1;
	//int& d = c;
	// 
	// 可以引用
	const int& d = c;
	// 赋值拷贝
	const int e = a;

	// 权限的放大缩小，只存在与const指针与引用中
	// 权限放大，不可以引用
	const int* p1 = &a;
	//int*& p2 = p1;
	const int* p2 = p1;

	return 0;
}

不需要注意的类似 int& rb = a*3; double d = 12.34; int& rd = d; 这样一些场景下a*3和结果保存在一个临时对象中，int& rd = d 也是类似，在类型转换中会产生临时对象储存中间值，也就是说，rb和rd引用的都是临时对象，而C++规定临时对象具有常性，所以这里就触发了权限放大，必须要常引用才可以。
所谓临时对象就是编译器需要一个空间暂存表达式的求值结果临时创建的一个未命名的对象，C++把这个未命名对象叫做临时对象。

代码演示：

int main()
{
	int i = 1;
	double d = i;

	const double& rd = i;

	return 0;
}

6.5 引用与指针的关系

C++中指针和引用就像两个性格迥异的亲兄弟，指针是哥哥，引用是弟弟，在实践中它们相辅相成，功能有重叠性，但是各自有自己的特点，互相不可替代。

语法概念上引用是一个变量的取别名不开空间，指针储存一个变量地址，要开空间。
引用在定义时必须初始化，指针建议初始化，但是在语法上不是必须的。
引用在初始化时引用一个对象后，就不能再引用其它对象；而指针可以不断的改变指向对象。
引用可以直接访问对象，指针需要解引用才访问指向对象。
sizeof中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数。
指针很容易出现空指针和野指针问题，引用很少出现，引用使用起来相对更安全一些。

7. inline

在学习inline前，我们先来复习一下宏。假设我们需要写一个宏函数那么，你会怎么写。

这里列出几种错误的写法（或者是不完全的写法）：

1. 把函数当宏函数写

#define int Add(x,y) return x + y

这种代码写出来一看就是完全不懂这部分内容。属于不懂装懂类型。

2. 宏定义后加分号

#define Add(x,y) x + y;

这段代码，在部分场景下适用，在部分场景下不适用。算是懂一丢丢，但不多。

int ret = Add(1 ,2);
cout << ret << endl;

在这个场景下是可以运行的，但是在其他场景中可能就会出错。

比如说我们看这个场景：

int ret = Add(1 ,2)* 3;
cout << ret << endl;

因为宏的本质是替换，也就是说放在代码中编译器经过预处理后：1 + 2 ；* 3，这是得不到我们想要的结果的。直接报错。

3. 宏定义后加上括号

#define Add(x,y) (x + y)

这是最接近正确答案的，是勉强合格的，包含了2中场景，但是还是有缺点的。

	int a = 1, b = 2;
	int ret = Add(a|b , a&b);
	cout << ret << endl;

我们这里使用了一个表达式，也就是处理后（1|2 + 1&2）这里就涉及到运算符的优先级，+是优先于|和&的。

4. 正确的

#define Add(x,y) ((x) + (y))

这样子使用，我们就不会有运算先后的问题。

宏有很多的缺点，宏不能调试，宏函数很复杂，容易写出问题。

既然宏有那么多的缺点，但是为什么还是有许多人趋之若鹜呢？

这就要说说宏的优点了：高频调用的小函数，写成宏函数，可以提高效率，不会建立栈帧空间。

看到这里，大家会有疑问，inline和宏有什么联系呢？

别急，接着往下看。

用inline修饰的函数叫做内联函数，编译时C++编译器会在调用的地方展开内联函数，这样调用内联函数就不需要建立栈帧了，就可以提高效率。

inline int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int ret = Add(1, 2);
	cout << ret << endl;

	return 0;
}

这样子写就会使上面的场景都可以使用。

inline对于编译器而言只是一个建议，也就是说，你加了inline编译器也可以选择在调用的地方不展开，不同编译器关于inline什么情况展开各不相同，因为C++没有规定这个，inline适用于频繁调用的短小函数，对于递归函数，代码相对多一些的函数，加上inline也会被编译器忽略。

代码演示：

在一些情况下编译器是不会展开inline的，VS差不多10行左右，当然我们在debug下调试。

有的小伙伴的编译器inline展开会有问题。大家可以这样做：

C语言实现宏函数也会在预处理时替换展开，但是宏函数实现很复杂很容易出错的，且不方便调试，C++设计了inline的目的就是替代C的宏函数。
VS编译器debug版本下面默认是不展开inline的，这样方便调试，我们上面已经展示了如何设置展开inline。
inline不建议声明和定义分离到两个文件，分离会导致链接错误。因为inline被展开，就没有函数地址，链接时会出错。

8. nullptr

NULL实际是一个宏。这里使用nullptr就是为了解决一个问题：

// nullptr
void f(int x)
{
	cout << "f(int x)" << endl;

}

void f(int* x)
{
	cout << "f(int* x)" << endl;

}
int main()
{
	f(0);
	f(NULL);
	return 0;
}

这段代码我们运行后：

我们定义了函数重载，本想输出int x 和 int* x，但是二者都输出了int x，这是因为在C++中NULL是整型的 0，与第一个函数更匹配，所以设计了nullptr。

C++中NULL可能被定义为字面常量0，或者C中被定义为无类型指针的常量，不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，本想通过f（NULL）调用指针版本的f（int*）函数，但是由于NULL被定义成0，调用了f（int x）。因此与程序的初衷相悖，f（（void*）NULL）会报错。
C++11中引入nullptr，nullptr是一个特殊关键字，nullptr是一种特殊的字面常量，它可以转换成任意类型的指针类型。使用nullptr定义空指针可以避免类型转换的问题，因为nullptr只能被隐式的转换成指针类型，而不能被转换成整数类型。