执行结果

也就是说，如果用函数返回引用，返回局部变量和引用初始化，程序会继续认为这个地址还是属于计算机的，并非是程序员自己申请的。

2.返回局部变量作为左值

 情况与上面类似

#include#includeusing namespace std;int demo1() {	int i = 0;	cout << "demo1()函数中，i的地址为：" << &i << endl;	return 0;}int& demo(int **p) {	int i = 600;	*p = &i;	cout << "i的地址为：" << &i << " i的值为：" << i << endl;	return i;				//返回局部变量}int main() {	int* p = NULL;	demo(&p) = 888;	cout << "p的地址为：" << p << " p的值为：" << *p << endl;	demo1();	cout << "p的地址为：" << p << " p的值为：" << *p << endl;	system("pause");	return 0;}

执行结果

 总结：若返回栈变量（自动变量/临时变量），不能成为其它引用的初始值，不能作为左值使用，虽然编译器只会警告，但在实际开发中是非常危险的操作！

3.例如返回static或者全局变量就不出出现这种情况

#include#includeusing namespace std;int& demo() {	static int i = 600;	cout << "i的地址为：" << &i << endl;	return i;				//返回静态变量}int main() {	int a = demo();	a = 888;	cout << "调用了demo(),a的值为：" << a << endl;	demo();	cout << "再次调用了demo(),a的值为：" << a << endl;	system("pause");	return 0;}

执行结果

其实，主要还是看返回值的生命周期，如果是立刻销毁的，则应注意使用~

4.C++11 _array容器用法

 array容器概念 

1. array 容器是 C++ 11 标准中新增的序列容器，简单地理解，它就是在 C++ 普通数组的基础上，添加了一些成员函数和全局函数。

1. array是将元素置于一个固定数组中加以管理的容器。
2. array可以随机存取元素,支持索引值直接存取， 用[]操作符或at()方法对元素进行操作，也可以使用迭代器访问
3. 不支持动态的新增删除操作
4. array可以完全替代C语言中的数组，使操作数组元素更加安全！
5. #include

 array特点

1. array 容器的大小是固定的，无法动态的扩展或收缩，这也就意味着，在使用该容器的过程无法增加或移除元素而改变其大小，它只允许访问或者替换存储的元素。
2. STL 还提供有可动态扩展或收缩存储空间的 vector 容器

 array对象的构造

 array采用模板类实现，array对象的默认构造形式

array arrayT;    //T为存储的类型, 为数值型模板参数

//构造函数

#includearray a1;     //一个存放5个int的array容器array a2;   //一个存放6个float的array容器array a3; //一个存放7个student的array容器

 array的赋值

array 的赋值

a1.assign(0); //玩法一 改变array中所有元素(注：将被废弃，不推荐使用)

在目前版本，编译器会报错

如果非要使用assign的话可以根据报错提示加一个宏

#define _SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING 1

a1.fill(666); //玩法二 用特定值填充array中所有元素

---

array test={1, 2, 3, 4};// 玩法三 定义时使用初始化列表，列表内的数量不能超过定义的大小

---

array test;

test={1,2,3,4};   //玩法四 定义后使用列表重新赋值

---

array a1,a2;

a1={1,2,3,4};

a2 = a1;//玩法五，赋值运算

---

a1.swap(a2);  //玩法六  和其它array进行交换

 array的大小

array.size();    返回容器中元素的个数array.empty();    判断容器是否为空,逗你玩的，因为容器是固定大小，永远为 falsearray.max_size();   返回容器中最大元素的个数，数组是固定大小，这也是逗你玩的同size()。

array的数据存取  

第一  使用下标操作 a1[0] = 100;

第二  使用at 方法 如: a1.at(2) = 100;

第三  接口返回的引用 a1.front() 和 a1.back()  

注意：   第一和第二种方式必须注意越界

array 迭代器访问 

#includeusing namespace std;array.begin();         返回容器中第一个数据的迭代器。array.end();          返回容器中最后一个数据之后的迭代器。array.rbegin();        返回容器中倒数第一个元素的迭代器。array.rend();         返回容器中倒数最后一个元素的后面的迭代器。array.cbegin();        返回容器中第一个数据的常量迭代器。array.cend();          返回容器中最后一个数据之后的常量迭代器。array.crbegin();        返回容器中倒数第一个元素的常量迭代器。array.crend();         返回容器中倒数最后一个元素的后面的常量迭代器。

