c++——引用、const关键字、动态分配内存、内联函数、函数重载、参数缺省值

定义一个引用，并将其初始化为引用某个变量。

类型名  &引用名  =某变量名；

int  &r=n;//r引用了n，r的类型是 int &

某个变量的引用，等价于这个变量，相当于该变量的一个别名。

引用的概念

1.定义引用时一定要将其初始化成引用某个变量。

2.初始化后，它就一直引用该变量，不会在引用别的变量了。

3.引用只能引用变量，不能引用常量和表达式。

引用可以作为函数的返回值。

常引用

定义引用时，前面加const关键字，即为“常引用”

int n;

const int &r=n;

r的类型是 const int &;

不能通过常引用去修改其引用的内容；

const T&和T &是不同的类型！！！

T&类型的引用或T类型的变量可以用来初始化const T&类型的引用。

const T类型的常变量 和const T&类型的引用则不能用来初始化T &类型的引用，除非进行强制类型转换。

const  关键字的作用

int n,m;

const int *p=&n;

不能通过常量指针修改其指向内容。

不能把常量指针赋值赋给非常量指针，反过来可以

动态分配内存——

1. 使用new来为一个变量分配空间

p=new  T;

T是任意类型名，p是类型为T*的指针，分配了内存为sizeof(T)大小的空间，将内存的起始地址赋给p。

2.分配一个数组

P=new T[n];

T是任意类型名；P类型为T*的指针；

要分配的数组元素的个数，可以是整型表达式

new运算符的返回值类型：T*;

用delete运算符释放动态分配的内存

delete 指针；//该指针必须指向new出来的空间

//一片空间不能被delete多次。

delete运算符释放动态分配的数组

delete []指针；//该指针必须指向new出来的数组

 内联函数

函数调用是有时间开销的。如果函数本身只有几条语句，执行非常快，而且函数被反复执行很多次，相比之下调用函数 所产生的这个开销就会显得比较大。

为了减少函数调用的开销，引入了内联函数机制。编译器处理对内联函数的调用语句时，是将整个函数的代码插入到调用的语句处，而不会产生调用函数的语句。

在函数定义前面加"inline" 可定义内联函数。

函数重载

一个或多个函数，名字相同，然而参数个数或参数类型不相同，这叫做函数的重载。

函数重载使得函数命名变得简单。

编译器根据调用语句中实参的个数和类型半段应该调用哪个函数。

函数的缺省参数

c++中，定义函数的时候可以让最右边的连续若干个参数有缺省值，那么调用函数的时候，若在相应位置不写参数，参数就是缺省值。

函数参数可缺省的目的在于提高程序的可扩充性。

即如果某个写好的函数要调价新的参数，而原先那些调用该函数的语句，未必需要使用新增的参数，那么为了避免对原先那些函数调用语句的的修改，就可以使用缺省参数。

课后测验题

1.简单的swap

#include <iostream>
using namespace std;
class A
{
	public:
	int x;
	int getX() { return x; }	
};

void swap(A &a, A &b)// 在此处补充你的代码
{
	int  tmp = a.x;
	a.x = b.x;
	b.x = tmp;
}
int main()
{
	A a,b;
	a.x = 3;
	b.x = 5;
	swap(a,b);
	cout << a.getX() << "," << b.getX();
	return 0;
}

2.难一点的swap

#include <iostream>
using namespace std;
void swap(int * &a,int * &b)//在此处补充你的代码 
{
	int * tmp = a;
	a = b;
	b = tmp;
}
int main()
{
	int a = 3,b = 5;
	int * pa = & a;
	int * pb = & b;
	swap(pa,pb);
	cout << *pa << "," << * pb;
	return 0;
}

3.好奇怪的返回值

#include <iostream>
using namespace std;
// 在此处补充你的代码
int &
//end
getElement(int * a, int i)
{
	return a[i];
}
int main()
{
	int a[] = {1,2,3};
	getElement(a,1)=10;
	cout << a[1] ;
	return 0;
}

4.神秘的数组初始化

#include <iostream>
using namespace std;
int main()
{
	int * a[] = {0,0,new int[6],new int[6]	
// 在此处补充你的代码
};

	*a[2] = 123;
	a[3][5] = 456;
	if(! a[0] ) {
		cout << * a[2] << "," << a[3][5];
	}
	return 0;
}