C++是在C的基础之上，容纳进去了面向对象编程思想，并增加了许多有用的库，以及编程范式等

C++ 为了解决 C语言中存在的一些不好的地方，从而增加了一些语法

一、命名空间

在项目组中，进行代码合并时，可能会遇到自己和其他人写的代码，定义了相同的名字，发生命名冲突，在C语言中，只能在产生错误后，修改名字，没有很好的预防手段

自己定义的变量名，函数名，类型名等，都可能会和别人定义的名字冲突，或者和库的名字冲突，因为此时相同的名字处在同一个域(全局域)

而在不同的域定义了相同的名字，并不会产生命名冲突，使用时是局部优先

C++ 中增加了另一种新的域，叫做命名空间，用 namespace 关键字定义

命名空间定义：
namespace 空间名
{
	//类型，变量，函数等
	
}	//花括号后没有分号

将处在全局域中的变量，函数，类型等，封装在命名空间域中，便可以防止命名冲突

在命名空间域中也包含全局域和局部域，因此不会影响变量的生命周期

在命名空间域中，内部对内部的访问，也是遵守先声明后使用，优先使用局部，然后使用命名空间域中的全局，最后使用命名空间域外的全局

命名空间域会影响编译时期的查找规则，在查找一个变量、函数、类型是否定义时，默认是在局部找(代码块内)，局部不存在便会去全局找，全局找不到便会报错，不会直接去已经定义的命名空间中找

外部想要访问命名空间内部的内容时：有三种方法

• 指定命名空间访问，使用域作用限定符 :: (两个冒号)
• 展开命名空间中的所有内容，using namespace 命名空间名
• 展开命名空间中的常用内容，using 命名空间名 :: 内容

C++ 中，将标准库函数的代码放在 iostream 头文件中，并用 std 命名空间封装，防止用户和库中的命名冲突，这里以 cout 为例

//指定命名空间访问
//:: 域作用限定符，左边为空，代表在全局域中查找
#include <iostream>

int main()
{
	std::cout << "hello world";
	
	return 0;
}

//展开命名空间中的所有内容
#include <iostream>

using namespace std;

int main()
{
	cout << "hello world";

	return 0;
}

//展开命名空间中的常用内容
#include <iostream>

using std::cout;

int main()
{
	cout << "hello world";

	return 0;
}

平时练习时可以使用全部展开，写项目时建议展开常用的和指定访问

还需要注意几点

• 命名空间的名字相同时，会合并为一个命名空间，但是名字相同的命名空间中，如果存在相同的定义会报错
• 命名空间可以定义在命名空间中，即命名空间可以嵌套定义

二、输入输出

C++ 中标准库提供的 cin 可以用于输入，cout 可以用于输出，cin 和 cout 自动识别类型，不用指定输入输出格式，cout 中 endl 表示换行

#include <iostream>

//为了可以找到封装在 std 中的 cin 和 cout
using namespace std;

int main()
{
    char c;
    int i;
    double d;

	//自动识别类型，cin >> 可以简单理解为数据从控制台流向变量
    cin >> c >> i >> d;
    
    //自动识别类型，输出数据后换行，cout << 可以简单理解为数据从变量流向控制台
    cout << c << endl;
    cout << i << endl;
    cout << d << endl;
    cout << "hello C++" << endl;
    
    return 0;
}

三、缺省参数

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

声明或定义函数时只能从右往左连续的为函数的参数指定缺省值，调用函数传参时，也只能从右往左连续省略实参

#include <iostream>

using namespace std;

//只能从右往左连续的为函数的参数指定缺省值
//void f1(int a, int b = 3, int c) -- 错误写法
void f1(int a, int b = 3, int c = 10)
{
    cout << a << " ";
    cout << b << " ";
    cout << c << endl;
}

int main()
{
    //只能从右往左连续省略实参
    //f1(1, , 3); -- 错误写法
    f1(1);
    f1(1, 2);
    f1(1, 2, 3);

    return  0;
}

注意：

• 有缺省参数时，声明和定义不能同时给缺省参数，推荐在声明给，如果出现声明和定义分离(多文件时)，只能在声明给，定义时不给
• 缺省值只能是常量或全局变量(一般不使用全局变量)

//报错：非法将局部变量作为缺省参数
void f1(int a, int b = a)
{
	cout << a << endl;
}