#include#includeusing namespace std;int main() {	array arrayInt = { 1,2,3,4,5 };	普通迭代器	for (array::iterator ite = arrayInt.begin(); ite != arrayInt.end(); ite++)		cout << *ite << "  ";	常量迭代器，常量迭代器无法修改	array::const_iterator ite = arrayInt.cbegin();	逆向迭代器，逆向迭代器也是++	for (array::reverse_iterator ite = arrayInt.rbegin(); ite != arrayInt.rend(); ite++)		cout << *ite << "  ";}

set.rbegin()与set.rend()。略。

5.C++类型转换简介

旧式转型  C风格的强制类型

                type  b  =  (  type  )  a

                例如：

                int i = 48;

                char  c = (char ) i;

double  PI = 3.1415926;int i = PI;   隐式转换int i1 = (int) PI ; 强制类型转换强制类型转换，整数直接变指针int * addr = (int*) 0x888888;  void *p;int * int_arg = (int*) p;  强制转换

新式转型C++风格的类型转换提供了4种类型转换操作符来应对不同场合的应用。

格式：

    type b = 类型操作符<type> ( a )   

       类型操作符= static_cast | reinterpreter_cast | dynamic_cast | const_cast

5.1.static_cas转换

静态类型转换（斯文的劝导，温柔的转换）（编译器会检查转换是否合理）。如int转换成char

char a = "A";int b = static_cast (a);

主要用法：

• 用于类层次结构中基类（父类）和派生类（子类）之间指针或引用的转换。上行指针或引用(派生类到基类)转换安全，下行不安全（上行可以，下行不安全）

• 用于基本数据类型之间的转换，如把int转换成char，把int转换成enum。这种转换的安全性也要开发人员来保证。
• 把空指针转换成目标类型的空指针。
• 把任何类型的表达式转换成void类型

1.用于类层次结构中基类（父类）和派生类（子类）之间指针或引用的转换 

