C++学习笔记：

C++ 进阶之路__Zwy@的博客-CSDN博客

各位于晏，亦菲们，请点赞关注！

我的个人主页：

_Zwy@-CSDN博客

目录

1、从C语言到C++的进化

1.1、历史渊源

1.2、语法层面的区别和联系

1.2.1、数据类型

1.2.2、函数定义与重载

1.2.3、变量声明与定义

1.2.4、面向对象特性

1.3、内存管理

1.4、编程范式

1.5、应用领域

2、C++的发展历史

2.1、前期探索与诞生（1979 年 - 1985 年）

2.2、标准化阶段（1991 年 - 1998 年）

2.3、现代 C++ 发展阶段（2003 年至今）

2.4、C++的参考文档

3、第一个C++程序

4、命名空间（重点）

4.1、命名空间的价值

4.2、namespace关键字

4.3、命名空间成员的访问

4.3.1、使用作用域解析运算符（::）

4.3.2、使用using声明

4.3.3、使用using namespace指令

4.4、嵌套命名空间

4.5、匿名命名空间

4.6、标准库命名空间std

5、C++输入输出（了解）

5.1、iostream 库概述

5.2、标准输出cout

5.3、标准出入cin

6、缺省参数（重点）

6.1、全缺省参数

6.2、半缺省参数

6.3、默认参数的顺序

6.4、声明和定义的一致性

7、函数重载（重点）

7.1、参数类型不同导致的重载 

7.2、参数个数不同导致的重载

7.3、参数顺序不同导致的重载

7.4、函数重载的注意事项

7.4.1、返回值类型不能作为重载依据

7.4.2、重载函数的调用可能存在二义性 

7.4.3、重载函数与默认参数的结合使用

8、引用（重点）

8.1、基本概念

8.2、引用的特性

8.2.1、必须初始化

8.2.2、一旦初始化就不能改变引用对象

8.2.3、⼀个变量可以有多个引用

8.3、引用的使用

8.3.1、引用作为函数参数

8.3.2、保证函数可以修改外部变量

8.3.3、引用作为函数返回值

8.4、const引用

8.4.1、定义

8.4.2、作为函数参数的const引用

8.4.3、const引用和临时对象

8.4.4、const引用作为函数返回值

8.5、引用和指针的关系

8.5.1、概念上的关联

8.5.2、初始化要求

8.5.3、操作符的使用

8.5.4、sizeof中含义不同

9、inline（了解）

9.1、inline函数的特点

9.1.1、代码膨胀与效率权衡

9.1.2、编译阶段的处理

9.1.3、作用域和链接特性

10、nullptr（重点）

10.1、NULL和nullptr

10.2、与NULL比较

10.3、语义清晰性

10.4、与0比较（指针上下文）

C++知识总结

tips：

本文目录中标记重点的知识，需要重点理解，尽量做到融会贯通，举一反三

标记了解的知识，现阶段只需要简单了解即可！

1、从C语言到C++的进化

1.1、历史渊源

C 语言诞生于 20 世纪 70 年代，是一种面向过程的编程语言。它以简洁高效的语法、对底层硬件的直接操控能力，迅速在系统编程、操作系统开发等领域占据了重要地位。C 语言的设计理念注重代码的执行效率和资源利用，其标准库提供了丰富的基础函数，能够完成诸如文件操作、内存管理等基本任务。

随着软件规模的不断扩大和编程需求的日益复杂，C++ 应运而生。C++ 在 C 语言的基础上进行了扩展，它保留了 C 语言的核心特性，同时引入了面向对象编程（OOP）的概念。20 世纪 80 年代初开始发展的 C++，逐渐融合了封装、继承和多态等面向对象特性，使得程序的设计更加模块化、可扩展和易于维护。这一发展使得 C++ 不仅适用于系统级编程，还广泛应用于游戏开发、图形图像处理、大型软件项目等众多领域。

1.2、语法层面的区别和联系

1.2.1、数据类型

