C++ 入门基础

C++是在C语言的基础上发展而来的一种面向对象编程语言，它在保留C语言强大功能的同时，引入了许多新的特性。比如面向对象编程(OOP)：类, 封装, 继承, 多态四大件，引用(Reference)，模板(Template)，命名空间(Namespace)，异常处理(Exception Handling)，标准模板库(STL)。

1. C++发展历史

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

1983年，Bjarne Stroustrup 在 C 语言的基础上添加了面向对象编程的特性，设计出了 C++ 语言的雏形，此时的 C++ 已经有了类、封装、继承等核心概念，为后来的面向对象编程奠定了基础。这一年该语言被正式命名为C++。

在随后的几年中，C++ 在学术界和工业界的应用逐渐增多。一些大学和研究所开始将 C++ 作为教学和研究的首选语言，而一些公司也开始在产品开发中尝试使用 C++。这一时期，C++ 的标准库和模板等特性也得到了进一步的完善和发展。

C++ 的标准化工作于1989年开始，并成立了一个 ANSI 和 ISO（International Standards Organization，国际标准化组织）的联合标准化委员会。1994年标准化委员会提出了第一个标准化草案。在该草案中，委员会在保持斯特劳斯特卢普最初定义的所有特征的同时，还增加了部分新特征。

在完成 C++ 标准化的第一个草案后不久，STL（Standard Template Library，标准模板库） 作为惠普实验室开发的一系列软件的统称被提出。它是由 Alexander Stepanov、Meng Lee 和 David R Musser 在惠普实验室工作时所开发出来的。在通过了标准化第一个草案之后，联合标准化委员会投票并通过了将 STL 包含到 C++ 标准中的提议。STL 对 C++ 的扩展超出 C++ 的最初定义范围。虽然在标准中增加 STL 是个很重要的决定，但也因此延缓了 C++ 标准化的进程。

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

2. C++的第一个程序

// test.cpp #include<stdio.h> int main() { printf("hello world\n"); return 0; }

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

当然C++有⼀套自己的输入输出，严格说C++版本的hello world应该是这样写的

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

这⾥的std cout等我们都看不懂，没关系，下⾯我们会依次讲解

3. 命名空间

3.1 namespace的价值

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

c语⾔项⽬类似下⾯程序这样的命名冲突是普遍存在的问题，C++引⼊namespace就是为了更好的解决这样的问题。

在没有包含<stdlib.h>时程序是可以运行的，但是如果包含了<stdlib.h>，程序还能正常运行吗？

答案显而易见，是不可以的，rand()函数是在头文件<stdlib.h>中的，它的作用是产生一个随机数。因为将头文件<stdlib.h>展开的话就会有rand()函数与全局变量rand重名，此时它们都在全局域内，这就会产生重定义。所以命名空间namespace就应运而生了。

3.2 namespace的定义

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

namespace本质是定义出⼀个域，这个域跟全局域各自独⽴，不同的域可以定义同名变量，所以下⾯的rand不在冲突了。

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

namespace只能定义在全局，当然他还可以嵌套定义。

项目工程中多文件中定义的同名namespace会认为是⼀个namespace，不会冲突。

C++标准库都放在⼀个叫std(standard) 的命名空间中。

#include <stdio.h> #include <stdlib.h> namespace test { int rand = 10; } int main() { //这里默认是访问的是全局的rand函数指针 printf("%d\n", rand); //这里指定test命名空间中的rand printf("%d\n", test::rand); return 0; }

3.3 命名空间的嵌套

C++ 中namespace（命名空间） 支持嵌套定义，即在一个命名空间内部可以定义另一个命名空间，形成层级化的域结构，能进一步细化名字的隔离范围，避免不同模块间的名字冲突。

嵌套命名空间的域是完全独立的：内外层命名空间中可定义同名变量/函数，不会冲突；
内层访问外层成员：需通过外层命名空间名::成员名显式指定，否则默认访问内层自身成员；

