C++学习_从C到C++

一、引用的概念和应用

---

 1.引用的概念

下面写法定义了一个引用，并将其初始化为引用某个变量。
		类型名 & 引用名 = 某变量名;
		int n = 4;
		int & r = n; // r引用了n，r的类型是 int &
某个变量的引用，等价于这个变量，相当于该变量的一个别名。　　

代码示例：

// 课堂练习
# include <iostream>
using namespace std;

int main(void)
{
	int n = 7;
	int & r = n;
	r = 4;
	cout<<r<<" "<<n<<endl; // 输出 4 4 
	n = 5;
	cout<<r<<" "<<n<<endl; // 输出 5 5 
	return 0;
} 

注意点： 1. 定义引用时一定要将其初始化为引用某个变量。
　　　　 2. 初始化以后，从一而终，不会再引用别的变量。
　　　　 3. 引用只能引用变量，不能引用常量和表达式。

代码示例：

// 课堂练习
# include <iostream>
using namespace std;

int main(void)
{
	double a = 4, b = 5;
	double & r = a; // r引用 a 
	double & p = r; // 这时候 p 也引用了 a
	p = 10;
	cout<<a<<" "<<r<<" "<<p; // 输出 10 10 10  
	r = b; // 这句话并不代表r重新引用b，而是把 b值赋值给r  
	cout<<a<<" "<<r<<" "<<p; // 输出 5 5 5  
	 
	return 0;
} 

课堂习题：　

下面程序片段输出结果是什么？
	int a = 1,b = 2;
	int & r = a;
	r = b;
	r = 7;
	cout << a << endl;

2. 引用应用的简单示例

2.1 引用作为函数的参数

C语言中如何交换两个整型变量的值？
void swap(int * a, int * b)
{
	int temp;
	temp = *a; *a=*b; *b=temp;
}
int n1, n2;
swap(&n1, &n2); // n1 n2 的值被交换
 
有了C++的引用：

void swap(int & a, int & b)
{
	int temp;
	temp = a; a=b; b=temp;
}
int n1, n2;
swap(n1, n2); // n1 n2 的值被交换

2.2 引用作为函数的返回值　　

// 课堂练习
# include <iostream>
using namespace std;
int n = 4;
int & SetValue()
{
	return n;
}
int main(void)
{
	SetValue() = 40; // 将40的值赋值给SetValue()函数的返回n 
	cout<<n; // 输出40 
	return 0;
} 

2.3 常引用　

定义引用时，前面加const关键字，即为“常引用”
int n;
const int & r = n; // r 的类型是const int &
不能通过常引用去修改其引用内容。
int n = 100;
const int & r = n;
r = 200; // 编译错
n = 300; // 没问题

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

const T & 和 T & 是不同的类型！
T &类型的引用或者T类型的变量可以用来初始化const T &类型的引用。

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

二、const关键字

---

 0) 定义常引用 （在引用处已经讲过，不再赘述）

1) 定义常量

const int MAX_VAL = 23;
const double Pi = 3.14;
const char * SCHOOL_NAME = "PKU";

2) 定义常量指针

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

int n, m;
const int * p = &n; 
* p = 5; // 试图通过指针修改指向内容， 编译出错
n = 4; // ok 指向的内容本身是可以修改的
p = &m; // ok 常量指针的指向可以发生变化

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

const int * p; // 常量指针
int * q; // 非常量指针
p = q; // ok
q = p; // error 企图把常量指针赋值给非常量指针
q = (int *)p; //ok 强制类型转化

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

// 课堂练习
# include <iostream>
# include <string.h>
using namespace std;

void MyPrintf(const char * p)
{
	strcpy(p,"123"); // 编译出错 
	// 因为strcpy()函数的第一个参数是 char * 非常量指针
	// 而定义的 P 是一个常量指针，所以，赋值过程会报错 
	printf("%s",p);  // ok
}

int main(void)
{
	char ch[5] = {"0123"};
	const char * q = ch;
	MyPrintf(q);
	return 0;
} 　　

课堂习题：