在数据类型方面，C 语言和 C++ 有很多相似之处。它们都拥有基本数据类型，如整型（int）、浮点型（float、double）、字符型（char）等。然而，C++ 在 C 的基础上进行了一些扩展。例如，C++ 增加了布尔类型（bool），使得逻辑判断更加直观清晰。此外，C++ 还引入了引用类型（&），这是 C 语言所没有的。引用在函数参数传递和函数返回值等方面提供了一种更方便、更安全的方式，避免了指针操作可能带来的一些风险。

1.2.2、函数定义与重载

C 语言中的函数定义相对较为简单，函数名在一个作用域内必须唯一。而 C++ 支持函数重载，即允许在同一作用域内定义多个同名函数，只要它们的参数列表不同（参数个数、参数类型或参数顺序）。这一特性大大提高了代码的灵活性和可读性，使得程序员可以根据不同的参数需求定义同名函数来执行相似的操作。

1.2.3、变量声明与定义

C 语言中，变量的声明和定义通常是分开进行的，并且在代码块开头集中声明变量是一种常见的编程风格。而 C++ 则更加灵活，变量可以在需要使用的地方进行声明和定义，这使得代码的逻辑结构更加清晰，变量的作用域更加明确。

1.2.4、面向对象特性

这是 C++ 相对于 C 语言最为显著的扩展。C++ 的类（class）是面向对象编程的核心。通过类，可以将数据和操作数据的函数封装在一起，实现数据的隐藏和保护。

1.3、内存管理

在内存管理方面，C 语言和 C++ 都提供了直接操控内存的能力，如使用malloc和free函数在 C 语言中进行动态内存分配和释放，在 C++ 中则可以使用new和delete运算符。然而，C++ 在内存管理上引入了更多的安全性和便利性。例如，C++ 的构造函数和析构函数可以在对象创建和销毁时自动执行一些内存初始化和清理工作，减少了因手动管理内存而可能出现的错误。同时，C++ 11 引入的智能指针（如shared_ptr和unique_ptr）进一步增强了内存管理的安全性，能够自动处理对象的生命周期，避免了内存泄漏和悬空指针等问题，这是 C 语言所不具备的高级内存管理机制。

1.4、编程范式

C 语言主要遵循面向过程编程范式，程序的设计围绕着函数和数据结构展开，强调算法的实现和数据的处理流程。例如，一个简单的 C 语言程序可能是一系列函数的顺序调用，通过函数之间的数据传递来完成特定任务。

而 C++ 支持多种编程范式，除了面向对象编程外，还可以进行面向过程编程（兼容 C 语言风格）以及泛型编程。泛型编程通过模板（template）实现，允许编写与类型无关的代码，提高代码的复用性。例如，C++ 标准模板库（STL）中的容器（如vector、list等）和算法（如sort、find等）就是泛型编程的典型应用，它们可以处理不同类型的数据，大大提高了编程效率。

1.5、应用领域

由于其特性的不同，C 语言和 C++ 在应用领域上也有所侧重。C 语言凭借其高效性和对底层的操控能力，仍然广泛应用于操作系统开发（如 Linux 内核）、嵌入式系统开发（如单片机编程）、驱动程序开发等对性能和资源控制要求极高的领域。

C++ 则在游戏开发领域占据重要地位，许多大型游戏引擎（如 Unreal Engine）都是基于 C++ 开发的。同时，C++ 在图形图像处理（如 OpenCV 库）、数据库管理系统开发、金融领域的高性能计算等方面也有着广泛的应用，其面向对象特性和丰富的库支持使得开发大型复杂软件项目更加高效和便捷。

1.6、总结

2、C++的发展历史

2.1、前期探索与诞生（1979 年 - 1985 年）

