异常和文件操作

引子：类型转换

1）普通类型之间的转换：static_cast 凡是可以隐式转换的地方都可以用，在编译时进行类型识别

	a = ststic_cast<int>(d);

2）指针之间的转换：reinterpret_cast 可用来在指针和整型之间转换

	p = reinterpret_cast<int *>(pd);

3）层次间转换：dynamic_cast 在运行时进行类型识别，基类和派生类之间转换；类型匹配则成功，不不匹配则失败，返回NULL指针；

	Dog * p = dynamic_cast<Dog*>(p);

4）去掉只读属性：const_cast 只是去掉只读属性赋给前面的值，但其本身并无变化

	char* p = const_cast <char*>(str);

1、异常处理

异常是一种程序控制机制，与函数机制独立和互补。可以用来改变程序的控制结构，但在错误处理方面取得了巨大好处。

1）使用throw可以抛出异常，然后可以使用try{}catch{}语句块来捕获并处理异常。

1、把可能发生异常的代码放在try（try不是处理错误，而是处理异常）中，异常需要人为抛出。

2、异常是跨函数的

3、异常在捕获后：处理，不让其继续抛或者不处理，用throw继续往后抛

4、catch捕获后，要严格遵循类型匹配，不允许任何形式的类型转换

2）从try开始到throw期间，在栈上创建的所有对象，当异常抛出的时候会被全部释放。析构顺序与构造顺序相反，成为栈解旋。但是堆上的对象需要自己处理，不会自动释放的

3）异常接口声明：默认函数可以抛出任意类型的异常，但也可以限制抛出类型：

	void fun()throw(A,B,C);		// 该函数只能抛出ABC类型的异常
	void fun() throw(); 		// 该函数不能抛出任何类型的异常



4）异常变量的生命周期：
当抛出一个对象时，

1、拿一个普通变量去收，会有匿名对象产生，但它的生命周期会直到异常处理完毕。

2、当拿引用去接这个匿名对象时，不会产生多个备份。

3、去接对象指针时，若在栈上，在异常接收前就释放了，接到的指针不可使用，它是非法指针。

4、去接一个堆上的对象指针，该对象不会自动释放，需要手动调用delete去释放

catch的类型：引用和普通变量不能共存，但引用和指针可以共存
5）异常在类层次中使用：用这样一个数组类来举例：对数组初始化时对数组的个数进行有效检查。这样的类除了需要一般的构造函数，析构函数等之外，在需要几个相关错误的处理类，让它们都继承自eSize类（内部类），这样，在构造函数中根据条件抛出这些错误处理类。在main函数中用try语句建数组类并用多态的知识利用基类的引用接错误类。
6）C++标准提供了一组标准异常类，这些类以基类Exception开始，标准程序库中抛出的所有异常，都派生于该基类，这些类的派生都继承了一个成员函数what()，用于返回错误信息（返回类型是const char*），声明如下：
	virtual const char * what() const throw();



2、C++输入输出流
1）输入输出流：

标准设备：键盘，屏幕==>标准I/O

文件：读（in）写（out）文件==>文件I/O

内存：缓冲区、数组==>串I/O

2）

输入流：

	ch = cin.get();  cin.get(ch);	//getchar()
	cin.getline(str,100);		//fgets  (cin读不了空格)
	cin.ignore(3);			//忽略3个字节往后读
	ch = cin.peek();		//偷窥一个字节，并不撩
	cin.putchar(ch);		//吃完吐回到缓存区
3）文件操作

1、读出

	ofstream f("test"); 		// 定义一个文件输出流对象，对象创建成功则已打开
	f << "hello world" << endl;	// 把f当cout用
 2、写入：类似读出

3、关闭：f.close();



/*
案例：设计一个数组类 MyArray，重载[]操作，
	数组初始化时，对数组的个数进行有效检查 
	1）index<0 抛出异常eNegative  
	2）index = 0 抛出异常 eZero  
	3）index>1000抛出异常eTooBig 
	4）eSize类是以上类的父类，实现有参数构造、并定义virtual void printErr()输出错误。
*/
#include <iostream>
using namespace std;

class MyArray
{
public:
	MyArray(int len)
	{
		if (len < 0)
		{
			throw eNegative(len);
		}
		if (len == 0)
		{
			throw eZero(len);
		}
		if (len > 1000)
		{
			throw eTooBig(len);
		}
		this->len = len;
		m_p = new int[len];
	}
	~MyArray()
	{
		if (m_p != NULL)
		{
			delete []m_p;
			m_p = NULL;
		}
		len = 0;
	}
	int &operator[](int index)
	{
		return m_p[index];
	}

	class eSize
	{
	public:
		eSize(int size)
		{
			this->size = size;
		}
		virtual void printErr() = 0;
	protected:
		int size;
	};
	class eNegative
	{
	public:
		eNegative(int size)
		{
			this->size = size;
		}
		void printErr()
		{
			printf("result < 0\n");
		}
	protected:
		int size;
	};
	class eZero
	{
	public:
		eZero(int size)
		{
			this->size = size;
		}
		void printErr()
		{
			printf("result = 0\n");
		}
	protected:
		int size;
	};
	class eTooBig
	{
	public:
		eTooBig(int size)
		{
			this->size = size;
		}
		void printErr()
		{
			printf("result > 1000\n");
		}
	protected:
		int size;
	};

protected:
	int len;
	int *m_p;
};
int main()
{
	try
	{
		MyArray a(3);
		for (int i = 0; i < 10; i++)
		{
			a[i] = i;
		}
	}
	catch(MyArray::eSize & e)	// 多态
	{
		e.printErr();
	}
	catch(...)
	{
		printf("others\n");
	}
	return 0;
}