从C到C++

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