1979 年，Bjarne Stroustrup 在贝尔实验室开始基于 C 语言进行扩展，尝试开发一种新语言，当时他在分析 UNIX 内核时，面临着如何将内核模块化等问题，于是在 C 语言基础上增加了类似 Simula 的类机制，完成了一个可运行的预处理程序 Cpre，这便是 C++ 的前身 “C with Classes” 
1983 年 8 月，第一个 C++ 实现投入使用，同年 12 月，Rick Mascitti 建议将其命名为 CPlusPlus，即 C++。
1985 年，Bjarne Stroustrup 正式发布了 C++ 语言的第一个版本，这个版本已经具备了类、继承、多态、虚函数等面向对象的特性，并且支持运算符重载、函数模板等高级特性。

2.2、标准化阶段（1991 年 - 1998 年）

1991 年，C++ 语言被 ANSI 和 ISO 标准化组织正式接受，并发布了 C++ 语言的第一个标准，该标准包含了类、继承、多态、虚函数、运算符重载、函数模板等面向对象特性，还涵盖了异常处理、命名空间、RTTI（运行时类型识别）等新特性。
1998 年，C++ 语言发布了第二个标准，其中包括了 STL（标准模板库）、智能指针等新特性，这使得 C++ 语言更加强大和灵活，进一步提升了其在软件开发中的应用价值。

2.3、现代 C++ 发展阶段（2003 年至今）

2003 年，C++ 语言发布了第三个标准，即现代 C++，此标准纳入了 TR1（技术报告 1）中的新特性，如正则表达式、智能指针、元编程等，让 C++ 在面对复杂的软件系统开发时更具优势。
2011 年，C++ 语言发布了第四个标准，引入了 lambda 表达式、右值引用等新特性，使 C++ 语言更加现代化和高效，增强了其在高性能计算和大型软件架构设计中的竞争力。
2014 年，C++ 语言发布了第五个标准，增加了多线程支持、类型推导等新特性，这使得 C++ 语言在并行计算和大数据处理领域能够更好地发挥其性能优势，满足了现代计算机系统对高效处理多任务和大量数据的需求 。
2020 年，C++20 标准发布，引入了模块 (modules)、协程 (coroutines)、范围 (ranges)、概念 (constraints) 等重大特性，还有对已有特性的更新，如 lambda 支持模板、范围 for 支持初始化等 。
2024 年 10 月，ISO 发布了最新的 C++23 标准，其包含了新的特性并且扩充了标准库，进一步推动了 C++ 语言的发展.

2.4、C++的参考文档

非官方文档：

只更新到C++11，内容以头文件形式展开，通俗易懂，对新手较为友好

cplusplus.com/reference/

C++官方中文文档：

包含C++目前的所有内容，但是不容易看懂，适合有一定基础的学者使用

C++ 参考手册 - cppreference.com

C++官方英文文档：

cppreference.com

3、第一个C++程序

C++兼容C语言

int main()
{
    printf("Hello World!\n");
    return 0;
}

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

还是以我们熟知的"Hello world!"为例，来编写我们的第一个C++程序

#include<iostream>
int main()
{
    std::cout << "Hello World!" << std::endl;
    return 0;
}

其中std表示C++标准库的命名空间，cout代表输出流，endl表示换行，<iostream>是函数所需要的头文件， 看不懂没关系，后面我们会依次详细讲解！

程序输出结果： 

4、命名空间（重点）

#include<iostream>
int rand = 100;
int main()
{
	std::cout << rand << std::endl;//编译出错 rand重定义，以前的定义是函数
}

namespace namespace_name
{
    // 变量、函数、类等的定义
}

//例如
namespace _Zwy
{
    int a = 10;
    int b = 20;
    int add(int x,int y)
    {
        return x + y;
    }
}

#include<iostream>
int main()
{
    int ret1 = _Zwy::add(10, 20);
    int ret2 = _Zwy::add(100, 200);
    std::cout << ret1 << std::endl;
    std::cout << ret2 << std::endl;
    return 0;
}

#include<iostream>
using _Zwy::add;
using std::cout;
using std::endl;
int main()
{
    int ret1 = add(10, 20);
    int ret2 = add(100, 200);
    cout << ret1 << endl;
    cout << ret2 << endl;
    return 0;
}

using namespace _Zwy;
using namespace std;
int main()
{
    cout << a << endl;
    cout << b << endl;
    cout << add(a, b) << endl;
    return 0;
}

