C++的一些简单特性扩展

C++的一些简单特性扩展

引用

引用的基本用法

引用的基本用法：

类型名 & 引用名 = 某变量名；
int n = 4;
int & r = n;

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

引用使用时必须注意：

1. 定义时一定要将引用初始化为引用某个变量
2. 引用一旦定义完成不能够再引用别的变量
3. 引用只能变量，不能引用常量和表达式

引用的简单示例：

int a = 4, b = 5;
void swap(int & a, int & b)
{
	int temp;
	temp = a; a = b; b = temp;
}
swap(a, b); //a, b被交换

引用作为函数返回值

int n = 4;
int & SetValue()
{
	return n;
}

int main()
{
	SetValue() = 40;
	cout<< n << endl;
	return 0;
	// 输出40
}

常引用

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

不能通过常引用改变其引用的内容

int n;
const int & r = n; //r类型为常引用
r = 200; //编译出错
n = 300; //没问题

常引用与非常引用的转换

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

const关键字

基本用法

1. 定义常量

const int MAX_VAL = 23;
const string SCHOOL_NAME = "Peking University";

2. 定义常量指针

不可以通过常量指针修改其指向的内容

int n, m;
const int * p = &n;
*p = 5;	//编译出错
n = 4;	//没问题
p = &m;	//没问题，指针指向可以发生变化

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

const int * p1;
int * p2;
p1 = p2; //ok
p2 = p1;	//error
p2 = (int * )p1;	//ok,强制类型转换

函数参数为常量指针时，可避免函数内部不小心改变参数指针所指地方的内容

void MyPrintf( const char * p )
{
	strcpy( p,"this"); //编译出错
	printf("%s",p); //ok
}

动态内存分配

new

分配一个变量

P = new T;

T是任意类型名，p是类型为T*的指针。

分配一个数组

P = new T[N];

T ：任意类型名

P：类型为T*的指针

N：整型或者整型表达式

delete

new与delete一定要配合使用

delete释放一个变量的内存空间

delete p;

delete释放一片内存空间

delete []p;

内联函数

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

内联函数定义的基本机制

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

在函数前添加关键字inline即可

函数重载

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

函数重载示例

int Max(double f1, double f2)	{ } //1
int Max(int n1, int n2)	{ } //2
int Max(int n1, int n2, int n3)	{ } //3

Max(3.24, 2.5);	//调用1
Max(2, 4); //调用2
Max(1, 2, 3); //调用3
Max(3, 2.4); //error, 二义性

函数重载必须：参数数量不同或者参数类型不同

函数缺省参数

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

函数缺省参数示例

void func(int x1, int x2 = 2, int x3 = 3)	{ };
func(10);	//等效于func(10,2,3)
func(10,8);	//等效于func(10,8,3)
func(10, , 8);	//错误，只能最右边的连续若干个参数缺省

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

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