C++异常处理知识点总结

#include <stdio.h>
#include <stdlib.h>

#define BUFSIZE 1024

//实现文件的二进制拷贝
int copyfile(const char* dest, const char* src) 
{
	FILE* fp1 = NULL, * fp2 = NULL;

	//rb 只读方式打开一个二进制文件，只允许读取数据
	fopen_s(&fp1, src, "rb");

	if (fp1 == NULL) 
	{
		return -1;
	}

	//wb 以只写的方式打开或新建一个二进制文件，只允许写数据。
	fopen_s(&fp2, dest, "wb");
	if (fp2 == NULL) 
	{
		return -2;
	}

	char buffer[BUFSIZE];
	int readlen, writelen;

	//如果读到数据，则大于0
	while ((readlen = fread(buffer, 1, BUFSIZE, fp1)) > 0) 
	{
		writelen = fwrite(buffer, 1, readlen, fp2);
		if (readlen != writelen) 
		{
			return -3;
		}
	}

	fclose(fp1);
	fclose(fp2);
	return 0;
}

int main() 
{
	int ret = 0;
	ret = copyfile("dest.txt", "src.txt");

	if (ret != 0)
	{
		switch (ret) 
		{
		case -1:
			printf("打开源文件失败!\n");
			break;
		case -2:
			printf("打开目标文件失败!\n");
			break;
		case -3:
			printf("拷贝文件时失败!\n");
			break;
		default:
			printf("出现未知的情况!\n");
			break;
		}
	}
	
	
	return 0;
}

// demo 15-15  
#include <stdio.h>
#include <stdlib.h>
#include <string>

using namespace std;

#define BUFSIZE 1024

int copyfile2(char* dest, char* src)
{
	FILE* fp1 = NULL, * fp2 = NULL;

	fopen_s(&fp1, src, "rb");

	if (fp1 == NULL)
	{
		throw new string("文件不存在");
	}

	fopen_s(&fp2, dest, "wb");
	if (fp2 == NULL) 
	{
		throw - 2;
	}

	char buffer[BUFSIZE];
	int readlen, writelen;

	while ((readlen = fread(buffer, 1, BUFSIZE, fp1)) > 0)
	{
		writelen = fwrite(buffer, 1, readlen, fp2);
		if (readlen != writelen)
		{
			throw - 3;
		}
	}
	fclose(fp1);
	fclose(fp2);
	return 0;
}

int copyfile1(char* dest, char* src) {
	return copyfile2(dest, src);
}

int main()
{
	int ret = 0;

	try 
	{
		ret = copyfile1("dest.txt", "src.txt");

	}
	catch (int error) 
	{
		printf("出现异常啦！%d\n", error);
	}
	catch (string* error) 
	{
		printf("捕捉到字符串异常：%s\n", error->c_str());
		delete error;
	}

	system("pause");
	return 0;
}

throw 表达式;

try{
    xxx
    这里写可能抛出异常的程序段。-出现异常直接进入到catch
    xxx,如果上面的这条语句执行了异常，那么这行就不会被执行。 
}catch(异常处理类型 xxx(可写可不写)){
    
}catch(){
    
}catch(...){} //接受所有异常

void function (xxx,xxx) throw (float, string *, int)

void function(xxx,xxx) throw()

throw classname();

#include<iostream>
#include"err.h"
using namespace std;


class Vector
{
public:
	Vector(int len = 128);
	Vector(const Vector& other);
	int GetLength()const;
	int& operator[](int index)const;
	Vector& operator=(const Vector& other);
	~Vector();
	friend ostream& operator<<(ostream& os, const Vector& other);
private:
	int* m_base;
	int m_len;

};
Vector::Vector(int len)
{
	if (len < 0)
	{
		errNegativeException err(len);
		throw &err;
	}
	else if (len == 0)
	{
		errZeroException err(len);
		throw &err;
	}
	else if (len > 1000)
	{
		errTooBigException  err(len);
		throw& err;
	}
	else if (len < 10)
	{
		errTooSmallException err(len);
		throw  &err;
	}
	m_len = len;
	m_base = new int[m_len];
}

