文章目录

7. C++输入与输出8. 缺省参数9. 函数重载10. 引用10. 1 引用的概念10. 2 引用的特性10. 3 引用的使用10. 4 const引用10. 5 指针和引用的关系

11. inline12. nullptr

7. C++输入与输出

iostream是 Input Output Stream 的缩写，是标准输入、输出流库，定义了标准的输入、输出对象。

包含C++标准库是不需要+<code>.h后缀。

#include<iostream>//C++库

#include<stdio.h>//C语言库

std::cin 是istream 类的对象，它主要面向窄字符(narrow characters(of type char))的标准输入流。

std::cout 是 ostream 类的对象，它主要面向窄字符的标准输出流。

std:.endl是一个函数，流插入输出时，相当于插入一个换行字符加刷新缓冲区。

<<是流插入运算符，>>是流提取运算符，它们可以连续输入输出。(C语言还用这两个运算符做位运算左移/右移)

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

一般日常练习中我们可以using namespace std;，实际项目开发中不建议使用，因为std这个命名空间远远不止只有输入输出的函数。

使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动指定格式，C++的输入输出可以自动识别变量类型(本质是通过函数重载实现的，这个后面会讲到)，其实最重要的是C++的流能更好的支持自定义类型对象的输入输出（也是函数重载）。

可以把流看成水流，<<和>>看作水流流动的方向。

#include<iostream>

using namespace std;

int main()

{

int a = 0;

char b = 'c';

cin >> a;//cin >> a >> b;也是支持的，可以连续输入

//可以连续输出，并且可以自动识别变量类型，可以混合使用

cout << a << b << 'c' << "ad" << endl;

return 0;

}

当然，也正是因为<code>cout输出比较简洁，所以相对printf来说其格式化地输出比较麻烦（当然，是可以实现的），失去了cout的简洁的优势，而且有的OJ平台不支持cout的格式化输出，所以在写OJ题时如果需要用到格式化输出，推荐使用printf，当然，在实际开发中还是使用IO流更加安全。

#include<iostream>

#include<iomanip>//cout格式化需要额外的头文件

#include<stdio.h>

int main()

{

double PI = 3.14159;

printf("%.2lf\n", PI);

std::cout<< std::fixed << std::setprecision(2) << PI << std::endl;

return 0;

}

这里printf和cout的输出是一样的，都是3.14，但显然printf比较简洁。

IO流涉及类和对象，运算符重载、继承等很多面向对象的知识，这些知识不属于入门基础，所以这里只能简单认识一下C++ IO流的用法，后面我会出专门的一篇博客来详解IO流库。

#include<iostream>

int main()

{

printf("1\n");

return 0;

}

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

在C++中，如果要包含C语言的库，比如stdio.h时，除了和C语言一样的写法之外，还有一种写法。

#include<cstdio>

int main()

{

printf("1\n");

return 0;

}

一般来讲更推荐这种写法。

效率问题：

#include<iostream>

using namespace std;

int main()

{

//在需要大量输入输出的竞赛中添加这3行代码可以提升效率

//取消IO流输入输出与stdio的关联

ios_base::sync_with_stdio(false);

//取消cin与cout之间的绑定

cin.tie(nullptr);

cout.tie(nullptr);

return 0;

}

8. 缺省参数

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

#include<iostream>

using namespace std;

int Add(int a = 1, int b = 10)//全缺省

{

return a + b;

}

int main()

{

cout << Add() << endl;//未传参，使用缺省参数

cout << Add(2) << endl;//传一个参，形参从左往右接收，其它的使用缺省参数

cout << Add(2, 3) << endl;//传两个参，按传参计算

return 0;

}

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

<code>int Add(int a = 10, int b)//不可以

{

return a + b;

}

int Sub(int a, int b = 10)//可以

{

return a - b;

}

这么规定的原因是，假如说有这样一个代码：

cout << Add(1) << endl;//这个Add就是上面的Add

那么这个参数1是传递给哪个形参的？而Sub就没有这样的歧义。

半缺省的函数调用时传参个数必须大于等于没有缺省值的形参个数。

带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。

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

//test.h

#include<iostream>

int Add(int a = 10, int b = 2);

//test.cpp

#include"test.h"

int Add(int a, int b)//定义时不要写缺省值

{

return a + b;

}

int main()