四、函数重载

C++ 允许 在同一作用域中 声明几个功能类似的 同名函数，但是需要满足这些同名函数的形参列表(参数个数 或 参数类型 或 参数类型顺序)不同，常用来处理实现功能类似，但参数的数据类型不同的问题

#include <iostream>

using namespace std;

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

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

//参数类型不同
int Add(int A, int B)
{
	return A + B;
}

double Add(double A, double B)
{
	return A + B;
}

//类型顺序不同
void f2(int i, char c)
{
	cout << "f2(int i, char c)" << endl;
}

void f2(char c, int i)
{
	cout << "f2(char c, int i)" << endl;
}

int main()
{
	//参数个数不同
	f1();
	f1(1);

	//参数类型不同
	cout << Add(1, 2) << endl;
	cout << Add(1.1, 2.2) << endl;

	//参数顺序不同
	f2(1, 'a');
	f2('a', 1);

	return 0;
}

未重载的函数，调用函数传参类型不同时，会隐式转换

重载的函数，调用函数时，实参的参数列表 和 所有重载的函数的参数列表 都不匹配时，不会隐式转换，编译器无法分辨调用哪个函数，便会报错

C++ 函数重载的原理 – 对函数名修饰
以 Linux 下的 gcc/g++函数名修饰规则为例

用 gcc 编译 .c 文件后，用 objdump -S 可执行程序 指令，查看函数名修饰规则

用 g++ 编译 .cpp 文件后，用 objdump -S 可执行程序 指令，查看函数名修饰规则

在编译时期对函数名进行修饰之后，便可以根据调用函数时给的参数类型，确定函数调用的是哪个重载函数，因此重载函数只会影响编译速度

函数调用时，返回值可以选择性的使用，因此只有返回值不同的同名函数，调用时无法区分，便不能构成重载

五、引用

1. 引用的用法

//定义引用
//类型& 引用名 = 引用实体;
int a = 10;
int& ra = a;

在使用上：引用不是定义新变量，而是给指定的变量取别名，和该变量共用同一块空间

#include <iostream>

using namespace std;

int main()
{
	//定义变量 i
	int i = 0;
	
	//定义新变量 j, i 和 j 占用不同的空间
	int j = i;
	
	//给变量 i 取别名, i 和 k 占用相同的空间
	int& k = i;
	
	//i 和 j 的地址不同
	//i 和 k 的地址相同
	cout << &i << " ";
	cout << &j << " ";
	cout << &k << endl;
	
	++i;
	++j;
	++k;
	
	//结果为 2 1 2
	cout << i << " ";
	cout << j << " ";
	cout << k << endl;

	return 0;
}

注意：

• 引用是变量的别名
• 引用在定义时必须初始化
• 变量可以有多个引用，可以给引用初始化为变量的别名(给别名取别名，都是同一个变量)
• 引用指定实体后，不能在引用其他实体
• 没有 NULL 引用
• 在 sizeof 中，引用结果为引用类型大小
• 没有多级引用，引用指针，引用数组，可以按以下内容理解
  引用不需要开辟新空间，没有引用的引用
  引用不需要开辟新空间，没有引用的指针
  引用不需要开辟新空间，不能作为数组元素(数组元素有空间)，即不存在引用数组

2. 常引用

C++ 中，指针和引用在使用时，权限只能保持或缩小，但是 权限不能放大

先以指针为例：

#include <iostream>

using namespace std;

int main()
{
	//指针权限放大 - error
	//i 是常变量，不可以被修改
	//int* 可以通过解引用修改变量的值
	//不可以修改 --> 可以修改 权限放大(不允许)
	const int i = 0;
	int* pi = &i;	//报错，const int* 无法转换为 int*

	//指针权限保持
	//i 是常变量，不可以被修改
	//const 修饰 *pi，因此 pi 不能通过解引用修改变量 i 的值
	//不可以修改 --> 不可以修改 权限保持
	const int i = 0;
	const int* pi = &i;

	//指针权限缩小
	//i 是变量，可以被修改
	//const 修饰 *pi，因此 pi 不能通过解引用修改变量 i 的值
	//可以修改 --> 不可以修改 权限缩小
	int i = 0;
	const int* pi = &i;

	return 0;
}

引用也是如此：

#include <iostream>

using namespace std;