class Animal {public:	virtual void cry() = 0;};class dog :public Animal {public:	void cry() {		cout << "小狗汪汪汪" << endl;	}};int main() {	dog* d = new dog();	Animal* animal = d;//子类对象赋给基类	使用static_cast指针转换	Animal* al = static_cast(d);    引用转换	dog d2;	Animal& a2 = static_cast(d2);	system("pause");	return 0;} 

那为什么说上行转换可以，下行转换不安全呢？

我们再增加一个Animal的派生类

class cat :public Animal {public:	void cry() {		cout << "小猫喵喵喵" << endl;	}};

int main() {	dog* d = new dog();	//上行转换安全	Animal* animal = static_cast(d);	//下行转换，这种也是安全的	d = static_cast(animal);	//animal已经是dog类转过来的，再转成cat的就不安全的	cat* c;	c = static_cast(animal);		system("pause");	return 0;} 

因此，并不是说下行转换不可用，例如上面的将从dog类转过来的animal再转到cat就是不安全的，还是取决于程序员的使用 。

2.基本数据类型之间的转换 

int a = 10;char b = static_cast(a);

 3.把空指针转换成目标类型的空指针。

int* p = static_cast(NULL);

NULL在C++里定义的是void*0

 4.把任何类型的表达式转换成void类型

int* p = new int[10];void* vp = static_cast(p);

总结：使用static_cast可以使编译器做一些合法性检查，不写也没关系。

5.2.reinterpreter_cast 转换

重新解释类型(挂羊头，卖狗肉) 不同类型间的互转，数值与指针间的互转

用法：  

        type b = reinterpret_cast ( a )

        type 必须是一个指针、引用、算术类型、函数指针。

例如强制将整数转为指针int* addr = reinterpret_cast(0x88888);如果使用static_cast则会报错int* addr1 = static_cast(0x88888);

 

 

忠告：滥用 reinterpret_cast 运算符可能很容易带来风险。 除非所需转换本身是低级别的，否则应使用其他强制转换运算符之一。

用法1，数值与指针之间转换 

int* p = reinterpret_cast(0x88888);int val = reinterpret_cast(p);

用法2， 不同类型指针和引用之间的转换

 定义一个父类和两个派生类

class Animal {public:	void cry() {		cout << "动物叫" << endl;	}};class cat :public Animal {public:	void cry() {		cout << "小猫喵喵喵" << endl;	}};class dog :public Animal {public:	void cry() {		cout << "小狗汪汪汪" << endl;	}};

1.隐式上行  转换  与强制上行  转换

dog d1;Animal* animal = &d1;animal->cry();//如果能用static_cast强转，static_cast优先dog* d2 = reinterpret_cast(animal);dog* d3 = static_cast(animal);

 2.不同类型指针转换不能用static_cast

3.但是可以使用reinterpre_cast转换

int main() {	dog d1;	cat* c1 = reinterpret_cast(&d1);	c1->cry();	system("pause");	return 0;}

编译器不管程序是将什么类型转的，只晓得最后要获得一个cat类型，然后按cat的存储类型，访问里面的方法。如果滥用reinterpreter_cast，类型之间转来转去，可能会导致程序快速崩溃。

4.引用的强制类型转换

dog d1;Animal& animal = d1;dog& d2 = reinterpret_cast(animal);

 reinterpreter_cast  再加一个 static_cast 就已经可以替换C语言的转换

5.3.dynamic_cast转换

 动态类型转换

• 将一个基类对象指针cast到继承类指针，dynamic_cast 会根据基类指针是否真正指向继承类指针来做相应处理。失败返回null，成功返回正常cast后的对象指针；
• 将一个基类对象引用cast 继承类对象，dynamic_cast 会根据基类对象是否真正属于继承类来做相应处理。失败抛出异常bad_cast

注意：dynamic_cast在将父类cast到子类时，父类必须要有虚函数一起玩。

第一种情况 示例代码

#includeusing namespace std;class Animal {public:    //父类必须有虚函数	virtual void cry() = 0;};class cat :public Animal {public:	void cry() {		cout << "小猫喵喵喵" << endl;	}};class dog :public Animal {public:	void cry() {		cout << "小狗汪汪汪" << endl;	}};int main() {	dog d1;	Animal* animal = &d1;	cat* ca= dynamic_cast(animal);	if (ca==NULL) {		cout << "这是只狗！" << endl;	}	else {		cout << "这是只猫" << endl;	}	system("pause");	return 0;}

运行结果

第二种情况示例代码

int main() {	dog d1;	Animal& animal = d1;	dog& d2 = dynamic_cast(animal);	system("pause");	return 0;}

这种是没有任何问题，因为dog与animal是子类与父类的关系，并且animal指针真正指向dog。

但是，如果我们用其他类型接受又会是什么情况呢？

int main() {	dog d1;	Animal& animal = d1;	cat& d2 = dynamic_cast(animal);	system("pause");	return 0;}

基类指针并没有指向cat，这种情况编译是没有任何问题，因为编译器会认为这是父类与子类之间的转换，但是当我们运行时，编译器就会抛出异常 

 

 

对于抛出异常，我们就可以利用try—catch语句捕获异常，保证程序能继续运行

int main() {	dog d1;	Animal& animal = d1;	try {		cat& d2 = dynamic_cast(animal);	}	catch (std::bad_cast bc) {		cout << "不是猫，应该是狗" << endl;	}		system("pause");	return 0;}

运行结果

5.4.const_cast 转换

去const属性。(仅针对于指针和引用) 

 例如

#includeusing namespace std;void demo(const char* p) {	char* p1 = const_cast(p);	p1[0] = "A";}int main() {    //字符数组	char p[] = "1234567";	demo(p);	cout << p << endl;	system("pause");	return 0;}

运行结果

或者直接使用const_cast，运行结果也是一样

int main() {	char p[] = "1234567";	const_cast(p)[0] = "A";	cout << p << endl;	system("pause");	return 0;}

 但是，对于常量字符串不能去掉const修改

例如

#includeusing namespace std;void demo(const char* p) {	char* p1 = const_cast(p);	p1[0] = "A";}int main() {	const char *p = "1234567";	demo(p);	cout << p << endl;	system("pause");	return 0;}

可以编译，但是运行会报错

因为常量所处位置是常量区，内存无法访问常量区。

 5.2 类型转换使用建议

1）static_cast静态类型转换，编译的时c++编译器会做编译时的类型检查；隐式转换；

基本类型转换，父子类之间合理转换

2）若不同类型之间，进行强制类型转换，用reinterpret_cast<>() 进行重新解释

   建  议：

        C语言中  能隐式类型转换的，在c++中可用 static_cast<>()进行类型转换。因C++编译器在编译检查一般都能通过；C语言中不能隐式类型转换的，在c++中可以用 reinterpret_cast<>() 进行强制类型解释。

        总结：static_cast<>()和reinterpret_cast<>() 基本上把C语言中的 强制类型转换给覆盖，注意reinterpret_cast<>()很难保证移植性。

3）dynamic_cast<>()，动态类型转换，安全的虚基类和子类之间转换；运行时类型检查

4）const_cast<>()，去除变量的只读属性

最后的忠告：程序员必须清楚的知道: 要转的变量，类型转换前是什么类型，类型转换 后是什么类型，转换后有什么后果。

C++大牛建议：一般情况下，不建议进行类型转换；避免进行类型转换。