C++入门基础

一.缺省参数

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

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

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

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

// 全缺省 
void quan(int a = 10, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
}
// 半缺省 
void ban(int a, int b = 10, int c = 20)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
}
int main()
{
	quan();
	quan(1);
	quan(1, 2);
	quan(1, 2, 3);
	ban(100);
	ban(100, 200);
    ban(100, 200, 300);
	return 0;
}

下面的一段代码来演示声明定义分离时，怎么做：

#pragma once
#include <iostream>
using namespace std;
// work.h
#include <iostream>
#include <assert.h>
using namespace std;
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;
void STInit(ST* ps, int n = 4);
//work.cpp
#include"work.h"
// 缺省参数不能声明和定义同时给
void STInit(ST* ps, int n)
{
	assert(ps && n > 0);
	ps->a = (STDataType*)malloc(n * sizeof(STDataType));
	ps->top = 0;
	ps->capacity = n;
}

二.函数的重载

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

1.参数的类型不同

int Add(int left, int right)
{
	cout << "int Add(int left, int right)" << endl;
	return left + right;
}
double Add(double left, double right)
{
	cout << "double Add(double left, double right)" << endl;
	return left + right;
}

2.参数的个数不同 

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

3. 参数的类型顺序不同

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

注意：1.返回值不同，不能作为函数的重载 ，且调用的时候也无法区分。如下

void fxx()
{}

int fxx()
{
 return 0;
}

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

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

三.引用

1.引用的定义以及概念 

引用不是新定义⼀个变量，而是给已存在变量取了⼀个别名，编译器不会为引用变量开辟内存空间， 它和它引用的变量共用同⼀块内存空间。比如：水壶传中李逵，宋江叫"铁牛"，江湖上人称"黑旋风"；林冲，外号豹子头； 类型& 引用别名 = 引用对象;

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;

这里我先给a取了两个别名，b，c，然后我又将b取了一个别名为d，这也就相当于给a又取了一个别名。所以四个的地址是一样的 

相当于一块区域，拥有多个名字 

2.引用的特性

• 引用在定义时必须初始化

• ⼀个变量可以有多个引用

• 引用⼀旦引用⼀个实体，再不能引用其他实体

如果不初始化就会报错 。

int a = 10;
int& b=a;
int c = 20;
b = c;
cout << &a << endl;
cout << &b << endl;
cout << &c << endl;

这里我们可以看见我进行了b=c，但是我们看他们的地址可以知道，a，b是一样的，而c是不一样的，所以引用不可以改变指向对象。那这里的b=c起到了什么作用呢 

我们可以看见进行完b=c之后，a，b的值都发生了改变。 

3.引用的使用

• 引用在实践中主要是于引用传参和引用做返回值中减少拷贝提高效率和改变引用对象时同时改变被 引用对象。

• 引用传参跟指针传参功能是类似的，引用传参相对更方便⼀些。

• 引用返回值的场景相对比较复杂，我们在这里简单讲了⼀下场景

• 引用和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。C++的引用跟其他 语言的引用(如Java)是有很大的区别的，除了用法，最大的点，C++引用定义后不能改变指向， Java的引用可以改变指向。

1.>寻常的类型

void Swap(int& rx, int& ry)
{
	int tmp = rx;
	rx = ry;
	ry = tmp;
}
int main()
{
	int a = 10;
	int b = 20;
	Swap(a, b);
	cout << a << endl;
	cout << b << endl;
	return 0;
}

2.>用指针的一些场景也可以使用引用来解决 

