C++笔记——引用、指针及动态内存分配

1、引用的概念

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

定义引用时一定要将其初始化成引用某个变量。
初始化后，它就一直引用该变量，不会再引用别的变量了。
引用只能引用变量，不能引用常量和表达

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

2、常引用

定义引用时，前面加const关键字，即为“常引用”，不能通过常引用去修改其引用的内容。

int n = 100;
const int & r = n;     //r 的类型是 const int &
r = 200;               // 编译错
n = 300;               // 没问题

3、常引用和非常引用的转换

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

（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
}

（3）定义常引用

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

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

（1）分配一个变量: P = new T

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

int * pn;
pn = new int;
* pn = 5;

（2）分配一个数组：P = new T[N]

N :要分配的数组元素的个数，可以是整型表达式
动态分配出一片大小为 sizeof(T)*N字节的内存空间，并且将该内存空间的起始地址赋值给P。

int * pn;
int i = 5;
pn = new int[i * 20];
pn[0] = 20;
pn[100] = 30;        //编译没问题。运行时导致数组越界

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

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

int * p = new int;
int * f = new int[20];
* p = 5;
delete [ ] p;      //释放动态分配的数组，要加“[]”
delete p;
delete p;          //导致异常，一片空间不能被delete多次

6、内联函数

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

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

7、函数重载

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

8、函数的缺省参数

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) ;        // 不行,

C++笔记——引用、指针及动态内存分配

猜你喜欢