C++入门基础-优快云博客

本文链接：https://blog.youkuaiyun.com/x_p96484685433/article/details/143668841

前言

本文内容：C++的输入和输出、namespace命名空间、缺省参数、函数重载、引用、inline内联函数、nullptr。

一、C++的第一个程序

我们发现 c++ 的写法大致框架与我们学过的C语言类似（头文件和main函数），这是因为 c++ 就是在C语言的基础上发展过来的。

C++起源（简述）：

        C++的起源可以追溯到1979年，当时BjarneStroustrup(本贾尼·斯特劳斯特卢普，这个翻译的名字不同的地方可能有差异)在贝尔实验室从事计算机科学和软件工程的研究工作。面对项目中复杂的软件开发任务，特别是模拟和操作系统的开发工作，他感受到了现有语言（如C语言）在表达能力、可维护性和可扩展性方面的不足。

        1983年，BjarneStroustrup在C语言的基础上添加了面向对象编程的特性，设计出了C++语言的雏形。

        C++的标准化工作于1989年开始，并成立了⼀个ANSI和ISO（InternationalStandards Organization）国际标准化组织的联合标准化委员会。

        1994年标准化委员会提出了第⼀个标准化草案。在该草案中，委员会在保持斯特劳斯特卢普最初定义的所有特征的同时，还增加了部分新特征。在完成C++标准化的第⼀个草案后不久，STL（StandardTemplateLibrary）是惠普实验室开发的⼀系列软件的统称。它是由AlexanderStepanov、MengLee和DavidRMusser在惠普实验室⼯作时所开发出来的。在通过了标准化第⼀个草案之后，联合标准化委员会投票并通过了将STL包含到C++标准中的提议。STL对C++的扩展超出C++的最初定义范围。虽然在标准中增加STL是个很重要的决定，但也因此延缓了C++标准化的进程。

        1997年11月14日，联合标准化委员会通过了该标准的最终草案。1998年，C++的ANSI/IS0标准被投入使用。

BjarneStroustrup（本贾尼·斯特劳斯特卢普）就是我们 c++ 语言之父了，1950年出生的他至今健在。

C++文件名后缀为.cpp，C语言的代码文件后缀为.c，VS编译器就是通过这个后缀调用不同的编译器。C++兼容C，因此我们可以在 c++ 文件中编写C语言的代码

这里我们没有包含<stdio.h>头文件，也可以使用printf和scanf，在包含<iostream>间接包含了<stdio.h>。vs系列编译器是这样的，其他编译器可能会报错。

总之，C++兼容C语言绝大多数的语法，所以C语言实现的 hello world 依旧可以运行，C++中需要把定义文件后缀改为.cpp，vs编译器看到是.cpp就会调用C++编译器编译，Linux下要用g++编译，不再是gcc。

二、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流的用法。
cout/cin/endl等都属于C++标准库，C++标准库都放在⼀个叫std(standard)的命名空间中，所以要通过命名空间的使用方式去用他们。

我们平常练习也可以通过using namespace std省略 std::

不过实际项目开发中不建议using namespace std，会影响性能，下面会开始讲命名空间 namespace

三、namespace 命名空间

在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace 关键字的出现就是针对这种问题的。

例如以下情况，命名冲突：

命名空间的定义：

定义命名空间，需要使用到 namespace 关键字，后面跟命名空间的名字，然后接⼀对{}即可，{}中即为命名空间的成员。命名空间中可以定义变量/函数/类型等。
namespace本质是定义出⼀个域，这个域跟全局域各自独立，不同的域可以定义同名变量，所以下面的rand不在冲突了。

如：

#include <stdio.h>
#include <stdlib.h>

namespace A
{
	//定义变量
	int rand = 6;

	//定义函数
	int Add(int x, int y)
	{
		return x + y;
	}

	//定义结构体
	struct Node
	{
		struct Node* next;
		int data;
	};
}

int main()
{
	printf("%d\n", A::rand);
	printf("%p\n", rand);//打印函数地址

	return 0;
}

（双冒号 :: 作用就是指定域的）

运行结果：

