一、位运算

应用：

1、判断某一位是否为1

2、只改变其中某一位，而保持其它位都不变

位运算操作：

1、& 按位与（双目）：

将某变量中的某些位清0（与0位与）且同时保留其它位不变（与1位与）；获取某变量中某一位（与其位与后判断是否为该数）

2、|  按位或（双目）：

将某变量中的某些位置1（与1位或）且保留其它位不变

3、^  按位异或（双目）：

将某变量中的某些位取反（与1异或）且保留其它位不变

异或运算特点：

如果 a^b=c，那么就有 c^b = a以及c^a=b。(穷举法可证---用于简单加密解密)

实现不通过临时变量，就能交换两个变量的值。例如：

int a = 5, b = 7;

a = a ^ b;

b = b ^ a;

a = a ^ b;

即实现a,b值交换。穷举法可证。

4、~  按位非（取反）（单目）：

将操作数中的二进制位0变成1，1变成0。

5、<< 左移（双目）：

表达式：a << b的值是：将a各二进位全部左移b位后得到的值。左移时，高位丢弃，低位补0。a 的值不因运算而改变。

实际上，左移1位，就等于是乘以2，左移n位，就等于是乘以2^n。而左移操作比乘法操作快得多。

6、>> 右移（双目）：

表达式：a >> b的值是：将a各二进位全部右移b位后得到的值。右移时，移出最右边的位就被丢弃。 a 的值不因运算而改变。

对于有符号数，如long，int，short，char类型变量，在右移时，符号位（即最高位）将一起移动，并且大多数C/C++编译器规定，如果原符号位为1，则右移时高位就补充1，原符号位为0，则右移时高位就补充0。

实际上，右移n位，就相当于左操作数除以2^n，并且将结果往小里取整。

二、引用（&）

定义：类型名 & 引用名 = 某变量名；

例如：int n = 4; 

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

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

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

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

初始化后，它就一直引用该变量，不会再引用别的变量了。——从一而终！！

应用：

1、交换变量的值

void swap( int & a, int & b)

{

int tmp;

tmp = a; a = b; b = tmp;

}

int n1, n2;

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

2、引用作为函数的返回值

int n = 4;

int & SetValue() { return n; }

int main() 

{

SetValue() = 40;

cout << n;

return 0;

}  //输出： 40

3、常引用

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

int n;

const int & r = n;   // r 的类型是 const int & 

不能通过常引用去修改其引用的内容:

int n = 100;

const int & r = n;

r = 200;  //编译错

n = 300;  // 没问题

4、常引用与 非常引用的转换

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

（1）T & 类型的引用或T类型的变量可以用来初始化const T & 类型的引用。

（2）const T 类型的常变量和const T & 类型的引用则不能用来初始化T &类型的引用，除非进行强制类型转换。

三、const 

1、定义常量   ——define也可以定义常量，但是没有类型

const int MAX_VAL = 23；

const string SCHOOL_NAME = “Peking University”；

2、定义常量指针

（1）不可通过常量指针修改其指向的内容。

int n,m;

const int * p = & n;

* p = 5;  //编译出错

n = 4;  //ok

p = &m; //ok, 常量指针的指向可以变化

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

const int * p1; int * p2;

p1 = p2;  //ok

p2 = p1;  //error

p2 = (int * ) p1; //ok,强制类型转换

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

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

四、动态内存分配（new、delete）——按需分配

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

（1）分配一个变量

P = new T; 

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

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

int * pn;

pn = new int; 

* pn = 5;

（2）分配一个数组

P = new T[N]; 

T :任意类型名

P :类型为T * 的指针

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

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

int * pn;

int i = 5;

pn = new int[i * 20];

pn[0] = 20;

pn[100] = 30; //编译没问题。运行时导致数组越界

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

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

（1）delete 指针；//该指针必须指向new出来的空间

int * p = new int;

* p = 5;

delete p;

delete p; //导致异常，一片空间不能被delete多次

（2）delete [ ] 指针；//该指针必须指向new出来的数组

int * p = new int[20];

p[0] = 1;

delete [ ] p;

注：用“delete”释放动态分配的数组，要加“[]”

五、内联函数、函数重载、函数缺省参数

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) { }

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

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

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