从C到C++
引用
1、类型名 & 引用名 = 某变量名;
例:
int n = 4;
int & r = n;
2、
- 定义引用时一定要将其初始化成引用某个变量。
- 初始化后,它就一直引用该变量,不会再引用别的变量了。
- 引用只能引用变量,不能引用常量和表达式。
double a = 4, b = 5;
double & r1 = a;
double & r2 = r1; // r2 也引用 a
r2 = 10;
cout << a << endl; // 输出 10
r1 = b; // r1 并没有引用 b
cout << a << endl; // 输出 5
3、常引用
- 定义引用时,前面加const关键字,即为“常引用”。
例:
int n = 4;
const int & r = n; // r的类型是 const int &
- 不能通过常引用去修改其引用的内容。
- const T & 和T & 是不同的类型
T & 类型的引用或T类型的变量可以用来初始化const T & 类型的引用。
const T 类型的常变量和const T & 类型的引用则不能用来初始化T &类型的引用,除非进行强制类型转换。
“const”关键字
1、定义常量
const int MAX_VAL = 23 ;
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, 强制类型转换
- 函数参数为常量指针时,可避免函数内部不小心改变
参数指针所指地方的内容
动态内存分配
1、用new 运算符实现动态内存分配
- 第一种用法,分配一个变量:
P = new T;
T是任意类型名,P是类型为T * 的指针
例:
int * pn;
pn = new int;
* pn = 5;
- 第二种用法,分配一个数组:
P = new T[N];
T :任意类型名
P :类型为T * 的指针
N :要分配的数组元素的个数,可以是整型表达式
例:
int * pn;
int i = 5;
pn = new int[i * 20];
2、用delete运算符释放动态分配的内存
- 用“new”动态分配的内存空间,一定要用“delete”运算符进行释放
- delete 指针;//该指针必须指向new出来的空间
int * p = new int;
* p = 5;
delete p;
delete p; //导致异常,一片空间不能被delete多次
- 用“delete”释放动态分配的数组,要加“[]”
int * p = new int[20];
p[0] = 1;
delete [ ] p;
内联函数
inline int Max(int a,int b)
{
if( a > b) return a;
return b;
}
函数重载
一个或多个函数,名字相同,然而参数个数或参数类
型不相同,这叫做函数的重载。
(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,二义性
函数的缺省参数
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) ; //不行,只能最右边的连续若干个参数缺省