int main()
{
	//引用权限放大 - error
	const int i = 0;
	int& ri = i;	//报错，const int 无法转换为 int&

	int& r = 10;	//报错

	//引用权限保持
	const int i = 0;
	const int& ri = i;

	const int& r = 10;

	//引用权限缩小
	int i = 0;
	const int& ri = i;

	return 0;
}

3. 引用的使用场景

(1) 输出型参数：

#include <iostream>

using namespace std;

//引用做参数，可以直接修改实参的值
void Swap(int& r1, int& r2)
{
    int tmp = r1;
    r1 = r2;
    r2 = tmp;
}

int main()
{
    int a = 10, b = 20;
  
    cout << a << " " << b << endl;

	//直接传变量 a 和 b;
    Swap(a, b);

    cout << a << " " << b << endl;

    return 0;
}

输出：
10 20
20 10

(2) 返回值引用：

在函数栈帧的知识中，函数的返回值是通过临时变量返回的(为什么不能直接返回？因为函数调用结束，回到调用函数处时，被调用函数的栈帧已经还给操作系统了)，如果返回值较小，则使用寄存器，如果返回值较大，则在调用函数的栈帧中开辟

下述代码中，变量 n 在静态区，当函数调用结束，回到调用函数的栈帧中时，变量 n 不会被销毁，但是编译器还是会通过临时变量的方式带回返回值

int Count()
{
   static int n = 0;
   n++;
   
   // ...
   
   return n;
}

int main()
{
	int ret = Count();
	return 0;
}

此时程序员可以自行调整代码，将返回值设置为引用，便不会使用临时变量，而是使用原空间的别名

int& Count()
{
   static int n = 0;
   n++;
   
   // ...
   
   return n;
}

int main()
{
	int ret = Count();
	return 0;
}

注意：不要返回当前函数栈帧中的变量的引用

#include <iostream>

using namespace std;

int& Add(int a, int b)
{
	int c = a + b;
	
	return c;
}

int main()
{
	int& ret = Add(1, 2);

	//ret 的结果是随机值
	cout << "Add(1, 2) is ：" << ret << endl;

	return 0;
}

什么情况下可以返回引用：调用函数结束，回到调用函数处时，变量不会销毁的，都可以做为引用返回
如：在堆上开辟的空间，静态区，参数中的引用等

引用做返回值时，’ 可以对函数的返回值进行修改 '，在之后学习的运算符重载中作用很大

传引用明显的比传值效率高
参数传值时，形参是实参的临时拷贝，返回值传值时，使用的是临时变量
参数传引用时，形参是实参的别名，返回值传引用时，使用的是变量的别名

4. 引用的底层实现

实现上：引用是由指针实现的，也是需要开辟空间的，虽然实现上是这样，但是为了便于使用引用，还是以使用上的概念为主

int main()
{
	int a = 0;

	//实现上，将 a 的地址赋给指针 ra
	int& ra = a;

	//实现上，编译器默认将 ra 解释为(*ra)
	//因此，&ra 解释为 &(*ra) == &a 所以 &a 和 &ra 的地址一样
	ra = 10;

	int* pa = &a;
	*pa = 10;

	return 0;
}

//启动调式，右键进入反汇编
	int a = 0;
00007FF71DA317AD  mov         dword ptr [a],0  

//引用和指针的指令，在汇编层面一模一样
	int& ra = a;
00007FF71DA317B4  lea         rax,[a]  
00007FF71DA317B8  mov         qword ptr [ra],rax  
	ra = 10;
00007FF71DA317BC  mov         rax,qword ptr [ra]  
00007FF71DA317C0  mov         dword ptr [rax],0Ah  

	int* pa = &a;
00007FF71DA317C6  lea         rax,[a]  
00007FF71DA317CA  mov         qword ptr [pa],rax  
	*pa = 10;
00007FF71DA317CE  mov         rax,qword ptr [pa]  
00007FF71DA317D2  mov         dword ptr [rax],0Ah

引用类型必须和引用实体是同种类型的，不同类型无法直接赋值，但可以通过以下两种方式

在 C/C++ 中，显示/隐式类型转换是通过临时变量来完成的，临时变量具有常属性(不可以被修改)

#include <iostream>

using namespace std;