C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找⼀个变量/函数/ 类型出处(声明或定义)的逻辑，所有有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不影响变量生命周期。
namespace只能定义在全局，当然他还可以嵌套定义。

如：

#include <stdio.h>
#include <stdlib.h>

namespace A
{
	//嵌套定义
	namespace B
	{
		int rand = 1;

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

	namespace C
	{
		int rand = 2;

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

int main()
{
	printf("%d\n", A::B::rand);
	printf("%d\n", A::C::rand);

	printf("%d\n", A::B::Add(1, 2));
	printf("%d\n", A::B::Add(3, 4));

	return 0;
}

运行结果

项目工程中多文件中定义的同名namespace会认为是⼀个namespace，他们会默认合并到⼀起，就像同⼀个 namespace ⼀样，不会冲突。

一个简单的单链表多文件定义示例，展示同名 namespace 效果：

//test.h文件
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

namespace A
{
	//定义一个链表结构
	typedef int SLTDataType;
	typedef struct SListNode
	{
		SLTDataType data;//节点数据
		struct SListNode* next;//指向下一节点的指针变量
	}SLTNode;

	//打印
	void SLTPrint(SLTNode* phead);

	//尾插
	void SLTPushBack(SLTNode** pphead, SLTDataType x);

	//销毁链表
	void SListDestroy(SLTNode** pphead);
}

//test.cpp文件
#include "test.h"

namespace A
{
	//打印
	void SLTPrint(SLTNode* phead)
	{
		SLTNode* pcur = phead;

		//循环打印
		while (pcur)
		{
			printf("%d->", pcur->data);
			pcur = pcur->next;
		}

		printf("NULL\n");
	}
	
	//申请节点
	SLTNode* SLTBuyNode(SLTDataType x)
	{
		//申请一个节点
		SLTNode* node = (SLTNode*)malloc(sizeof(SLTNode));
		if (node == NULL)
		{
			perror("malloc fail!");
			exit(1);
		}

		//赋值
		node->data = x;
		node->next = NULL;

		return node;
	}
	
	//尾插
	void SLTPushBack(SLTNode** pphead, SLTDataType x)
	{
		//断言pphead不能为空指针
		assert(pphead);
		//申请新节点
		SLTNode* newnode = SLTBuyNode(x);

		//如果pphead指向的第一个节点就是空指针
		if (*pphead == NULL)
		{
			*pphead = newnode;
		}
		else
		{
			//找尾结点
			SLTNode* pcur = *pphead;
			while (pcur->next)
			{
				pcur = pcur->next;
			}
			pcur->next = newnode;
		}
	}

	//销毁链表
	void SListDestroy(SLTNode** pphead)
	{
		assert(pphead && *pphead);
		SLTNode* pcur = *pphead;

		//循环销毁链表
		while (pcur)
		{
			SLTNode* next = pcur->next;
			free(pcur);
			pcur = next;
		}

		//记得将头指针指置空
		*pphead = NULL;
	}
}

int main()
{
	A::SLTNode* plist = NULL;
	A::SLTPushBack(&plist, 6);
	A::SLTPrint(plist);
	A::SListDestroy(&plist);

	return 0;
}

运行结果：

C++标准库都放在一个叫std(standard)的命名空间中。所以上面使用标准输入输出流时就要指定 std 命名空间。

命名空间的使用：

编译查找一个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间里面去查找。所以下面程序会编译报错。

所以我们要使用命名空间中定义的变量/函数，有三种方式式：

1. 指定命名空间访问，项目中推荐这种方式。

2. using 将命名空间中某个成员展开（using为c++的一个关键字），项目中经常访问的不存在冲突的成员推荐这种方式。

3. 展开命名空间中全部成员，项目不推荐，冲突风险很大，比如命名冲突等，日常小练习程序为了方便推荐使用（比如：using namespace std;）

补充：

在 IO 需求比较高的地方，如部分大量输入的竞赛题中，加上以下 3 行代码，可以提高 C++IO 效率（具体原理在c++后期中讲）

#include <iostream>
using namespace std;

int main()
{
	//提高IO效率
	ios_base::sync_with_stdio(false);//关掉c++与C语言的同步关系，也就是使c++不再兼容c了
	cin.tie(nullptr);//取消与其他流的绑定
	cout.tie(nullptr);

	return 0;
}

四、缺省参数

缺省参数是声明或定义函数时为函数的参数指定⼀个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。（有些地方把缺省参数也叫默认参数）

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

#include <iostream>
using namespace std;

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

//半缺省，缺省值必须右往左给
void Func2(int a, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
}


int main()
{
	Func1();//不传参，形参全部使用缺省值
	Func1(6);//传参，则根据实参个数从左往右给形参赋值
	Func1(6, 66);
	Func1(6, 66, 666);

	Func2(6);//半缺省必须给无缺省值的形参赋值
	Func2(6, 66);
	Func2(6, 66, 666);

	return 0;
}

运行结果：

函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。

//test.h文件

#pragma once
#include <iostream>
using namespace std;

int Add(int x = 0, int y = 0);

void Func(int a, int b = 6);

//test.cpp文件

#include "test.h"

//缺省值已经在声明时出现，定义时不能再写缺省值了
int Add(int x, int y)
{
	return x + y;
}

void Func(int a, int b)
{
	cout << a << endl;
	cout << b << endl << endl;
}

//main.cpp文件

#include "test.h"

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