namespace outer 
{
    namespace inner
    {
        void nested_function()
        {
            std::cout << "This is a nested function." << std::endl;
        }
    }
}

int main()
{
    outer::inner::nested_function();
    return 0;
}

#include<iostream>
namespace
{
    int local_variable = 10;
    void local_function() 
    {
        std::cout << "This is a local function." << std::endl;
    }
}
int main()
{
    local_function();
    return 0;
}

#include<iostream>
int mian()
{
    std::cout << "作用域解析运算符" << std::endl;
    return 0;
}

#include<iostream>
using std ::cout;
using std ::endl;
int main()
{
    cout << "using 声明" << endl;
    return 0;
}

使用using namespace std;（不推荐） 日常练习时使用即可

#include<iostream>
using namespace std;
int main()
{
    cout << "using namespace std;" << endl;
    return 0;
}

5、C++输入输出（了解）

5.1、iostream 库概述

在 C++ 中，输入输出操作主要依赖<iostream>库。<iostream> 是 Input Output Stream 的缩写这个库提供了用于处理标准输入（cin）、标准输出（cout）、标准错误输出（cerr）和无缓冲标准错误输出（clog）的对象和相关操作。
<iostream>库是基于流（stream）的概念进行设计的。流是字节序列的抽象，输入流用于从某个源读取字节序列，输出流用于将字节序列写入某个目标

5.2、标准输出cout

基本用法：

#include <iostream>
int main()
{
    const char* message = "Hello World!";
    int num = 100;
    std::cout << message  << num<< std::endl;
    return 0;
}

输出：

在这里，<<是输出运算符，它将右侧的数据发送到cout流中。endl是一个操纵符，它的作用是输出一个换行符并刷新输出缓冲区

格式化输出：

使用setw操纵符设置输出宽度：setw来自<iomanip>头文件，用于设置下一个输出项的宽度。

例如：

#include <iostream>
#include <iomanip>
int main()
{
    int num1 = 10;
    int num2 = 100;
    std::cout << std::setw(5) << num1 << std::endl;
    std::cout << std::setw(5) << num2 << std::endl;
    return 0;
}

输出：

setw(5)会使得输出的整数占 5 个字符的宽度，如果整数本身宽度小于 5，则在前面填充空格。

控制浮点数的精度：

可以使用fixed和setprecision操纵符来控制浮点数的输出精度。fixed来自<iostream>，setprecision来自<iomanip>。例如：

#include <iostream>
#include <iomanip>
int main() 
{
    double d = 3.1415926;
    std::cout << std::fixed << std::setprecision(2);
    std::cout << d << std::endl;
    return 0;
}

输出：

这里fixed表示以固定小数点数形式输出，setprecision(2)表示小数部分保留两位精度，所以输出结果为3.14 

5.3、标准出入cin

可以使用cin来读取用户输入的数据。例如，读取一个整数和一个字符串：

#include <iostream>
int main() 
{
    int age;
   std::string name;
    std::cout << "Please enter your name: ";
    //输入姓名
    std::cin >> name;
    std::cout << "Please enter your age: ";
    //输入年龄
    std::cin >> age;
    std::cout << "Your name is " << name << " and your age is " << age << std::endl;
    return 0;
}

输出： 

在这里，>>是输入运算符，它从cin流中读取数据并存储到相应的变量中。 

输入中的问题及处理：

缓冲区问题：

cin在读取数据时是基于缓冲区的。当用户输入的数据多于程序期望读取的数据时，多余的数据会留在缓冲区中。例如，在读取一个整数后接着读取一个字符串，如果用户在输入整数后输入了一个空格和其他字符，那么在读取字符串时，可能会读取到意外的数据。解决这个问题的一种方法是使用cin.ignore()函数来清除缓冲区中的多余字符。例如：

#include<string>
#include <iostream>
int main() 
{
    int num;
    std::string text;
    std::cin >> num;
    std::cin.ignore();  // 忽略缓冲区中的一个字符（通常是换行符）
    std::cout << "Please enter a string: ";
    std::getline(std::cin, text);
    std::cout << "The number is " << num << " and the string is " << text << std::endl;
    return 0;
}