#include <stdio.h> using namespace std; // 定义嵌套命名空间 namespace OuterNS { int a = 10; namespace InnerNS { int a = 20; void show() { printf("InnerNS::a = %d\n ",OuterNS::a); // 访问外层命名空间的a（需指定外层域） printf("OuterNS::a = %d\n ",OuterNS::a); } } } int main() { //逐级访问内层成员 OuterNS::InnerNS::show(); printf("直接访问InnerNS::a: %d\n ",OuterNS::InnerNS::a); //using声明简化访问 using OuterNS::InnerNS::a; printf("using后访问a: %d\n ",a); //using指令引入整个内层命名空间 using namespace OuterNS::InnerNS; show(); // 无需逐级写域，直接调用 return 0; }

多文件中可以定义同名namespace，他们会默认合并到⼀起，就像同⼀个namespace⼀样

myns.h

// 防止头文件重复包含 #pragma once #include <stdio.h> //声明命名空间中的函数 namespace MyNS { void func1(); void func2(); }

namespace1.cpp

#include "myns.h" // 定义MyNS的变量和函数 namespace MyNS { int num1 = 100; void func1() { printf("这是 MyNS 中的 func1，num1 = %d\n", num1); } }

namespace2.cpp

#include "myns.h" // 定义 MyNS 的另一部分变量和函数 namespace MyNS { int num2 = 200; void func2() { printf("这是 MyNS 中的 func2，num2 = %d\n", num2); } }

test.cpp

#include "myns.h" //直接访问合并后的 MyNS 成员 int main() { // 直接访问不同文件中定义的 MyNS 变量（命名空间已自动合并） printf("访问 MyNS::num1 = %d\n", MyNS::num1); printf("访问 MyNS::num2 = %d\n", MyNS::num2); // 调用 MyNS 中的函数 MyNS::func1(); MyNS::func2(); return 0; }

3.4 命名空间使用

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

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

// 指定命名空间访问 int main() { printf("%d\n", N::a); return 0; } // using将命名空间中某个成员展开 using N::b; int main() { printf("%d\n", N::a); printf("%d\n", b); return 0; } // 展开命名空间中全部成员 using namespce N; int main() { printf("%d\n", a); printf("%d\n", b); return 0; }

4. 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 流的用法，后面我会有专门的一个章节来细化 IO 流库。

cout/cin/endl 等都属于 C++ 标准库，C++ 标准库都放在一个叫std (standard) 的命名空间中，所以要通过命名空间的使用方式去使用它们。

一般日常练习中我们可以using namespace std，实际项目开发中不建议使用using namespace std。

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

#include <iostream> using namespace std; int main() { int a; double b; char c; //输出流 cout << "Hello World\n" << endl; //输入流 cin >> a >> b >> c; cout << a << " " << b << " " << c << endl; // << 流插入运算符 >> 流提取运算符 return 0; }

5. 缺省参数

缺省参数是声明或定义函数时为函数的参数指定⼀个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。（有些地方把缺省参数也叫默认参数）
全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。
带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。
函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。

#include<iostream> using namespace std; void Func(int n = 0) //缺省参数 { cout << n << endl; } //全缺省 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 = 10, int c = 20) { cout << "a = " << a << endl; cout << "b = " << b << endl; cout << "c = " << c << endl << endl; } int main() { Func(); //没有传参时，使用参数的默认值 Func(10);//传参时，使用指定的实参 Func1(); Func1(1); Func1(1, 2); Func1(1, 2, 3); //传参是从左到右不能跳跃 Func2(100); Func2(100, 200); Func2(100, 200, 300); return 0; }

函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须在函数声明中给缺省值。因为如果缺省参数在函数声明和定义中同时出现并且给的缺省值都不同的话，编译器就无法确定缺省值到底是哪一个。

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

6. 函数重载

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