下面说法哪种是对的？
A） 常引用所引用的变量，其值不能被修改
B） 不能通过常量指针，去修改其指向的变量
C） 常量指针一旦指向某个变量，就不能再指向其他变量
D)  以上都不对

三、动态内存分配

---

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

1.1) 用new 分配一个变量

P = new T;
T 是任意的类型名，P是类型为T * 的指针。
动态分配出一片大小为sizeof(T)字节的内存空间，并且将该内存空间的起始地址赋值给P。

代码示例：

// 课堂练习
# include <iostream>
using namespace std;

int main(void)
{
	 int * p;
	 p = new int; // 给P指针分配内存
	 *p = 5;
	 cout<<*p;
	  
	return 0;
} 

课堂习题：

表达式 “new int”的返回值类型是：
A) int
B) int *
C) int &
D) void

1.2) 分配一个数组

P = new T[N];
T: 任意类型名
P: 类型为T * 的指针
N：要分配的数组元素的个数
动态分配出一片大小为N*sizeof(T)字节的内存空间，并且将该内存空间的起始地址赋值给P。

代码示例：

// 课堂练习
# include <iostream>
using namespace std;

int main(void)
{
	int * p;
	p = new int[20];
	p[10] = 5;
	cout<<p[10]; // 输出5 
	  
	return 0;
} 

1.3) new 运算符的返回值类型

new T;
new T[N];
均返回T*类型

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

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

delete 指针; // 该指针必须指向new出来的空间
int * p = new int;
* p = 5;
delete p;
delete p; // error,不能delete两次

代码示例：

// 课堂练习
# include <iostream>
using namespace std;

int main(void)
{
	int * p = new int;
	*p = 5;
	cout<<*p<<endl; // 输出5 
	delete p;
	cout<<*p<<endl; // 输出结果不为 5，空间已经被释放 
	return 0;
} 

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

delete [] 指针; // 该指针必须指向new出来的数组
int * p = new int[20];	
p[0] = 1;
delete [] p;	

代码示例：　

// 课堂练习
# include <iostream>
using namespace std;

int main(void)
{
	int * p = new int[20];
	p[10] = 5;
	cout<<p[10]<<endl; // 输出5 
	printf("%p\n",p[10]); // 输出p[10]的地址 
	delete [] p;	
	cout<<p[10]<<endl; // 输出5，空间已经被释放 
	printf("%p\n",p[10]); // 输出p[10]的地址
	delete [] p; // 再次delete编译不会报错，但是程序无法继续执行	
	cout<<p[10]<<endl; // 无输出
	printf("%p\n",p[10]); // 无输出
	return 0;
} 

课堂习题：

下面小段程序，哪个是正确的：
A) char * p = new int; 
		p = 'a';  
		delete p;
B) int *p = new int[25]; 
   p[10] = 100; 
   delete p;
C) char * p = new char[10];       
   p[0] = 'K'; 
   delete [] p;
D) 都不对?
		 

四、动态内存分配

---

1. 内联函数 

　　 函数调用是有时间开销的。
　　如果函数本身只有几条语句，执行非常快，而且函数被反复执行很多次，相比之下调用函数所产生的这个开销就会显得比较大。
　　为了减少函数调用的开销，引入了内联函数机制。
　　编译器处理对内联函数的调用语句时，是将整个函数的代码插入到调用语句处，而不会产生调用函数的语句。

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

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

2. 函数重载

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

以下三个函数是重载关系：
int Max(double f1,double f2) { }
int Max(int n1,int n2) { }
int Max(int n1,int n2,int n3) { }

　　函数重载使得函数命名变得简单。编译器根据调用语句的中的实参的个数和类型判断应该调用哪个函数。

具体使用：

(1) int Max(double f1,double f2) { }
(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) ; //不行,只能最右边的连续若干个参数缺省

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

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

课堂例题：

下面说法正确的是：
A) 多个重载函数的参数个数必须不同。
B) 两个函数，参数表相同，返回值类型不同，它们是重载关系。
C) 调用一个第二个和第三个参数都有有缺省值的函数时，可以不写第二个实参而写第三个实参。
D) 使用内联函数的目的是提高程序的运行速度。

RRR