从C到C++

一.引用的概念

下面的写法定义了一个引用，并将其初始化为引用某个变量。

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

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

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

#include <iostream>
using namespace std;
int main()
{
	int n = 7;
	int & r = n;
	r = 4;
	cout << r << endl;		//输出4
	cout << n << endl;		//输出4
	n = 5;
	cout <<r<< endl;		//输出5
	cout << n << endl;		//输出5
}

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

初始化后，他就一直引用该变量，不会再引用别的变量了。

引用只能引用变量；不能引用常量和表达式。

#include <iostream>
using namespace std;
int main()
{
	double a = 4,b=5;
	double & r1 = a;
	double & r2 = r1;
	r2 = 10;
	cout << a << endl;		//输出10
	r1 = b;
	cout << a << endl;		//输出5
}

引用应用的简单示例

C语言中，如何编写交换两个整型变量值的函数？

#include <iostream>
using namespace std;
void swap(int a, int b)
{
	int tmp;
	tmp = a; 
	a = b; 
	b = tmp;

}
int main()
{
	int n1, n2;
	cin >> n1>> n2;
	swap(n1, n2);

	cout << n1 << endl;
	cout << n2 << endl;			//n1,n2的值不会被交换
}

n1,n2的值不会被交换

void swap(int a, int b)  //因为这是“形参”

	cin >> n1>> n2;		//这是“实参

形参不会影响实参的值。

解决方法：

        利用指针： *

void swap(int * a, int * b)  
{
	int tmp;
	tmp = * a; 
	* a = * b; 
	* b = tmp;

}

这时，n1,n2的值会被交换：    swap(& n1, & n2);    //参数变成了n1，n2的地址  &

	swap(& n1, & n2);		//n1,n2的值会被交换

	cout << n1 << endl;		//输出6
	cout << n2 << endl;		//输出5	

有了C++的引用：

#include <iostream>
using namespace std;
void swap(int & a, int & b)  
{
	int tmp;
	tmp =  a; 
	 a =  b; 
	b = tmp;
}
int main()
{
	int n1, n2;
	cin >> n1>> n2;		
	swap(n1, n2);			//n1,n2的值会被交换

	cout << n1 << endl;		//输出6
	cout << n2 << endl;		//输出5	
}

引用作为函数的返回值：

#include <iostream>
using namespace std;
int n;
int & SetValue()
{
	return n;
}
int main()
{
	SetValue() = 40;
	cout << n<< endl;		//输出40
    return 0;
}

常引用：

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

int n;
const int & r=n;

r的类型是：const int &

不能通过常引用取修改其引用的内容：

int n=100;
const int & r=n;
r=200;    //编译出错
n=300;    //编译没问题

常引用和非常引用的转换：

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

二.const关键字

1.定义常量

2.定义常量指针

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

int n, m;
	const int * p = &n;
	*p = 5;    //编译出错
	n = 4;     //OK
	p = &m;    //OK，常量指针的指向可以变化

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

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
}

strcpy为string copy的类型是char型，strcpy(p,"this"); 其中p是const char型

3.定义常引用

不能通过常引用修改其引用的变量

int n;
const int & r=n;
r=5;    //error
n=4;    //ok

三.动态内存分配

用new运算符实现动态内存分配

第一种用法，分配一个变量：

    P=new T;

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

  动态分配出一片大小为sizeof(T)字节的内存空间，并且将改内存空间的起始地址赋值给P。比如：

int * pn;
pn=new int;
* pn=5;    //pn的类型是int *

第二种用法，分配一个数组：

    P=new T[N];

T:任意类型名

P：类型为T *的指针

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

        动态分配出一片大小为N * sizeof(T)字节的内存空间，并且将改内存空间的起始地址赋值给P

动态分配数组示例：

int * pn;
int i=5;
pn = new int[i * 20];
pn[0]=20;    //访问下标为0的元素的值为20
pn[100]=30;   //访问下标为0的元素的值为100       //编译没问题。运行时导致数组越界

因为是从0开始到100是101个元素，前面定义的值是100个元素，所以可能导致错误。

new运算符的返回值类型：

new T;
new T[N];

这两个表达式的返回值的类型都是 T *

int * p=new int;

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

用"new"动态分配的内存空间，一定要用"delete"运算符进行释放

delete 指针;        //改指针必须指向new出来的空间

int * p = new int;
* p = 5;
delete p;
delete p;    //导致异常，一片空间不能被delete多次

用"delete"释放动态分配的数组，要加"[ ]"

delete [ ] 指针;        //改指针必须指向new出来的数组

int * p = new int [20];
p[0] = 1;
delete []P;    //回收P内存空间

四.内联函数，函数重载和函数缺省参数

 1.内联函数

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

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

        

        在函数定义前面加“inline”关键字，即可定义内联函数
 

inline int Max(int a,int b)    //优点：inline提高函数效率    
                               //缺点：可执行程序的体积会增大
{
    if(a > b) 
    {
        return a;
    }else{
        return b;
    }
}

 2.函数重载

        一个或多个函数，名字相同，然而参数个数或参数类型不相同，这叫做函数的重载。
以下三个函数是重载关系:

int Max(double f1,double f2)    //Max of two double 
{
    
}
int Max(int n1,int n2)    //Max of two int
{

}
int Max(int n1,int n2,int n3)    //Max of three int
{

}

优点：

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

(2)编译器根据调用语句的中的实参的个数和类型判断应该调用哪个函数。

//(1)
int Max(double f1,double t2)
{

}
//(2)
int Max(int n1,int n2)
{

}
//(3)
int Max(int n1,int n2,int n3)
{

}

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

3.函数的缺省参数:

        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);    //不行,只能最右边的连续若干个参数缺省

优点：

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

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