类型不匹配问题：

如果用户输入的数据类型与程序期望读取的数据类型不匹配，cin会进入错误状态。例如，程序期望读取一个整数，但用户输入了一个字母。可以通过检查cin的状态来处理这种情况。例如： 

#include <iostream>
int main()
{
    int number;
    std::cout << "Please enter an integer: ";
    std::cin >> number;
    if (std::cin.fail())
    {
        std::cout << "Invalid input. Please enter a valid integer." << std::endl;
        std::cin.clear();  // 清除错误状态
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');  // 忽略缓冲区中的所有字符直到换行符
    }
    else 
    {
        std::cout << "You entered " << number << std::endl;
    }
    return 0;
}

以上关于cin和cout的讲解，大家可能都不太懂，现阶段只需要掌握如何使用cin和cout进行输入输出即可，后面我们会有专门的章节讲解IO流库，会对C++的IO流做更深入的讲解 

6、缺省参数（重点）

缺省参数（也称为默认参数）是 C++ 中的一个特性，它允许在函数声明或定义时为参数指定默认值。这样，在调用函数时，如果没有为这些参数提供实际的值，编译器就会自动使用默认值。缺省参数分为全缺省和半缺省参数。（有些地方把缺省参数也叫默认参数）

6.1、全缺省参数

全缺省就是全部形参给缺省值

#include <iostream>
void Test(std::string s = "helloworld!", int num = 3)
{
	for (size_t i = 0; i < num; ++i)
	{
		std::cout << s <<std:: endl;
	}
}
int main()
{
	Test();
	return 0;
}

输出：

也可以调用函数时传递参数，覆盖其中一个缺省参数

#include <iostream>
void Test(std::string s = "helloworld!", int num = 3)
{
	for (size_t i = 0; i < num; ++i)
	{
		std::cout << s <<std:: endl;
	}
}
int main()
{
	Test("hello_Zwy!");
	return 0;
}

输出： 

同样可以将两个缺省值全覆盖

#include <iostream>
void Test(std::string s = "helloworld!", int num = 3)
{
	for (size_t i = 0; i < num; ++i)
	{
		std::cout << s <<std:: endl;
	}
}
int main()
{
	Test("hello_Zwy!",5);
	return 0;
}

输出： 

6.2、半缺省参数

#include <iostream>
void Test(std::string s , int num = 3, char ch='a')
{
	for (size_t i = 0; i < num; ++i)
	{
		std::cout << s <<ch<<std:: endl;
	}
}
int main()
{
	Test("helloworld!");
	return 0;
}

#include <iostream>
void Test(std::string s , int num = 3, char ch='a')
{
	for (size_t i = 0; i < num; ++i)
	{
		std::cout << s <<ch<<std:: endl;
	}
}
int main()
{
	Test("helloC++!!!",2,'C');
	return 0;
}

6.3、默认参数的顺序

C++规定，当函数有多个参数时，缺省参数必须从右往左依次定义。

例如，下面的函数声明是正确的

void Test(int a, int b = 2, int c = 3);

 但是，下面的声明是错误的

void Test(int a = 1, int b, int c = 3);

 因为我们说，缺省参数必须从右往左依次定义，不能跳跃！

6.4、声明和定义的一致性

如果函数的声明和定义分开，那么缺省参数只能在函数声明中指定一次。通常是在头文件中的函数声明处指定缺省参数

头文件（Test.h）

#ifndef TEST_H
#define TEST_H
void myTest(int a, int b = 2);
#endif

源文件（Test.cpp）

#include "Test.h"
void myTest(int a, int b) 
{
	// 函数体
}

如果在源文件中的函数定义处也指定了不同的默认参数，编译器可能会发出警告或者错误，因为这会导致不一致性

7、函数重载（重点）