#include<iostream>
#include<stdlib.h>
#include<assert.h>
using namespace std;
typedef int STDateType;
typedef struct Stack
{
	STDateType* a;
	int top;
	int capacity;
}ST;
void Push(ST* ps, STDateType x)
{
	assert(ps);
	if (ps->capacity == 0)
	{
		
		STDateType* b = (STDateType*)malloc(sizeof(STDateType) * 4);
		if (b == NULL)
		{
			perror("malloc");
			exit(0);
		}
		ps->capacity = 4;
		ps->a = b;
	}
	if ( ps->top  == ps->capacity)
	{
		STDateType newcapacity = 2 * ps->capacity;
		STDateType* b = (STDateType*)realloc(ps->a, newcapacity*sizeof(STDateType));
		if (b==NULL)
		{
			perror("relloc");
			exit(0);
		}
		ps->a = b;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

上面是原来的代码，下面是用引用的代码 

void Push(ST& ps, STDateType x)
{
	if (ps.capacity == 0)
	{

		STDateType* b = (STDateType*)malloc(sizeof(STDateType) * 4);
		if (b == NULL)
		{
			perror("malloc");
			exit(0);
		}
		ps.capacity = 4;
		ps.a = b;
	}
	if (ps.top == ps.capacity)
	{
		STDateType newcapacity = 2 * ps.capacity;
		STDateType* b = (STDateType*)realloc(ps.a, newcapacity * sizeof(STDateType));
		if (b == NULL)
		{
			perror("relloc");
			exit(0);
		}
		ps.a = b;
		ps.capacity = newcapacity;
	}
	ps.a[ps.top] = x;
	ps.top++;
}

这里我只是将每一个结构体取了别名，所以可以直接改变里面的数据 

 3.>指针变量也是可以取别名的。

#include<iostream>
using namespace std;
typedef int SLTDataType;//便于适用于其他的类型如char float 等
typedef struct SListNode
{
	SLTDataType data; //节点数据 
	struct SListNode* next; //指针保存下⼀个节点的地址 
}SLTNode;
//SLTNode* a = (SLTNode*)malloc(sizeof(SLTNode));//为链表扩展一个空间，相当于火车的一节
//链表的初始化
void  SLInit(SLTNode**pphead)
{
	if (pphead)                //判断链表头是否为NULL，如果为NULL，则不可以解引用
	{
		(*pphead)->data = 0;
		(*pphead)->next = NULL;
	}
}

上面是原来的代码，下面是用引用的代码 

//链表的初始化
void  SLInit(SLTNode*& pphead)
{
	if (pphead)                //判断链表头是否为NULL，如果为NULL，则不可以解引用
	{
		(*pphead).data = 0;
		(*pphead).next = NULL;
	}
}

这里我们用引用就可以让二级指针改变。

这里创建单链表的时候的每一节车厢，我都是用指针来指向这一节车厢，如果我要改变里面的数据的话，我就要用到二级指针，但是我这里用引用的话，我就相当于给每一节车厢取别名，所以我才可以改变 

如果对我说的车厢有疑问，可以看一看这一篇博客

C++——单链表的详细讲解_c++单链表-CSDN博客

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++中把这个未命名对象叫做临时对象

 这里就出现了权限放大的问题，b是a的别名，我们用的区域是一样的，但是a已经用const限制了，他是一个常数，不可以改变值，但是b没有const限制，所以b是一个变量，可以改变值，所以发生了冲突，引发权限放大。（权限的放大是对引用而言的）

解决的方法：

const int a = 10;
const int& b = a;

int a = 10;
int& b = a;

当然还有一种情况：

这样不会出现问题 ，也就是说明权限可以缩小但是不可以放大。

这里便是上面讲解的当发生转换或者a*3的情况时，会出现临时变量，这个变量是常数，所以发生了权限的放大 

 解决方法：

int a = 10;
const int& b = a * 3;
const double& c = a;

5.指针与引用的关系

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

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

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

• 引用在初始化时引用⼀个对象后，就不能再引用其他对象；而指针可以在不断地改变指向对象。 • 引用可以直接访问指向对象，指针需要解引用才是访问指向对象。

• sizeof中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下 占4个字节，64位下是8byte) • 指针很容易出现空指针和野指针的问题，引用很少出现，引用使用起来相对更安全⼀些。 

四.内联函数

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

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

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

• inline不建议声明和定义分离到两个文件，分离会导致链接错误。因为inline被展开，就没有函数地址，链接时会出现报错。

inline int Add(int x, int y)
{
int ret = x + y;
ret += 1;
ret += 1;
ret += 1;
return ret;
}

五.nullptr 

1.NULL实际是⼀个宏，他的代码：

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

C++中NULL可能被定义为字面常量0，或者C中被定义为无类型指针(void*)的常量。不论采取何种 定义，在使用空值的指针时，都不可避免的会遇到⼀些麻烦。

#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);
	return 0;
}

这个代码在vs2019的程序中，只会运行出参数为int的类型的函数，而不会运行int*的函数，会出现。f((void*)NULL); 调用报错。 

2.引入nullptr 

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