int main()
{	
	int a = 2;
	double& ra1 = (double&)a;
	const double& ra2 = a;

	//输出 2 -9.25596e+61 2
	cout << a << " " << ra1 << " " << ra2 << endl;

	return 0;
}

//启动调式，右键进入反汇编
	int a = 2;
00007FF7780D23CD  mov         dword ptr [a],2  
//mov 将 2 放到 a 中

	double& ra1 = (double&)a;
00007FF7780D23D4  lea         rax,[a]  
00007FF7780D23D8  mov         qword ptr [ra1],rax 
//lea 取出 a 的地址放到 rax
//mov 将 rax 中的内容放到指针 ra1 中

	const double& ra2 = a;
00007FF7780D23DC  cvtsi2sd    xmm0,dword ptr [a]  
00007FF7780D23E1  movsd       mmword ptr [rbp+68h],xmm0  
00007FF7780D23E6  lea         rax,[rbp+68h]  
00007FF7780D23EA  mov         qword ptr [ra2],rax  
//cvtsi2sd 取出 a 中低 64 位，将其转换为浮点数，放到 xmm0
//movsd 将 xmm0 放到临时变量 rdb+68h(h 表示十六进制) 空间中
//lea 取出 rdb+68h 空间的地址放到 rax
//mov 将 rax 中的内容放到指针 ra2 中

引用 ra1 是 a 的别名，因此 ra1 会以浮点数的方式看待 a 中的值(这里可以修改 ra1，存在问题，待以后解决)
引用 ra2 是赋值时隐式转换过程中 临时变量的别名，因此 ra2 是以浮点数的方式看待浮点类型的临时变量的值

引用比指针使用起来更安全

六、内联函数

在 C语言中，宏的缺点：1. 不能调试 2. 没有类型检查 3. 有些场景下非常复杂，容易出错，宏的优点：1. 速度快(不用创建函数栈帧) 2. 类型不固定

在 C++ 中，为了弥补宏的缺点，推荐 用 const 和 enum 代替 宏常量，用 内联函数 代替 宏函数

用 inline 修饰的函数称作内联函数(可以调试，有类型检查，书写和函数一样容易记忆)，编译时 C++ 编译器会 在调用内联函数的地方展开(速度快)，

为了可以在 debug 模式观察到内联函数的展开，需要对编译器进行设置(因为 debug 模式下，编译器默认不会对代码进行优化)
在 vs 2022 中
右击项目 -> 属性 -> C/C++ 下的常规 -> 调式信息格式 改为 程序数据库 (/Zi)
右击项目 -> 属性 -> C/C++ 下的优化 -> 内联函数扩展 改为 只适用于 __inline (/Ob1)

#include <iostream>

using namespace std;

//内联函数
inline void Swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}

int main()
{
	int a = 10, b = 20;
	Swap(a, b);

	cout << a << " " << endl;

	return 0;
}

//启动调式，右键进入反汇编
//汇编指令中，函数调用时需要通过 call 指令，跳转到函数地址
//Swap 调用时的汇编指令中没有 call，也就说明内联函数展开了
	Swap(a, b);
00007FF64AB41552  mov         eax,dword ptr [a]  
00007FF64AB41556  mov         dword ptr [rsp+60h],eax  
00007FF64AB4155A  mov         eax,dword ptr [b]  
00007FF64AB4155E  mov         dword ptr [a],eax  
00007FF64AB41562  mov         eax,dword ptr [rsp+60h]  
00007FF64AB41566  mov         dword ptr [b],eax  

内联函数特性：

• 函数用 inline 修饰，对编译器而言只是一个建议，在编译阶段是否会展开，取决于编译器，不加 inline 修饰的函数不会展开
  建议 将函数规模小，不是递归并且频繁调用的函数 用 inline 修饰，否则编译器会忽略 inline 特性
• 内联函数是一种以空间换时间的方法
  优点：少了函数调用开销，提升效
  缺点：可执行程序变大
• 内联函数如果声明和定义分离，会导致链接错误
  编译时会将 F.h 中的声明拷贝到 test.cpp 中，此时 test.cpp 中只有内联函数 f 的声明，没有内联函数 f 的定义，于是便无法将 f 函数展开(.cpp 文件是单独编译的)，并且由于内联函数会展开，所以内联函数 f 并不会在 test.cpp 的符号表中产生，也就导致在链接时合并符号表后无法找到函数 f
  
  书写内联函数时，在 .h 文件中 定义