函数重载是 C++ 中的一个特性，它允许在同一作用域内定义多个同名函数，只要这些函数的参数列表（参数个数、参数类型或参数顺序）不同即可。编译器会根据函数调用时提供的实际参数来确定调用哪个具体的重载函数。C语言是不支持同⼀作用域中出现同名函数的。

例如，定义两add函数来完成不同类型的加法操作

int add(int a, int b) 
{
    return a + b;
}
double add(double a, double b)
{
    return a + b;
}

7.1、参数类型不同导致的重载 

这是最常见的函数重载情况。如上述add函数的例子，一个用于整数相加，一个用于双精度浮点数相加。当在程序中调用add函数时，编译器会根据传入的参数类型来决定调用哪个版本。
例如：

int main()
{
    int ret1 = add(3, 5);
    double ret2 = add(3.14, 2.71);
    return 0;
}

在add(3, 5)调用中，编译器看到参数是两个整数，所以会调用int add(int a, int b)这个版本；而在add(3.14, 2.71)调用中，由于参数是两个双精度浮点数，编译器会调用double add(double a, double b)版本 

7.2、参数个数不同导致的重载

函数也可以根据参数个数的不同进行重载。例如，定义一个函数用于打印一个整数，另一个函数用于打印两个整数：

void print(int num) 
{
    std::cout << "The number is: " << num << std::endl;
}
void print(int num1, int num2)
{
    std::cout << "The two numbers are: " << num1 << " and " << num2 << std::endl;
}
int main() 
{
    print(5);
    print(3, 7);
    return 0;
}

编译器会根据传递的参数个数来选择合适的print函数。print(5)会调用void print(int num)，而print(3, 7)会调用void print(int num1, int num2) 

7.3、参数顺序不同导致的重载

即使参数个数和类型的组合总数相同，但顺序不同也可以构成函数重载。

例如：

void Test(int a, double b)
{
    std::cout << "int and double: " << a << ", " << b << std::endl;
}
void Test(double a, int b) {
    std::cout << "double and int: " << a << ", " << b << std::endl;
}
int main() 
{
    Test(3, 4.5);
    Test(3.14, 7);
    return 0;
}

对于Test(3, 4.5)，编译器会调用void Test(int a, double b)，因为参数顺序是先整数后双精度浮点数；而Test(3.14, 7)会调用voidTest(double a, int b)，因为参数顺序是先双精度浮点数后整数 

7.4、函数重载的注意事项

7.4.1、返回值类型不能作为重载依据

返回值类型不能作为重载依据在 C++ 中，仅返回值类型不同的函数不能构成重载

例如：下面的代码是错误的，编译不能依靠返回值类型来判断为函数重载

int add(int a, int b) 
{
    return a + b;
}
double add(int a, int b)
{
    return (double)(a + b);
}

7.4.2、重载函数的调用可能存在二义性 

 如果存在多个重载函数，其参数匹配情况不明确时，编译器会报二义性错误。例如

void Test(int a, double b) 
{
    //...
}
void Test(double a, int b) 
{
    //...
}
int main() {
   Test(3.0, 4.0);//编译出错，函数调用有二义性
    return 0;
}

在func(3.0, 4.0)这个调用中，两个参数都是双精度浮点数，编译器无法确定是将第一个参数当作整数、第二个参数当作双精度浮点数来匹配void func(int a, double b)，还是将第一个参数当作双精度浮点数，第二个参数当作整数来匹配void func(double a, int b)，所以会产生二义性错误 

7.4.3、重载函数与默认参数的结合使用

当函数有默认参数时，可能会影响函数重载的调用。例如：

void print(int a, int b = 0) 
{
    std::cout << "Function with default parameter: " << a << ", " << b << std::endl;
}
void print(int a) 
{
    std::cout << "Function without default parameter: " << a << std::endl;
}
int main()
{
    print(3);
    return 0;
}

这段代码会导致编译错误，因为在调用print（3）时，编译器不知道匹配哪个重载函数，因为第一个函数有缺省值，可以匹配，第二个函数也同样符合传参规则可以匹配！ 编译器不知道该调用哪个函数

