引用类型与函数

引用类型的定义与使用

引用时已有变量或表达式的一种别名机制，主要用于函数的参数和返回值。

引用定义时必须初始化。初始化后不能再指向其他的变量。

引用的本质上是在C++内部实现一个指针常量。

	int a = 10;
	
	//	定义引用b并初始化为a; 
	int& b = a;

	//	b是a的别名,通过b可以访问到a的值
	cout << "b: " << b << endl;

	//	a的值发生改变，b的值也会改变；b的值发生改变,a的值也会改变。
	b++;
	cout << "b: " << b << " a: " << a << endl;
	a++;
	cout << "b: " << b << " a: " << a << endl;

	int c = 20;
	//	把c的值赋给b。
	b = c;
	cout << "b: " << b << " a: " << a << endl;

函数

在程序设计时，如果一段代码重复进行某个操作或完成特定的功能，则将这样的代码组织称为函数。

/*
	函数的定义
		函数定义由函数类型、函数名和函数参数组成，称为函数头。函数名要满足标识符命名规则。  
		由两个大括号括起来的语句组称为函数体。  
	函数类型与返回值
		函数可以有返回值也可以没有返回值。
		有返回值时，函数类型就是返回值的类型；没有返回值时，函数类型是void。
		函数类型可以是C++支持的任意类型。
	函数参数
		形参（形式参数），定义函数时，括号中的参数。
		实参（实际参数），调用函数时，括号中的参数。	
*/

int mySum(int n)  // n是形参
{
	int sum = 0;
	for (int i = 1; i <= n; i++)
	{
		sum += i;
	}
	
	return sum;
}

void myShow()	 // 函数可以没有返回值，此时函数类型时void
{

	cout << "Hello!" << endl;	
	
}

//	求两个书中较大的值
int myMax(int a, int b);

int main()
{
	int n = 5;
	//	函数调用
	int m = mySum(n); // n是实参
	cout << "m: " << m << endl;	
	
	cout << max(10, 20) << endl;
	cout << max(20, 10) << endl;
	return 0;
}

int myMax(int a, int b)
{
	if (a > b)
	{
		return a;
	}
	return b;
}

函数的参数传递

在函数调用时，系统为形参分配内存单元，并将实参的值传到形参的单元中。根据函数功能的需要，函数参数可以选择数值，指针或引用三种形式之一。

数值作为函数的参数传递给函数时，实参与形参占用不同的存储单元，实参的值赋给形参。

void mySwap(int a, int b);

int main()
{
	int a = 10, b = 20;
	mySwap(a, b);
	cout << "main a: " << a << " b: " << b << " &a: " << &a << " &b: " << &b << endl;		
	return 0;
}

void mySwap(int a, int b)
{
	int tmp = a;
	a = b;
	b = tmp;
	cout << "mySwap a: " << a << " b: " << b << " &a: " << &a << " &b: " << &b << endl;
}

指针作为函数的参数，传递的是变量的地址。

void mySwap(int* p1, int* p2);

int main()
{
	int a = 10, b = 20;
	int* p1 = &a, * p2 = &b;
	cout << "main a: " << a << " b: " << b << " &a: " << &a << " &b: " << &b << " &p1: " << &p1 << " &p2: " << &p2 << endl;
	mySwap(p1, p2);
	cout << "main a: " << a << " b: " << b << " &a: " << &a << " &b: " << &b << " &p1: " << &p1 << " &p2: " << &p2 << endl;

	return 0;
}

void mySwap(int* p1, int* p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
	cout << "mySwap： &p1" <<  &p1 << " &p2: " << &p2 << endl;
}

引用作为函数的参数，传递的是变量的地址。

void mySwap(int& a, int& b);

int main()
{
	int a = 10, b = 20;
	mySwap(a, b);	
	return 0;
}

void mySwap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;	
}

数组作为函数的参数和返回值：数组名作为参数时，传递的数组的首地址。

//	数组名作为参数时，传递的数组的首地址。
void func1(int* a, int len);

//	数组名作为参数时，形参也可以写成: 数组类型 形参名[]
void func2(int a[], int len);

void show(int* a, int len);

int main()
{
	int a[5] = { 1, 2, 3, 4, 5 };
	//	数组名作为参数时，传递的数组的首地址。
	func1(a, 5);
	show(a, 5);
	//	func1(a[3], 2); func1的第一个参数是整型指针，不能传入整型数据

	//	func1的第一个参数也允许传入某个数组元素的地址
	func1(&a[3], 2);
	show(a, 5);

	func2(a, 5);
	show(a, 5);
	func2(&a[3], 2);
	show(a, 5);

	return 0;
}

void func1(int* a, int len)
{
	for (int i = 0; i < len; i++)
	{
		a[i] += 1;
	}
}

void func2(int a[], int len)
{
	for (int i = 0; i < len; i++)
	{
		a[i] += 1;
	}
}

void show(int* a, int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << a[i] << ", ";
	}
	cout << endl;
}

C++中函数不能直接返回一个数组，但是可以通过指针来实现返回一个数组。

int* func1();
void show(int* a, int len);

int main()
{
	int* a = func1();
	show(a, 15);
	
	delete[]a;
	return 0;
}

int* func1()
{
	//int a[15] = { 1, 2, 3, 4, 5 };
	int* a = new int[15] ;
	for(int i = 0; i < 5; i++) 
	{ 
		a[i] = i;
	}
		
	show(a, 15);
	return a;
}

void show(int* a, int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << a[i] << ", ";
	}
	cout << endl;
}

变量的生命周期

变量的作用范围

局部变量

函数内部定义的变量（也称为局部变量），只在函数范围内有效。

全局变量

函数外部定义的变量称为全局变量，在程序运行过程中有效。

在一段程序中，如果出现同名的全局和局部变量，则优先访问局部变量。

//	全局变量
int i = 100;

void func();

int main()
{
	//	局部变量
	int i = 20;
	func();
	//	当存在和全局变量同名的局部变量时，使用局部变量
	cout << "main i: " << i << endl;
	//	当存在和全局变量同名的局部变量时，可以通过 ::变量名 使用全局变量
	cout << "main ::i: " << ::i << endl;
	return 0;
}

void func()
{
	//	使用全局变量
	cout << "func i: " << i << endl;
	i++;
}

变量的存储类别

动态存储方式，在程序执行过程中，根据需要动态分配存储空间。

静态存储方式，在程序运行期间，分配固定的存储空间并且一直存在。

有static关键字的变量，是静态存储的。

int func(int n);

int main()
{
	cout << func(1) << endl;
	cout << func(2) << endl;
	cout << func(3) << endl;
	cout << func(0) << endl;
	cout << func(10) << endl;
	return 0;
}


int func(int n)
{
	static int f = 1;
	f *= n;
	return f;
}