七、auto 关键字(C++11)

在早期的 C/C++ 中 auto 用来表示变量具有自动存储器的局部变量(但是一直没有人使用 auto)

到了 C++11，标准委员会赋予了 auto 全新的含义，auto 不再是一个存储类型指示符，而是一个新的类型指示符(为了避免与 C++98 中的 auto 发生混淆，C++11 只保留了 auto 作为类型指示符的用法)

auto 声明的变量，由编译器在编译时期 根据初始化的值的类型 自动推到变量的类型

#include <iostream>

using namespace std;

int main()
{
	//auto 声明的变量必须初识化
	//auto a; --error

	//auto 自动推导变量类型
	auto c = 'a';
	auto i = 10;
	auto d = 3.14;

	//auto 声明指针时 auto 和 auto* 没有区别，但 auto* 一定要初识化为地址
	auto p1 = &i;
	auto* p2 = &i;

	//引用类型必须用 auto&
	auto& r = i;

	//typeid 是操作符，typeid(变量).name() 获取变量的类型
	//输出：char int double int * __ptr64 int * __ptr64 int
	cout << typeid(c).name() << " ";
	cout << typeid(i).name() << " ";
	cout << typeid(d).name() << " ";
	cout << typeid(p1).name() << " ";
	cout << typeid(p2).name() << " ";
	cout << typeid(r).name() << endl;
	
	return 0;
}

auto 不是一种 “类型” 的声明，而是一种类型声明时的 “占位符”，编译器在编译期会将 auto 替换为变量实际的类型，所以 auto 声明多个变量时，编译器只会对第一个变量的类型进行推导，然后将 auto 替换为推导的类型，因此每个变量的类型应该相同(不相同会编译错误)

auto 不能作为函数的参数，因为编译时无法知道实参的类型

auto 不能用来声明数组

在以后的学习中，某些类型较长，容易写错，此时便可以使用 auto 关键字自动推导，这种情况下也可以使用 typedef 来解决，不过 typedef 在某些情况存在一些问题

typedef char* pstr;

int main()
{
	//编译报错，const 修饰 p1，需要指定初始化
	//const pstr p1;

	//const 修饰 p2，编译通过
	const pstr* p2;

	return 0;
}

八、范围 for – 语法糖(C++11)

C++11 中引入了基于范围的 for 循环

范围 for 循环后的括号由冒号 : 分为两部分
第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

#include <iostream>

using namespace std;

int main()
{
	int array[] = { 1, 2, 3, 4, 5, 6 };

	//自动将数组 array 中的元素依次赋值给 i，自动判断结束
	//i 是循环变量，auto 是循环变量的类型
	for (auto i : array)
	{
		cout << i << " ";
	}
	cout << endl;

	return 0;
}

注意：和普通循环一样，可以使用 continue 和 break

九、nullptr(C++11)

在定义指针变量时，如果不知道指针的指向，通常会将指针变量指向 NULL

在 C++98 中，NULL实际是一个宏，在传统的 C 头文件 stddef.h 中

//在 C++ 中，NULL 被定义成 0
//在 C 语言中，NULL 被定义成 ((void *)0)
#ifndef NULL
    #ifdef __cplusplus
        #define NULL 0
    #else
        #define NULL ((void *)0)
    #endif
#endif

由于在 C++98 中 NULL 被定义为了 0，在使用 NULL 时，难免会遇到一些麻烦

#include <iostream>
#include <stddef.h>

using namespace std;

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

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

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

	return 0;
}

输出:
f(int)
f(int)

程序本意是想通过 f(NULL) 调用指针版本的 f(int*) 函数，但是由于 NULL 被定义成 0，因此与程序的初衷相悖

C++11 中，引入了新的关键字 nullptr，表示指针空值((void*)0)，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同

最后

以上就是重要冰淇淋为你收集整理的C++ 入门一、命名空间二、输入输出三、缺省参数四、函数重载五、引用六、内联函数七、auto 关键字(C++11)八、范围 for – 语法糖(C++11)九、nullptr(C++11)的全部内容，希望文章能够帮你解决C++ 入门一、命名空间二、输入输出三、缺省参数四、函数重载五、引用六、内联函数七、auto 关键字(C++11)八、范围 for – 语法糖(C++11)九、nullptr(C++11)所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。