C++那些你不得不知道的（2）

C++那些你不得不知道的（2）

1、缺省参数在使用的遍历

（1）以下是实现顺序表的初始化和检查容量空间的方式：

void Init(list* ps)
{
	ps->arr = NULL;
	ps->Capacity = ps->size = 0;
}

void CheckCapacity(list* ps)
{
	assert(ps);
	if (ps->size == ps->Capacity)
	{
		std::cout << "扩容" << std::endl;
		int newCapacity = ps->Capacity == 0 ? 4 : 2 * ps->Capacity;
		int* temp = (int*)realloc(ps->arr, sizeof(int) * newCapacity);
		if (temp == NULL)
		{
			perror("malloc fail!");
			exit(1);
		}
		ps->Capacity = newCapacity;
		ps->arr = temp;
	}
}

我们知道：多次扩容会消耗内存空间和时间，造成程序的效率低下！

（2）引入C++的缺省参数之后的改良代码：

typedef struct list
{
	int* arr;
	int size;
	int Capacity;
}list;

void Init(list* ps,int size=4)
{
	ps->arr = (int*)calloc(sizeof(int) ,size);
	ps->Capacity = size;
	ps->size = 0;
}

void CheckCapacity(list* ps)
{
	assert(ps);
	if (ps->size == ps->Capacity)
	{
		std::cout << "扩容" << std::endl;
		int newCapacity = ps->Capacity == 2 * ps->Capacity;
		int* temp = (int*)realloc(ps->arr, sizeof(int) * newCapacity);
		if (temp == NULL)
		{
			perror("realloc fail");
			exit(1);
		}
		ps->Capacity = newCapacity;
		ps->arr = temp;
	}
}

void listpush(list* ps, int x)
{
	assert(ps);
	CheckCapacity(ps);
	ps->arr[ps->size++] = x;
}

void test01()
{
	list s;
	Init(&s, 100);
	for (int i = 0 ; i < 100; i++)
	{
		listpush(&s, i);
	}
	
}

通过缺省参数的使用，我们就避免了多次动态开辟内存空间造成的缓存浪费和效率低下问题!

2、函数重载及其作用

（1）函数重载的定义：

C++支持在同一作用域中出现同名函数，但是要求这些同名函数的形式参数（形参）不同----（形式参数的类型不同/参数个数不同）。 例如：

#include<iostream>

void Swap(int* x,int* y)
{
	int temp=*x;
	*x=*y;
	*y=temp;
}

void Swap(double* x,double* y)
{
	double temp=*x;
	*x=*y;
	*y=temp;
}

int main()
{
	int a=0,b=1;
	double c=0.2,d=1.5;
	Swap(&a,&b);
	Swap(&c,&d);
	return 0;
}

在这里，我们使用了同名函数Swap,但是函数的参数类型不同：一个参数为Swap(int* x,int* y)，一个参数为Swap(double* x,double* y)。这样，我们就不用为Swap取其他函数名，能够使代码的可读性提高！！！

（2）函数重载的类型：

①参数类型不同

②参数个数不同

③参数类型顺序不同（本质还是参数类型不同）

！！！注意：返回值不同不能作为重载条件（因为调用时无法区分）

下面举例虽然满足函数重载条件，但是使用起来有歧义的代码：

#include<iostream>

void f()
{
	std::cout<<"f()"<<std::endl;
}

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

int main()
{
	f();
	return 0;
}

这里调用的时候就会出现歧义，编译器无法分辨出该调用哪个函数，造成歧义，报错！

3、引用

（1）引用的概念和定义：引用是给一个已存在的变量取一个别名，编译器不会为引用变量重新开辟空间，而是与引用变量共用一块内存空间。

（2）形象表示：引用相当于水浒传中林冲的别名是“豹子头”一样，其真实的名字都是林冲这个人！

（3）引用方法：类型 & 引用别名 = 引用对象。 例如：

#include<iostream>

int main()
{
	int a=10;
	int& b=a;
    std::cout<<&a<<std::endl;
    std::cout<<&b<<std::endl;
}

这里的b和a共用一块内存空间，即a的别名是b,a和b的地址空间一样！！!

如果大家喜欢这篇文章，欢迎品读，留言，点赞，谢谢！！！

#include<iostream>

int main()
{
	int a=10;
	int& b=a;
    std::cout<<&a<<std::endl;
    std::cout<<&b<<std::endl;
}

这里的b和a共用一块内存空间，即a的别名是b,a和b的地址空间一样！！!

如果大家喜欢这篇文章，欢迎品读，留言，点赞，谢谢！！！