#include <iostream> using namespace std; //函数重载 //1.参数类型不同 //2.参数个数不同 //3.参数顺序不同 int Add(int x, int y) { return x + y; } double Add(double x, double y) { return x + y; } int main() { cout << Add(1, 2) << endl; cout << Add(1.1, 2.2) << endl; return 0; }

注意：当两个函数的函数名相同时，如果两个函数的参数列表相同而返回类型不同，这种情况也不会构成函数重载。因为函数在被调用时，编译器不知道调用哪一个。

#include<iostream> using namespace std; void f1() { cout << "f()" << endl; } void f1(int a = 10) { cout << "f(int a)" << endl; } int main() { //f1(); 不能正常运行，编译器不知道调用哪一个函数 f1(1);//可以正常运行 return 0; }

上面两个函数构成重载，但调用f1()时，会报错，存在歧义，编译器不知道调用谁

注意：在不同的作用域中，两个函数就算同名，参数列表相同还有返回类型相同，那也是不同的两个函数，不会造成冲突。

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

7. 引用

7.1 引用的概念和定义

概念：引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。⽐如：水浒传中李逵，宋江叫"铁牛"，江湖上⼈称"黑旋风"；林冲，外号豹⼦头；

使用方法：类型& 引用别名 = 引用对象;

C++中为了避免引入太多的运算符，会复用C语⾔的⼀些符号，比如前面的<< 和 >>，这里引用也和取地址使用了同⼀个符号&。

#include <iostream> using namespace std; int main() { int a = 0; //引用：b和c是a的别名 int& b = a; int& c = a; //也可以给别名b取别名，d相当于还是a的别名 int& d = b; //给别名取别名 ++d; //他们的地址是一样的 cout << &a << endl; cout << &b << endl; cout << &c << endl; cout << &d << endl; return 0; }

注意：引用于被引用的对象类型必须一致

7.2 引用的特征

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

#include<iostream> using namespace std; int main() { int a = 10; // 编译报错：“ra”: 必须初始化引⽤ //int& ra; int& b = a; int c = 20; // 这⾥并⾮让b引⽤c，因为C++引⽤不能改变指向， // 这⾥是⼀个赋值 b = c; cout << &a << endl; cout << &b << endl; cout << &c << endl; return 0; }

7.3 引用的使用

引用在实践中主要是于引用传参和引用做返回值中减少拷贝提高效率和改变引用对象时同时改变被引用对象。
引用传参跟指针传参功能是类似的，引用传参相对更方便⼀些。
引用返回值的场景相对比较复杂，我们在这里简单讲了⼀下场景，还有⼀些内容后续类和对象章节中会继续深入讲解。
引用和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。
C++的引用跟其他语言的引用(如Java)是有很大的区别的，除了用法，最大的点，C++引用定义后不能改变指向，Java的引用可以改变指向。

#include<iostream> using namespace std; void Swap(int& rx, int& ry) { int tmp = rx; rx = ry; ry = tmp; } int main() { int x = 0, y = 1; cout << x <<" " << y << endl; Swap(x, y); cout << x << " " << y << endl; return 0; }

被引用的对象类型也可以是指针

#include <iostream> using namespace std; int main() { int num = 100; int* p = &num; int*& rp = p; // 定义指针的引用rp，关联到指针p（rp是p的别名） //通过指针引用修改指向的变量值 *rp = 200; cout << "num = " << num << endl; //num = 200 //通过指针引用修改指针本身的指向 int new_num = 300; rp = &new_num; cout << "*p = " << *p << endl; //*p = 300（p的指向被rp修改） return 0; }

7.4 const 引用(常引用)

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

不需要注意的是类似

int& rb = a*3;
double d = 12.34;
int& rd = d;

这样⼀些场景下a*3的和结果保存在⼀个临时对象中， int& rd = d 也是类似，在类型转换中会产⽣临时对象存储中间值，也就是时，rb和rd引用的都是临时对象，⽽C++规定临时对象具有常性，所以这里就触发了权限放⼤，必须要用常引用才可以。

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