Vector::Vector(const Vector& other)
{
	m_len = other.m_len;
	delete[] m_base;
	m_base = new int[m_len];
	for (int i = 0; i < m_len; i++)
	{
		m_base[i] = other.m_base[i];
	}

}

Vector::~Vector()
{
	if (m_base)
	{
		delete[] m_base;
		m_len = 0;

	}
}

int Vector::GetLength()const
{
	return m_len;
}

int& Vector::operator[](int index)const
{
	return m_base[index];
}



ostream& operator<<(ostream& os, const Vector& other)
{
	for (int i = 0; i < other.GetLength(); i++)
	{
		os << other.m_base[i] << " ";
	}
	os << endl;
	return os;
}


Vector& Vector::operator=(const Vector& other)
{
	delete[] this->m_base;
	this->m_len = other.m_len;
	this->m_base = new int[this->m_len];
	for (int i = 0; i < this->m_len; i++)
	{
		this->m_base[i] = other.m_base[i];
	}
	return *this;
}

int main(void)
{

	try
	{
		Vector v(1111);
		//上面没有问题才会执行到下面的这个for
		for (int i = 0; i < v.GetLength(); i++)
		{
			v[i] = i;
		}
		cout << v;
	}
	//多态实现父类指针指向子类对象
	catch (errSizeException* err)
	{
		err->printError();
	}
	/*catch (errNegativeException& err)
	{
		cout << "errNegativeException" << endl;
	}
	catch (errZeroException& err)
	{
		cout << "errZeroException" << endl;
	}
	catch (errTooBigException& err)
	{
		cout << "errTooBigException" << endl;
	}
	catch (errTooSmallException& err)
	{
		cout << "errTooSmallException" << endl;
	}*/

	

	return 0;
}

#pragma once
#include<iostream>
using namespace std;

/*
	
 
	1) index<0 抛出异常errNegativeException
	2）index = 0 抛出异常 errZeroException
	3）index>1000抛出异常errTooBigException
	4）index<10 抛出异常errTooSmallException

	errSizeException类是以上类的父类，实现有参数构造、并定义virtual void printError()输出错误。
*/
class errSizeException
{
public:
	errSizeException(int size):m_size(size)
	{

	}
	virtual void printError()const
	{
		cout << "size:" << m_size << endl;
	}
protected:
	int m_size;
};

class errNegativeException:public errSizeException
{
public:
	errNegativeException(int size):errSizeException(size)
	{

	}
	virtual void printError()const
	{
		cout << "errNegativeException size:" << m_size << endl;
	}
};
class errZeroException :public errSizeException
{
public:
	errZeroException(int size) :errSizeException(size)
	{

	}
	virtual void printError()const
	{
		cout << "errZeroException size:" << m_size << endl;
	}
};
class errTooBigException :public errSizeException
{
public:
	errTooBigException(int size) :errSizeException(size)
	{

	}
	virtual void printError()const
	{
		cout << "errTooBigException size:" << m_size << endl;
	}
};
class errTooSmallException :public errSizeException
{
public:
	errTooSmallException(int size) :errSizeException(size)
	{

	}
	virtual void printError()const
	{
		cout << "errTooSmallException size:" << m_size << endl;
	}
};

#include<iostream>
using namespace std;
class Student
{
public:
	Student(int age )
	{
		if (age > 249)
		{
			throw out_of_range("年龄过大");
		}
		m_age = age;
		m_space = new int[1024 * 1024 * 100];
	}

private:
	int m_age;
	int* m_space;
};


int main(void)
{
	try
	{
		for (int i = 1; i < 1024; i++)
		{
			Student* s = new Student(18);
		}
	

	}
	catch (out_of_range &e)
	{
		cout << e.what() << endl;	
	}
	catch (bad_alloc& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}