	Func(3);
	Func(10, 20);

	return 0;
}

运行结果：

如果在定义文件中也写了缺省值，会出现以下报错

五、函数重载

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

重载的方式有以下几种：

1，参数类型不同

#include <iostream>
using namespace std;

//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;
}

int main()
{
	int a = 10, b = 20;
	double c = 9.9, d = 19.9;

	cout << Add(a, b) << endl;
	cout << Add(c, d) << endl;

	return 0;
}

运行结果：

2，参数个数不同

3，参数类型顺序不同

注意：返回值不同不能作为重载条件，因为调用时也无法区分

另外，需要注意的是，全缺省参数与无参存在歧义，调用时会报错，编译器不知道调用谁

因此，在定义重载函数时，如果使用了缺省参数，需要格外注意类似情况

六、引用

概念与定义：

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

用法：

类型& 引用别名 = 引用对象;

C++ 中为了避免引入太多的运算符，会复用C语言的一些符号，比如前面的 << 和 >>，这里引用也和取地址使用了同一个符号&，注意使用方法角度区分就可以。（这里的复用本质是运算符重载）

引用是对变量取别名，自己与引用对象共用一块空间，修改引用变量就是在引用对象上进行修改

是不是和指针很像？

2.引用的特性

引用在定义时必须初始化
⼀个变量可以有多个引用
引用一旦引用一个实体，再不能引用其他实体

3.引用的使用

引用在实践中主要是于引用传参和引用做返回值中减少拷贝提高效率和改变引用对象时同时改变被引用对象。
引用传参跟指针传参功能是类似的，引用传参相对更方便⼀些。

引用返回值的场景相对比较复杂，我们在这里简单讲了一下场景，详细讲解在后续篇章中

比如我们数据结构中的栈，有一个取栈顶元素的方法，它的返回值我们可以写成引用，这样我们对返回值操作也会影响到栈顶元素。

// int STTop(ST& rs)
 int& STTop(ST& rs)
 {
     assert(rs.top > 0);
     return rs.a[rs.top];
 }

我们在目前需要认识到的是，不是所有场景都能使用引用作为返回值

#include <iostream>
using namespace std;

int& Func()
{
	int a = 10;
	a++;

	return a;
}

int main()
{
	Func() += 1;

	return 0;
}

以上场景中 Func 的返回值为局部变量 a 的引用，我们知道函数结束后它的函数栈帧就销毁了，因此局部变量 a 也被销毁了，在指针中，如果返回了一个局部变量的指针那么它就是一个野指针。因此对这样的引用返回值进行操作其实是一种越界，不合规的。

编译器只是报了一个警告，因为编译器对于越界修改这一行为采用抽查的方式判断，因次越界访问并修改不一定会报错。（只是越界读是一定不会报错的，越界写不一定报错因为是抽查）

我们还可以对一级指针变量取别名，这样就不用二级指针就可以修改一级指针的指向了。

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

4.const引用

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

#include <iostream>
using namespace std;

int main()
{
	const int a = 10;
	const int& ra = a;

	
	//int& ra = a; //error C2440: “初始化”: 无法从“const int”转换为“int &”
				   //不加 consr 引用const对象会报错，这里就是权限的放大

	int b = 20;
	const int& rb = b;//这里是权限的缩小，可以引用


	return 0;
}

需要注意的是类似 int& ra = a*3; double d = 12.34; int& rd = d; 这样一些场景下 a*3 的和结果保存在一个临时对象中， int& rd = d 也是类似，在类型转换中会产生临时对象存储中间值，也就是说，ra 和 rd 引用的都是临时对象，而C++规定临时对象具有常性，所以这里就触发了权限放大，必须要用常引用才可以。

#include <iostream>
using namespace std;

int main()
{
	int a = 10;
	const int& ra = a * 3;

	double d = 13.14;
	const int& rd = d;

	return 0;
}

像上述中的表达式，强制转换，我们对其进行引用时其实引用的是一个中间的临时对象。这种临时对象具有常性，也就是不可改变的性质，因此引用时必须使用 const 修饰。

所谓临时对象就是编译器需要一个空间暂存表达式的求值结果时临时创建的⼀个未命名的对象， C++中把这个未命名对象叫做临时对象。

5.指针和引用的关系

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

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

底层汇编的角度看，引用也是由指针实现的

6.inline

用 inline 修饰的函数叫做内联函数，编译时C++编译器会在调用的地方展开内联函数，这样调用内联函数就不需要建立栈帧了，就可以提高效率。
inline 对于编译器而言只是⼀个建议，也就是说，你加了inline编译器也可以选择在调用的地方不展开，不同编译器关于 inline 什么情况展开各不相同，因为C++标准没有规定这个。inline适用于频繁调用的短小函数，对于递归函数，代码相对多⼀些的函数，加上inline也会被编译器忽略。
C语言实现宏函数也会在预处理时替换展开，但是宏函数实现很复杂很容易出错的，且不方便调试，C++设计了 inline 目的就是替代C的宏函数。

#include <iostream>
using namespace std;

//内联函数
inline int Add(int a, int b)
{
	return a + b;
}

int main()
{
	int ret = Add(2, 3);
	cout << ret << endl;

	return 0;
}

vs编译器debug版本下面默认是不展开 inline 的，这样方便调试，debug版本想展开需要设置一下以下两个地方。

因为我用的 vs2022 即使这样设置了也没有效果，只有 vs2019 及以下才有效果，具体效果通过反汇编查看。

最后，inline 不建议声明和定义分离到两个文件，分离会导致链接错误。因为 inline 被展开，就没有函数地址，链接时会出现报错。

7.nullptr

NULL 实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifndef NULL
    #ifdef __cplusplus
        #define NULL 0
    #else
        #define NULL ((void *)0)
    #endif
#endif

C++中NULL可能被定义为字面常量0，或者C中被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到⼀些麻烦，本想通过 f(NULL) 调用指针版本的 f(int*) 函数，但是由于NULL被定义成0，调用了 f(int x)，因此与程序的初衷相悖。f((void*)NULL); 调用会报错。

这里原因就是：

#ifdef __cplusplus
        #define NULL 0

_cplusplus 就是c++下的定义。

哪怕手动使用第二个定义 ((void *)0) 就会会报错，因为 c++ 不支持强转为 void* 类型

虽然使用 int*进行强制可以，但是这样不够通用

C++11中引入nullptr，nullptr是一个特殊的关键字，nullptr是一种特殊类型的字面量，它可以转换成任意其他类型的指针类型。使用 nullptr 定义空指针可以避免类型转换的问题，因为 nullptr 只能被隐式地转换为指针类型，而不能被转换为整数类型。

总之，你可以把 nullptr 认为是C++版的 NULL。

总结

以上就是本文的全部内容，感谢支持