{

std::cout << Add() << std::endl;

return 0;

}

如果在定义时仍然写缺省值，编译器会给出重定义默认参数的错误。

9. 函数重载

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

C语言是不支持同一作用域中出现同名函数的。

形参类型不同

#include<iostream>

using namespace std;

int Add(int a, int b)

{

cout << "int Add(int a, int b)" << endl;

return a + b;

}

double Add(double a, double b)

{

cout << "double Add(double a, double b)" << endl;

return a + b;

}

int main()

{

Add(1, 2);

Add(1.0, 2.0);

return 0;

}

输出：

这两个Add函数就是重载函数，调用时会根据形参的类型自动选择合适的函数，不用像C语言一样命名为add_int，add_double。

2. 参数个数不同

<code>#include<iostream>

using namespace std;

void func()

{

cout << "void func()" << endl;

}

void func(int a)

{

cout << "void func(int a)" << endl;

}

int main()

{

func();

func(1);

return 0;

}

参数类型的顺序不同

<code>#include<iostream>

using namespace std;

void func(int a, char c)

{

cout << "void func(int a, char c)" << endl;

}

void func(char c, int a)

{

cout << "void func(char c, int a)" << endl;

}

int main()

{

func(1, 'c');

func('c', 2);

return 0;

}

输出：

还有几个常见的错误：

返回值不同不构成重载

<code>int func()

{

cout << "int func()" << endl;

}

void func()

{

cout << "void func()" << endl;

}

编译器给出报错：

无参数与全缺省

<code>#include<iostream>

using namespace std;

int func(int a = 10)//全缺省

{

cout << "int func(int a = 10)" << endl;

}

void func()//无参数

{

cout << "void func()" << endl;

}

int main()

{

func(1);//调用全缺省

func();//调用谁？

return 0;

}

编译器会给出重载函数调用不明确的报错。

10. 引用

10. 1 引用的概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。比如林冲外号豹子头，林冲和豹子头指的都是林冲。

<code>类型& 引用别名 = 引用对象;

C++中为了避免引入太多的运算符，会复用C语言的一些符号，比如前面的<<和>>，这里引用也和取地址使用了同一个符号&，注意从使用方法角度区分就可以，取地址是在变量前面的，而引用符号是类型的一部分。

#include<iostream>

using namespace std;

int main()

{

int a = 10;

int& b = a;

int& c = b;

cout << a << ' ' << &a << endl;

cout << b << ' ' << &b << endl;

cout << c << ' ' << &c << endl;

return 0;

}

可以看到它们的值和地址都是一样的。

10. 2 引用的特性

引用在定义时必须初始化一个变量可以有多个引用引用指向的变量不可更改

<code>#include<iostream>

using namespace std;

int main()

{

int a = 10;

//int& b;//未初始化，编译器报错

int b = 5;

int& c = a;

c = b;//当尝试让c引用其他变量时，会发现这其实是一个赋值语句

cout << a << ' ' << &a << endl;

cout << c << ' ' << &c << endl;

return 0;

}

<code>c 仍然指向 a，并且通过 c 改变了 a 的指向。

10. 3 引用的使用

引用在实践中主要是用于引用传参和引用做返回值，减少拷贝，提高效率，并且改变引用对象时同时改变被引用对象。引用传参跟指针传参功能是类似的，引用传参相对更方便一些。引用返回值的场景相对比较复杂，这里简单介绍一下场景，还有一些内容在后续类和对象的博客中会继续深入探讨。使用引用返回值时要注意，引用的本质是简化了的指针，返回的值不能是局部变量，不然会导致野引用。

#include<iostream>

using namespace std;

int& Add(int& a, int& b)

{

int* c = (int*)malloc(sizeof(int));//动态开辟

*c = a + b;

return *c;

}

int main()

{

int a = 1, b = 2;

cout << Add(a, b) << endl;//注意这里不能 Add(1, 2)，原因在下个小章节

return 0;

}

输出为 3。

引用和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。C++的引用跟其他语言的引用(如Java)是有很大的区别的，除了用法，最大的区别是C++引用定义后不能改变指向，Java的引用可以改变指向。一些主要用C代码实现版本数据结构教材中，使用C++引用替代指针传参，目的是简化程序，避开复杂的指针。（可惜这导致这段C原因代码更难理解了）

比如单链表的尾插：

C语言版本：