int main() { const int a = 10; // 编译报错：error C2440: “初始化”: ⽆法从“const int”转换为“int &” // 这⾥的引用是对a访问权限的放⼤ //int& ra = a; × // 这样才可以 const int& ra = a; //√ // 编译报错：error C3892: “ra”: 不能给常量赋值 //ra++; // 这⾥的引⽤是对b访问权限的缩⼩ int b = 20; const int& rb = b; // 编译报错：error C3892: “rb”: 不能给常量赋值 //rb++; return 0; }

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

#include<iostream> using namespace std; int main() { int a = 10; const int& ra = 30; // 编译报错: “初始化”: ⽆法从“int”转换为“int &” // int& rb = a * 3; const int& rb = a*3; double d = 12.34; // 编译报错：“初始化”: ⽆法从“double”转换为“int &” // int& rd = d; const int& rd = d; return 0; }

为什么int& rb = a * 3;是不合法的,需要改成const int& rb = a*3;才合法?

a * 3 是一个表达式，它计算a和3的乘积，并产生一个临时对象来存储临时的整型值（在这个例子中是30）。这个临时对象没有持久的内存地址，它在表达式求值完成后就会被丢弃。因此，你不能将一个引用绑定到一个临时对象上，因为引用需要绑定到一个持久的、可以唯一标识的实体上。

常量引用有一个重要的用途：它可以延长临时对象的生命周期。在C++中，通常临时对象的生命周期仅限于包含它们的完整表达式。但是，如果你将一个临时对象绑定到一个常量引用上，那么这个临时对象的生命周期就会被延长，直到引用它的常量引用超出作用域或被重新绑定到另一个对象上。

为什么int& rd = d;是不合法的,需要改成 const int& rd = d;才合法?

int 和 double 是两种底层存储结构完全不同的类型，将 double 转换为 int 时会发生数值截断（比如 double 类型的 12.34 转换为 int 会丢失小数部分，仅保留 12）；若允许非 const 引用绑定，后续通过 int 引用修改的值会基于截断后的 int 存储规则写入，这会直接破坏原始 double 对象的内存结构（double 占用 8 字节、int 占用 4 字节，存储格式也不同），导致程序出现不可预测的运行错误。

编译器在处理跨类型绑定引用时，会先执行隐式类型转换并生成一个临时的 int 对象来存储截断后的值；而 C++ 语法明确规定，普通的非 const 引用不能绑定到临时对，因为临时对象的生命周期极短，若允许绑定，引用修改的只是临时对象而非原始 d，会导致代码逻辑完全偏离预期

也就是，当试图把 double 的 d 绑定到 int 引用时，编译器会先把 d 转换成 int 类型（截断小数），并在内存中创建一个临时的 int 对象来存储这个转换后的值。const 引用支持绑定跨类型转换产生的临时对象（即存储 d 截断后值的 int 临时对象），避免了非 const 引用的 “无效修改” 问题，const关键字不仅保证了无法通过 rd 修改临时对象（契合 “截断后的值仅用于读取” 的合理场景），还会将临时对象的生命周期延长至与引用 rd 一致，确保访问时临时对象不会被提前销毁。

7.5 指针和引用的关系

C++ 中指针和引用就像两个性格迥异的亲兄弟，指针是哥哥，引用是弟弟，在实践中他们相辅相成，功能有重叠性，但是各有自己的特点，互相不可替代。
语法概念上引用是一个变量的取别名不开空间，指针是存储一个变量地址，要开空间。
引用在定义时必须初始化，指针建议初始化，但是语法上不是必须的。
引用在初始化时引用一个对象后，就不能再引用其他对象；而指针可以不断地改变指向对象
引用可以直接访问指向对象，指针需要解引用才是访问指向对象。
sizeof中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数（32 位平台下占 4 个字节，64 位下是 8byte）。
指针很容易出现空指针和野指针的问题，引用很少出现，引用使用起来相对更安全一些。

#include <iostream> using namespace std; int main() { int a = 10, b = 20; //引用必须初始化，指针可未初始化 int& ra = a; // 引用定义时必须绑定对象 int* p; // 指针语法上可未初始化 //引用不可更换绑定对象，指针可更换指向 // ra = b; // 这不是更换引用对象，而是给a赋值为20 p = &a; // 指针指向a p = &b; // 指针可改为指向b //访问方式：引用直接用，指针需解引用 cout << "引用访问：" << ra << endl; // 直接访问a，输出10 cout << "指针访问：" << *p << endl; // 解引用访问b，输出20 //sizeof差异 cout << "sizeof(引用)：" << sizeof(ra) << endl; // 输出4（int类型大小） cout << "sizeof(指针)：" << sizeof(p) << endl; // 64位平台输出8，32位输出4 return 0; }

8. online

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

inline 对于编译器而言只是一个建议性关键字，也就是说，即便你给函数加上 inline，编译器也可以选择不在调用位置将其展开；不同编译器对 inline 函数的展开规则各不相同，因为 C++ 标准并未强制规定展开的具体场景。inline仅适用于频繁调用的短小函数，对于递归函数、代码量较多的函数，即便加上 inline也会被编译器忽略。

C 语言的宏函数会在预处理阶段直接替换展开，但宏函数的实现逻辑复杂、极易出错，且无法调试，C++ 设计 inline 的核心目的，就是替代 C 语言的宏函数，既保留 “代码展开” 的效率优势，又解决宏函数的缺陷。

VS 编译器在 Debug 调试版本 下默认不展开 inline 函数（便于调试），若想在 Debug 版本中让 inline 生效，需要手动设置两个配置项。

inline 函数不建议将声明和定义分离到两个文件（如声明在.h、定义在.cpp），这种分离会导致链接错误 —— 因为 inline 函数被编译器展开后，不会生成函数的地址符号，链接阶段找不到对应函数地址就会报错。

右键项目-->属性打开属性页

#include<iostream> using namespace std; inline int Add(int x, int y) { int ret = x + y; ret += 1; ret += 1; ret += 1; return ret; } int main() { // 可以通过汇编观察程序是否展开 // 有call Add语句就是没有展开，没有就是展开了 int ret = Add(1, 2); cout << Add(1, 2) * 5 << endl; return 0; }

我们可以通过汇编观察内联函数是否展开，有 call 语句就是没有展开，没有就是展开了

通过上面的设置之后可以看到内联函数的展开

9. nullptr

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

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

在 C++ 中，NULL的定义存在两种常见形式：要么被定义为字面常量0，要么沿用 C 语言的定义无类型指针(void*)的常量。无论采用哪种定义，使用NULL表示空指针时都会引发问题：例如原本希望通过f(NULL)调用指针版本的f(int*)函数，但由于NULL本质被解析为0，编译器会优先匹配f(int x)重载函数，完全违背程序设计初衷；即便尝试用f((void*)NULL)强制调用指针版本，也会直接触发编译报错。

C++11 标准专门引入了关键字nullptr来解决NULL的缺陷：nullptr是一种特殊类型的字面量，它仅能被隐式转换为任意指针类型，但无法转换为整数类型。使用nullptr定义空指针可彻底规避类型混淆问题，比如调用f(nullptr)时，编译器会精准匹配f(int*)指针版本的函数，而非f(int x)整数版本，完全符合程序的设计意图。

#include<iostream> using namespace std; void f(int x) { cout << "f(int x)" << endl; } void f(int* ptr) { cout << "f(int* ptr)" << endl; } int main() { f(0); // 本想通过f(NULL)调用指针版本的f(int*)函数， // 但是由于NULL被定义成0，调用了f(intx)，因此与程序的初衷相悖。 f(NULL); f((int*)NULL); // 编译报错：error C2665: “f”: 2 个重载中没有⼀个可以转换所有参数类型 // f((void*)NULL); f(nullptr); return 0; }