8、引用（重点）

8.1、基本概念

在 C++ 中，引用（Reference）是一种给变量起别名的机制。引用不是新定义⼀个变量，而是给已存在变量取了⼀个别名，引用就像是一个变量的另一个名字，它和被引用的变量共享同一块内存空间。比如水浒传中的林冲，外号豹子头，实际上林冲和豹子头都是同一个人

基本语法：

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

int main()
{
    int num = 10;
    int& ref = num;
    return 0;
}

这里ref是num的引用，对ref的任何操作，实际上就是对num的操作。比如，ref = 20;会将num的值修改为20。 

8.2、引用的特性

8.2.1、必须初始化

int main()
{
    int& uninitialized_ref;//编译错误
    return 0;
}

int main()
{
    int num1 = 10;
    int num2 = 20;
    int& ref = num1;
    ref = num2;  // 这里不是让ref引用num2，而是将num2的值赋给ref所引用的num1
    return 0;
}

int main()
{
    int num = 10;
    int& ref1 = num;
    int& ref2 = num;
    int& ref3 = num;
    return 0;
}

struct Person 
{
    std::string name;//姓名
    std::string gender;//性别
    int age;//年龄
    std::string id;//身份证号码
};

void modifyAgeValue(Person p, int new_age)
{
    p.age = new_age;
}

void modifyAgeReference(Person& p, int new_age) 
{
    p.age = new_age;
}

void swap(int& a, int& b)
{
    int temp = a;
    a = b;
    b = temp;
}

int& getValue(int* arr, int index) 
{
    return arr[index];
}

int& Test() 
{
    int local_num = 10;
    return local_num;  // 错误，返回了局部变量的引用
}

const int num = 10; 
const int& ref = num;

struct Person 
{
    std::string name;//姓名
    std::string gender;//性别
    int age;//年龄
    std::string id;//身份证号码
};

void printPerson(const Person& p)
{
    std::cout << "Name: " << p.name <<" "<<"gender :"<<p.gender<<" " << " Age : " << p.age <<
      "  "<<"id:"<<p.id<< std::endl;
}
int main()
{
    struct Person p = { "_Zwy","男",18,"11223344" };
    printPerson(p);
    return 0;
}

int add(int a, int b) 
{
    return a + b;
}
int main()
{
    const int& result_ref = add(3, 5);
    return 0;
}

const std::string& getTempString() 
{
    std::string str = "HelloWorld!";
    return str;
}
int main() 
{
    const std::string& str_ref = getTempString();
    std::cout << str_ref << std::endl;
    return 0;
}

class Matrix 
{
public:
   const int&  getElement(int row, int col) const
    {
        // 返回矩阵中指定行和列的元素
        return elements[row * cols + col];
    }
private:
    int* elements;
    int rows;
    int cols;
};

int main()
{
    int a = 100; double b= 3.14;
    int* p1 = &a;  double* p2 = &b;
    int& ref1 = a; double& ref2 = b;
    //int类型
    cout <<"int引用大小："<< sizeof(ref1) << endl;
    cout <<"指针大小"<< sizeof(p1) << endl;
    //double类型
    cout << "double引用大小"<<sizeof(ref2) << endl;
    cout << "指针大小："<<sizeof(p2) << endl;
    return 0;
}

inline int add(int a, int b) 
{
    return a + b;
}

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

void Test(int* p) 
{
    cout << "void func(int* p) " << endl;
}
void Test(int i)
{
    cout << "void func(int i) " << endl;
}

int main() 
{
    Test(NULL);  // 可能会调用func(int i)，这可能不是期望的结果
    Test(nullptr);  // 一定会调用func(int* p)，符合预期
    return 0;
}

void Test(int* p) 
{
    cout << "void func(int* p) " << endl;
}
void Test(int i)
{
    cout << "void func(int i) " << endl;
}

int main() 
{
    int* p = 0;
    Test(p);  // 0可以转换成空指针
    Test(nullptr);  // 一定会调用func(int* p)，符合预期
    return 0;
}