void SListPushBack(SListNode** pplist, SLTDateType x);

可以看到C语言版本需要用到二级指针。

C++版本：

void SListPushBack(SListNode& list, SLTDateType x);

而C++版本就不需要。

指针变量也可以取别名，所以二级指针基本就被优化掉了。

指针取别名：

#include<iostream>

using namespace std;

typedef int* pint;

int main()

{

int* a=(int*)malloc(sizeof(int));

*a = 10;

//int*& b = a;

pint& b = a;//两种写法均可以

cout << *a << ' ' << a << endl;

cout << *b << ' ' << b << endl;

}

10. 4 const引用

const对象也可以被引用，但是必须用const引用。const引用也可以引用普通对象，因为对象的访问权限在引用过程中可以缩小，但是不能放大。（引用的底层是指针，权限的放大缩小问题与指针是一样的）

#include<iostream>

using namespace std;

int main()

{

const int a = 10;

int k = 0;

// int& b = a;//权限放大，编译不通过

const int& c = a;//权限相等，可以

const int& d = k;//权限缩小，可以

return 0;

}

不需要注意的是类似：

int main()

{

int a = 10;

int& b = a * 3;//编译不通过

double d = 12.3;

int& e = d;//注意这里发生了隐式类型转换，编译不通过

return 0;

}

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

int main()

{

int a = 10;

const int& rb = a * 3;

double d = 12.3;

const int& e = d;

return 0;

}

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

10. 5 指针和引用的关系

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

语法概念上引用是一个变量的取别名不开空间，指针是存储一个变量地址，要开空间。

引用在定义时必须初始化，指针建议初始化，但是语法上不是必须的。

引用在初始化时引用一个对象后，就不能再引用其他对象。而指针可以不断地改变指向对象。

引用可以直接访问指向对象，指针需要解引用才是访问指向对象。

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

指针很容易出现空指针和野指针的问题，引用（相对）很少出现，引用使用起来相对更安全一些。

11. inline

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

C语言实现宏函数也会在预处理时替换展开，但是宏函数实现很复杂很容易出错，且不方便调试，C++设计了inline目的就是替代C的宏函数。

但inline对于编译器而言只是一个建议，也就是说，你加了inline编译器也可以选择在调用的地方不展开，不同编译器关于inline什么情况展开各不相同，因为C++标准没有规定这个。inline适用于频繁调用的短小函数，对于递归函数，代码相对多一些的函数，加上inline也会被编译器忽略。

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

右键项目->属性->C/C++ ->常规->调试信息格式->（更改为）程序数据库

前同->C/C+±>优化->内联函数扩展->（更改为）只适用于_inline

注意即使更改了这两处，当函数内容较多时，内联函数也不会展开。

你可以通过VS调试功能中的反汇编功能观察是否发生了内联展开。

当代码正在调试（F10）时，右击编辑器窗口（就是写代码的地方）->转到反汇编。

<code>inline int Add(int a, int b)

{

return a + b;

}

int main()

{

Add(1, 2);

return 0;

}

5. <code>inline函数不能声明和定义分离到两个文件，分离会导致在这两个文件之外的地方调用这个函数时链接错误。因为inline被展开，就没有函数地址，链接时会出现报错。

//test.h

inline int Add(int a, int b);

//test.cpp

#include"test.h"

inline int Add(int a, int b)

{

return a + b;

}

//main.c

#include"test.h"

int main()

{

Add(1, 2);

return 0;

}

编译器报错：

12. nullptr

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

#ifndef NULL

#ifdef __cplusplus

#define NULL 0

#else

#define NULL ((void *)0)

#endif

#endif

可以看到，如果是C++文件，NULL的定义就会从 (void*)0 变成 0。

不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，本想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，调用了f(intx)，因此与程序的初衷相悖。

#include<iostream>

using namespace std;

void func(int* a)

{

cout << "void func(int* a)" << endl;

}

void func(int a)

{

cout << "void func(int a)" << endl;

}

int main()

{

func(NULL);

return 0;

}

输出如下，与预期不符。

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

’

将上面的main函数中的函数调用语句更改为这个:

func(nullptr);

当然也可以这样调用：

<code>func((int*)NULL);

不过不如直接使用nullptr。

谢谢你的阅读，喜欢的话来个点赞收藏评论关注吧！

我会持续更新更多优质文章！