• 【C++初阶】C++入门

    目录

    1. C++关键字(C++98)

    2. 命名空间

    2.1 命名空间定义

    2.2 命名空间的使用

    3. C++输入&输出

    4. 缺省参数

    4.1 缺省参数概念

    4.2 缺省参数分类

    5. 函数重载

    5.1 函数重载概念

    面试题1. C语言为什么不支持重载？C++支持？C++底层是如何支持重载的？

    面试题2. extern "C"的作用是什么？

    5.2 名字修饰(name Mangling)

    6. 引用

    6.1 引用概念

    6.2 引用特性

    6.3 常引用

    6.4 使用场景

    6.5 传值、传引用效率比较

    6.5.1 值和引用的作为传参的性能比较

    6.5.2 值和引用的作为返回值类型的性能比较

    6.6 引用和指针的区别

    7. 内联函数

    7.1 概念

    7.1.1 面试题：宏的优缺点 

    7.2 特性

    8. auto关键字(C++11)

    8.1 auto的使用细则

    8.2 auto不能推导的场景

    9. 基于范围的for循环(C++11)

    9.1 范围for的语法

    9.2 范围for的使用条件

    10. 指针空值nullptr(C++11)

    1. C++关键字(C++98)

    C++总计63个关键字，C语言32个关键字

    2. 命名空间

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

    2.1 命名空间定义

    C语言中命名冲突问题：

    1. //namespace 定义的是一个域
    2. //用于解决C语言命名冲突问题
    3.  
    4. //eg:命名冲突
    5. //C语言的库中，有两个函数用scanf和strlen名称
    6. //假设代码里，想用这两个名称命名变量，就会产生冲突
    7. int main()
    8. {
    9. 	//定义到局部不会报错，但用的时候会报错(定义到全局不用也会报错)
    10. 	int scanf = 10;
    11. 	int strlen = 20;
    12.  
    13. 	//以下均会报错,且C语言解决不了冲突的问题
    14. 	scanf("%d", &scanf);
    15. 	printf("%d\n", scanf);
    16. 	printf("%d\n", strlen);
    17.  
    18.     return 0;
    19. }

    定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。

    1. //使用C++命名空间，进行名字的隔离
    2. //1. 普通的命名空间
    3. namespace N1 // N1为命名空间的名称
    4. {
    5. 	//命名空间中的内容，既可以定义变量，也可以定义函数
    6. 	int scanf = 10;
    7. 	int strlen = 20;
    8.  
    9. 	int Add(int left, int right)
    10. 	{
    11. 		return left + right;
    12. 	}
    13. }
    14.  
    15. //2. 命名空间可以嵌套
    16. namespace N2
    17. {
    18. 	int a;
    19. 	int b;
    20. 	int Add(int left, int right)
    21. 	{
    22. 		return left + right;
    23. 	}
    24.  
    25. 	namespace N3
    26. 	{
    27. 		int c;
    28. 		int d;
    29. 		int Sub(int left, int right)
    30. 		{
    31. 			return left - right;
    32. 		}
    33. 	}
    34. }
    35.  
    36. //3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
    37. //注意：同一个域里不能定义同名的变量或函数
    38. namespace N1
    39. {
    40. 	int Mul(int left, int right)
    41. 	{
    42. 		return left * right;
    43. 	}
    44. }
    45.  
    46.  
    47.  
    48. int main()
    49. {
    50. 	//默认访问局部其次是全局
    51. 	//由于局部没有，访问全局的头文件,所以此时打印的是库函数的地址
    52. 	printf("%x\n", scanf);   //411433
    53. 	printf("%x\n", strlen);  //4113d4
    54.  
    55. 	//指定访问N1命名空间
    56. 	printf("%x\n", N1::scanf);   //a
    57. 	printf("%x\n", N1::strlen);  //14
    58. 	
    59. 	//指定命名空间后，才能调用N1里的函数
    60. 	int a = N1::Add(1, 2);
    61. 	printf("%d\n", a); //3
    62.  
    63. 	//访问嵌套命名空间的内容
    64. 	int b = N2::N3::Sub(5, 3);
    65. 	printf("%d\n", b); //2
    66.  
    67. 	return 0;
    68. }

    注：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中

    2.2 命名空间的使用

    C++库为了防止命名冲突，把自己库里的东西都定义在std的命名空间中，要使用标准库中的东西，有三种方式

    ① 加命名空间名称及作用域限定符

    指定命名空间，缺陷: 麻烦，每个地方要用都要制定，但是这是最规范的使用方式

    ② 使用using namespace 命名空间名称引入

    把std整个展开:using namespace std ,相当于库里的东西都到全局域了 ，缺陷: 如果自己定义的和库的冲突了就无法解决了，所以规范的工程项目中是不推荐这种方式的，日常练习无所谓

    ③ 使用using将命名空间中成员引入

    对部分常用的库里面的东西展开，是针对1和2折中的方案，在项目中经常使用

    1. //C++库为了防止命名冲突，把自己库里的东西都定义在了一个std的命名空间中
    2. //要使用标准库中的东西，有三种方式
    3. //1. 指定命名空间 
    4. //   -> 缺陷: 麻烦，每个地方要用都要制定，但是这是最规范的使用方式
    5. //2. 把std整个展开:using namespace std ,相当于库里的东西都到全局域了 
    6. //   ->缺陷: 如果自己定义的和库冲突了就无法解决了
    7. //   所以规范的工程项目中是不推荐这种方式的，日常练习无所谓
    8. //3. 对部分常用的库里面的东西展开，是针对1和2折中的方案，在项目中经常使用
    9.  using std::cout;
    10.  using std::endl;
    11.  
    12. //using namespace std;
    13.  
    14. int main()
    15. {
    16. 	//1. 指定命名空间
    17. 	std::cout << "hello world" << std::endl;
    18.  
    19. 	// 2.把std整个展开,上面写了using namespace std;下面直接用即可
    20. 	cout << "hello world" << endl;
    21.  
    22. 	// 3.对部分常用的库里面的东西展开
    23. 	cout << "hello world" << endl;
    24. 	std::string s; //没展开的就不能直接使用
    25.  
    26. 	return 0;
    27. }

    3. C++输入&输出

    1. #include<iostream>
    2.  
    3. //cout 是ostream类型全局对象
    4. //cin  是istream类型全局对象
    5. //endl 是全局的换行符号
    6. int main()
    7. {
    8. 	std::cout << "hello world!" << std::endl;
    9.  
    10. 	//对比C语言printf和scanf区别是：
    11. 	//可以自动识别类型
    12. 	int a = 10;
    13. 	int* p = &a;
    14. 	//c语言打印
    15. 	printf("%d,%p\n", a, p);
    16. 	//c++打印
    17. 	std::cout << a << "," << p << std::endl;
    18.  
    19. 	return 0;
    20. }

    说明：

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

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

    2. 使用C++输入输出更方便，不需增加数据格式控制，比如：整形--%d，字符--%c

    4. 缺省参数

    4.1 缺省参数概念

    缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参。缺省参数可以使调用更灵活。

    1. //缺省参数
    2. void TestFunc(int a = 0)
    3. {
    4. 	cout << a << endl;
    5. }
    6.  
    7. int main()
    8. {
    9. 	TestFunc();   // 0,没有传参时，使用参数的默认值
    10. 	TestFunc(10); // 10,传参时，使用指定的实参
    11.  
    12.     return 0;
    13. }

    4.2 缺省参数分类

    ① 全缺省参数

    1. //全缺省
    2. void TestFunc(int a = 10, int b = 20, int c = 30)
    3. {
    4. 	cout << "a = " << a << endl;
    5. 	cout << "b = " << b << endl;
    6. 	cout << "c = " << c << endl;
    7. }

    ② 半缺省参数

    1. //半缺省
    2. void TestFunc(int a, int b = 10, int c = 20)
    3. {
    4. 	cout << "a = " << a << endl;
    5. 	cout << "b = " << b << endl;
    6. 	cout << "c = " << c << endl;
    7. }

    注意：

    1. 半缺省参数必须从右往左依次来给出，并且连续，不能间隔着给

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

    3. 缺省值必须是常量或者全局变量

    4. C语言不支持（编译器不支持）

    5. 函数重载

    5.1 函数重载概念

    函数重载 : 是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须不同，常用来处理实现功能类似数据类型不同的问题

    1. //C语言不允许定义同名函数
    2. //C++可以 -> 函数重载 -> 参数(类型或个数或顺序)不同
    3. int Add(int left, int right)
    4. {
    5. 	return left + right;
    6. }
    7.  
    8. double Add(double left, double right)
    9. {
    10. 	return left + right;
    11. }
    12.  
    13. int main()
    14. {
    15. 	cout << Add(1, 2) << endl;     //3
    16. 	cout << Add(1.1, 2.2) << endl; //3.3
    17.  
    18. 	return 0;
    19. }

    下面两个函数属于函数重载吗？

    1. short Add(short left, short right)
    2. {
    3. 	return left + right;
    4. }
    5. int Add(int left, short right)
    6. {
    7. 	return left + right;
    8. }

    答：不算，判断时，不看返回类型，只看函数名是否相同，参数个数或类型是否不同

    面试题1. C语言为什么不支持重载？C++支持？C++底层是如何支持重载的？

    答：通过函数名修饰规则搞定，待补充

    面试题2. extern "C"的作用是什么？

    答：待补充

    5.2 名字修饰(name Mangling)

    6. 引用

    6.1 引用概念

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

    1. int main()
    2. {
    3. 	int a = 10;
    4.  
    5. 	//b是a的引用(别名)
    6. 	//注意区分引用和取地址，引用是类型后&变量，取地址是直接&变量
    7. 	int& b = a;
    8. 	b = 20;
    9.  
    10. 	//继续取别名
    11. 	int& c = b;
    12. 	c = 30;
    13.  
    14. 	return 0;
    15. }

    注意：引用类型必须和引用实体是同种类型的

    1. //引用的价值
    2. //用别名就可以不用传地址进行交换
    3. void swap(int& r1, int& r2)
    4. {
    5. 	int tmp = r1;
    6. 	r1 = r2;
    7. 	r2 = tmp;
    8. }
    9.  
    10. void StackInit(struct Stack& s)
    11. {
    12. 	//...
    13. }
    14.  
    15. int main()
    16. {
    17. 	int a = 1, b = 2;
    18. 	swap(a, b); //c语言需要传地址
    19.  
    20. 	struct Stack st;
    21. 	StackInit(st);
    22.  
    23. 	return 0;
    24. }

    6.2 引用特性

    1. 引用在定义时必须初始化

    2. 一个变量可以有多个别名

    3. 一旦引用一个实体，就不能引用其他实体

    6.3 常引用

    1. //权限可以缩小，但不能放大
    2. int main()
    3. {
    4. 	const int a = 10;//用const修饰后，a只能读不能写
    5. 	//int& ra = a;//报错，ra引用a属于权限放大(可读可写)
    6. 	const int& ra = a; //正确代码
    7.  
    8. 	int b = 10;
    9. 	int& rb = b;
    10. 	const int& crb = b;//正确，ceb引用b属于权限的缩小，所以可以
    11.  
    12. 	int c = 10;
    13. 	double d = 1.11;
    14. 	d = c; //隐式类型转换，将int类型的c放到一个double类型的临时变量中，再赋值给d
    15.  
    16. 	//double& rc = c; //报错，报错原因并不是因为类型不同
    17. 	const double& rc = c; //*正确代码，此时rc是c临时变量的别名，临时变量具有常性，所以加const就可以
    18.  
    19. 	return 0;
    20. }

    6.4 使用场景

    1. 做参数

    1. void Swap(int& left, int& right)
    2. {
    3. 	int temp = left;
    4. 	left = right;
    5. 	right = temp;
    6. }

    2. 做返回值(特殊场景)

    1. 传值返回 返回的是返回对象c的拷贝
    2. //int Add(int a, int b)
    3. //{
    4. //	int c = a + b;
    5. //	return c;
    6. //}
    7. //int main()
    8. //{
    9. //	//int& ret = Add(1, 2); //报错，因为ret接收的是储存c的值的临时变量(不是c)，具有常性，需在前加上const
    10. //	const int& ret = Add(1, 2);
    11. //	
    12. //	return 0;
    13. //}
    14.  
    15. //传引用返回 返回的是对象c的引用，其实就是c
    16. //实际中，如果出了函数作用域，返回变量就不存在了，不能用引用返回;出了作用域还在:例如用static修饰
    17. int& Add(int a, int b)
    18. {
    19. 	static int c = a + b;
    20. 	return c;
    21. }
    22.  
    23. int main()
    24. {
    25. 	int& ret = Add(1, 2);
    26. 	cout << ret << endl; //3
    27.  
    28. 	return 0;
    29. }

    注意：如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

    下面代码输出什么结果？为什么？

    1. int& Add(int a, int b)
    2. {
    3. 	int c = a + b;
    4. 	return c;
    5. }
    6. int main()
    7. {
    8. 	int& ret = Add(1, 2);
    9. 	Add(3, 4);
    10. 	cout << "Add(1, 2) is :" << ret << endl; //7
    11.  
    12. 	return 0;
    13. }

    6.5 传值、传引用效率比较

    以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低，相反使用引用传参效率更高。

    6.5.1 值和引用的作为传参的性能比较

    1. #include <time.h>
    2. struct A { int a[10000]; };
    3. void TestFunc1(A a) {}
    4. void TestFunc2(A& a) {}
    5. void TestRefAndValue()
    6. {
    7. 	A a;
    8.  
    9. 	// 以值作为函数参数
    10. 	size_t begin1 = clock();
    11. 	for (size_t i = 0; i < 10000; ++i)
    12. 		TestFunc1(a);
    13. 	size_t end1 = clock();
    14.  
    15. 	// 以引用作为函数参数
    16. 	size_t begin2 = clock();
    17. 	for (size_t i = 0; i < 10000; ++i)
    18. 		TestFunc2(a);
    19. 	size_t end2 = clock();
    20.  
    21. 	// 分别计算两个函数运行结束后的时间
    22. 	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;  //11
    23. 	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl; //1
    24. }
    25.  
    26. int main()
    27. {
    28. 	TestRefAndValue();
    29.  
    30. 	return 0;
    31. }

    6.5.2 值和引用的作为返回值类型的性能比较

    1. #include <time.h>
    2. struct A { int a[10000]; };
    3. A a;
    4. // 值返回
    5. A TestFunc1() { return a; }
    6. // 引用返回
    7. A& TestFunc2() { return a; }
    8. void TestReturnByRefOrValue()
    9. {
    10. 	// 以值作为函数的返回值类型
    11. 	size_t begin1 = clock();
    12. 	for (size_t i = 0; i < 100000; ++i)
    13. 		TestFunc1();
    14. 	size_t end1 = clock();
    15. 	// 以引用作为函数的返回值类型
    16. 	size_t begin2 = clock();
    17. 	for (size_t i = 0; i < 100000; ++i)
    18. 		TestFunc2();
    19. 	size_t end2 = clock();
    20. 	// 计算两个函数运算完成之后的时间
    21. 	cout << "TestFunc1 time:" << end1 - begin1 << endl;  //254
    22. 	cout << "TestFunc2 time:" << end2 - begin2 << endl;  //2
    23. }
    24. int main()
    25. {
    26. 	TestReturnByRefOrValue();
    27.  
    28. 	return 0;
    29. }

    通过上述代码的比较，发现传值和指针在作为传参以及返回值类型上效率相差很大。只要符合条件，尽量使用引用传参、传返回值。

    6.6 引用和指针的区别

    在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

    1. int main()
    2. {
    3. 	int a = 10;
    4. 	int& ra = a;
    5.  
    6. 	cout << "&a = " << &a << endl;    //00B5FD7C
    7. 	cout << "&ra = " << &ra << endl;  //00B5FD7C
    8.  
    9. 	return 0;
    10. }

    在底层实现角度，引用的底层也是类似指针存储地址的方式处理的，下面说的是语法角度。

    1. int main()
    2. {
    3. 	int a = 10;
    4.  
    5. 	//在语法上，给a的这块空间取了个别名，没有新开空间
    6. 	int& ra = a;
    7. 	ra = 20;
    8.  
    9. 	//在语法上，定义了一个pa指针变量,开辟了4个字节，存储a的地址
    10. 	int* pa = &a;
    11. 	*pa = 20;
    12.  
    13. 	return 0;
    14. }

    面试题*：引用和指针的不同点:

    1. 在语法上，引用概念上定义一个变量的别名，指针存储一个变量地址

    2. 引用在定义时必须初始化，指针没有要求

    3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体

    4. 没有NULL引用，但有NULL指针

    5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)

    6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

    7. 有多级指针，但是没有多级引用

    8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

    9. 引用比指针使用起来相对更安全

    7. 内联函数

    7.1 概念

    以 inline 修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销， 内联函数提升程序运行的效率。

    以交换函数为例：调用Swap函数需要建立栈帧，建立栈帧是有代价的，C语言为了避免小函数建立栈帧，提供了宏函数支持，预处理阶段展开，那么C语言都已经解决了，为什么C++还要提供inline函数呢？(面试题：宏函数的缺点)

    7.1.1 面试题：宏的优缺点 

    优点： 1.增强代码的复用性。 2.提高性能。

    缺点： 1.不支持调试。（因为预编译阶段进行了替换） ，导致代码可读性差，可维护性差，容易误用。 2. 宏函数语法复杂，容易出错 3.没有类型安全的检查 。

    写一个ADD的宏函数

    1. //ADD的宏函数
    2. //#define ADD(int x, int y) return x+y  //典型错误写法
    3. //#define ADD(x, y) (x)+(y);  //典型错误写法,加了分号
    4. //标准写法
    5. #define ADD(x, y) ((x) + (y))

    C++有哪些技术替代宏？

    1. 常量定义 换用const

    2. 换用内联函数

    1. //C++推荐将频繁调用的小函数，定义成inline(内联)，会在调用的地方展开。没有栈帧的开销
    2. inline int Add(int x, int y)
    3. {
    4. 	return x + y;
    5. }
    6.  
    7. int main()
    8. {
    9. 	int c = Add(1, 2);
    10. 	cout << c << endl;
    11.  
    12. 	return 0;
    13. }

    7.2 特性

    1. inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。

    2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。

    3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

    1. // F.h
    2. #include <iostream>
    3. using namespace std;
    4. inline void f(int i);
    5. // F.cpp
    6. #include "F.h"
    7. void f(int i)
    8. {
    9. 	cout << i << endl;
    10. }
    11. // main.cpp
    12. #include "F.h"
    13. int main()
    14. {
    15. 	f(10);
    16. 	return 0;
    17. }
    18. // 链接错误：main.obj : error LNK2019: 无法解析的外部符号 "void __cdecl f(int)" (?f@@YAXH@Z)，该符号在函数 _main 中被引用

    假设Sort()函数有100行指令，在10个地方调用，总计110条指令，但如果用inline修饰后，10个地方调用，展开后则变成1000条指令

    当指令变多意味着什么？

    答案：意味着编译出的可执行程序变大，导致安装软件的人体验变差，执行程序内存消耗变多。(指令的多少与效率高低无关，如果直接调用Sort会建立栈帧，效率反而低于直接执行1000条指令的inline Sort)

    结论：频繁调用的小函数，建议定义成内联函数

    8. auto关键字(C++11)

    1. #include <map>
    2. #include <string>
    3. //以下语法,当前了解即可
    4. //auto
    5. int main()
    6. {
    7. 	int a = 10;
    8. 	//int b = a;
    9. 	auto b = a; //类型声明成auto，可以根据a的类型自动推导b的类型为int
    10.  
    11. 	map<string, string> m;
    12. 	//map<string, string>::iterator it = m.begin();
    13. 	//这里可以根据m.begin()自动推导到it的类型是map<string, string>::iterator
    14. 	//这样写比较简洁
    15. 	auto it = m.begin();
    16.  
    17. 	return 0;
    18. }

    8.1 auto的使用细则

    1. auto与指针和引用结合起来使用 

    用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

    2. 在同一行定义多个变量

    当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

    1. void TestAuto()
    2. {
    3. 	auto a = 1, b = 2;
    4. 	auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
    5. }

    8.2 auto不能推导的场景

    1. auto不能作为函数的参数

    2. auto不能直接用来声明数组

    3. auto在实际中最常见的优势用法就是与C++11提供的新式for循环，还有lambda表达式等进行配合使用

    9. 基于范围的for循环(C++11)

    9.1 范围for的语法

    1. int main()
    2. {
    3. 	int array[] = { 1, 2, 3, 4, 5 };
    4. 	//以前遍历数组的方式
    5. 	for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
    6. 		cout << array[i] << " ";
    7. 	cout << endl;
    8. 	// 1 2 3 4 5 
    9. 	
    10. 	//范围for，更简单，数组也可以直接遍历
    11. 	//自动遍历，以此取出array中的元素，赋值给e，直到结束
    12. 	for (auto e : array)
    13. 	{
    14. 		cout << e << " ";
    15. 	}
    16. 	cout << endl;
    17. 	//1 2 3 4 5 
    18.  
    19. 	//以上是"读"的操作，"写"的操作需要注意加引用符号
    20. 	for (auto& ee : array) //ee是数组元素的临时拷贝，要想修改数组需要加引用符号
    21. 	{
    22. 		ee *= 2;
    23. 	}
    24.  
    25. 	return 0;
    26. }

    9.2 范围for的使用条件

    1. for循环迭代的范围必须是确定的

    对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。

    注意：以下代码就有问题，因为for的范围不确定

    1. void TestFor(int array[])
    2. {
    3. 	for (auto& e : array)
    4. 		cout << e << endl;
    5. }
    6. //因为此处array作为形参是一个指针，而非数组了

    2. 迭代的对象要实现++和==的操作(之后再谈)

    10. 指针空值nullptr(C++11)

    1. //C++11
    2. int main()
    3. {
    4. 	//以前使用的
    5. 	int* p1 = NULL; //等价于 int* p1 = 0;
    6.  
    7. 	//C++推荐使用的
    8. 	int* p2 = nullptr;
    9.  
    10. 	return 0;
    11. }

    NULL实际是一个宏，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在 使用空值的指针时，都不可避免的会遇到一些麻烦，比如：

    1. void f(int i)
    2. {
    3. 	cout << "f(int)" << endl;
    4. }
    5. void f(int* p)
    6. {
    7. 	cout << "f(int*)" << endl;
    8. }
    9. int main()
    10. {
    11. 	f(0);         //期望匹配整形参数的f，结果:f(int)
    12. 	f(NULL);      //期望匹配指针参数的f，结果:f(int),因为NULL被替换成0了
    13. 	f((int*)NULL);//f(int*)
    14. 	f(nullptr);   //f(int*)
    15.  
    16. 	return 0;
    17. }

    程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。 在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。

    注意：

    1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。

    2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。

    3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。

  • 相关阅读:
    原创 VTK 基础入门 ( 一 ) 贴纹理
    RabbitMQ部署指南
    Mybatis 动态SQL
    Java动态代理Proxy.newProxyInstance
    Yield Guild Games：社区更新——2022 年第二季度
    [ACNOI2022]做过也不会
    还不会Nginx？京东技术官精心准备的一份Nginx高并发神器送给你
    基于批发价格指数的美国通货膨胀研究，数据从1960年第一季度至1990年第4季度的WPI（批发价格指数）共有124个数据，使用R中的ARIMA模型对该时间序列进行建模分析。
    【视觉SLAM十四讲学习笔记】第二讲——初识SLAM
    网络安全——逻辑漏洞之越权漏洞
  • 原文地址：https://blog.csdn.net/m0_62934529/article/details/125440791