2017.2.15

1.引用用法：

别名，必须初始化，不允许重定义。

引用初始化两种=,()

1.左值引用

1.做函数参数，改值

2.引用一个指针，在函数内部可以改变指针的指向，还可以改变指针的值。

1 int *p1=new int;
2 int *p2=new int;
3 int *& p3=p1;  //指针的引用，指向同一块内存
4 *p3=100;     //改变值
5 p3=p1;       //改变指向

3.左值引用是用指针实现的。

4.引用做返回值，不能返回栈上的数据，可以返回堆，静态区的数据

 1 #include<stdio.h>
 2 #include<iostream>
 3 int * & data()
 4 {
 5     int *p;
 6     p=new int;
 7     *p=10;
 8     int *& rp=p;
 9     return rp;
10 }
11 
12 
13 int main()
14 {
15     int *&rc=data();
16     std::cout<<*rc<<std::endl;
17     std::cout<<*rc<<std::endl;
18     
19 }

View Code

mingw下g++编辑结果为10 10

ubuntu下g++编译结果为10 0

vs2015编译结果为 10 257909260

2.右值引用

待补

2.const用法：

1.c与c++ const对比

c中的const量，只是一个可读的变量，可以通过强制转换其指针来改变值。

 1 #include<stdio.h>
 2 
 3 int main()
 4 {
 5     const int c=0;
 6     int * p=(int*)(&c);
 7     *p=1;
 8     printf("%d
",c);       //用gcc编译c=1，用g++编译c=0
 9 }

c中const量不能用于数组

1 const int d=8；
2 int len[d];              //c error,c++可以

c++ const的强制转换方法：

1 int *p = const_cast<int*>(&a);

View Code

c++常量强制转化后修改不变，是因为没从内存读取，而是直接读常量表，但是内存中的值已经修改。

 1 #include<iostream>
 2 
 3 
 4 int main()
 5 {
 6     const int a = 0;
 7     std::cout << &a << std::endl;    //006FFDAC
 8     int *p = const_cast<int*>(&a);
 9     *p = 4;
10     std::cout << a << std::endl;     // 0
11     std::cout << *p << std::endl;    // 4  内存已经修改
12     std::cin.get();
13 }

2. 指向常量的指针和常指针

1 const int *pointer 
2 int *const pointer

c++强类型转换一般约束只会增强，不会削弱。

比如：

1 int a=0;
2 const int b=0;
3 const int *pointer(&a)   //正确
4 const int *pointer(&b)   //正确
5 int *cosnt pointer(&a)   //正确
6 int *cosnt pointer(&b)   //错误

3,4两行无论是const还是非const变量的地址，对于指向常量的指针都无关紧要。

而第6行，把const变量的地址赋给常指针（可以修改值），类型转换某种意义上是削弱了，不能通过const变量的地址来修改值。

3.new/delete:

delete不能delete两次（同free）

1 int *p=new int[10];
2 
3 ....
4 
5 delete []p;

View Code

::new/::delete 全局