Ogre
异常处理
Ogre用c++内建的异常处理机制来处理错误
使用异常处理的好处
首先，使用异常
处理了，可以使得C++程序的两个部分相互通信（这两个部分通常是分别开发的）。检测到异常的部分可以抛出异常，而另一部分可以捕获异常并做出处理。
其次，使用异常处理，可以避免用返回值来定义错误，当有错误发生的时候，一个异常就会被抛出，这个异常里面封装了发生错误的详细信息。
Eg:
Try{
app.go();
}catcn(Ogre::Exception &e
){
//处理异常
}
首先，这段代码分为两个部分，分别由try与catch包围起来，如果app.go()有错误产生，则Ogre：：Exception类型的异常会被抛出，catch部分捕获并处理这个异常。
其次，如果没有异常这段代码可能就是这样的：
If（！app.go()）
{
//处理错误
}
可以看出如果没有异常机制，我们就不得不使用函数的返回值来定义错误，这样，不但错误信息不准确，而且导致程序的错误处理代码与应用代码混在一起，不易于维护。
Ogre对异常处理的支持
Ogre：：Exception
Ogre定义了自己的异常类型Ogre：：Exception，它记录了错误地详细信息（错误编号、详细描述、错误发生的文件名、行数等）。当有错误发生的时候，Ogre会抛出这个类型的异常，并把这个异常记录的错误信息写入到LogManager的默认日志文件中。
Ogre：：Exception提供了一个成员函数getFullDescription,它的返回值是String类型的，保存了对错误的详细描述。
Ogre：：Exception维护了一个函数名称堆栈，提供了一个入栈函数pushFunction，它接受一个String类型的参数。和一个出栈函数_popFunction，我们需要在每个函数的起始位置调用_pushFunction,并把该函数的额函数名当做参数传入，在结束位置调用_popFunction.
通过查看代码可以看到真个异常定义是通过工厂模式来实现的，首先是定义一个异常类，然后通过继承该类并添加不同的附加信息形成信息携带不同的异常类，最后用一个异常工厂来完成异常的判断。
#ifndef __Exception_H_
#define __Exception_H_
// Precompiler options
#include "OgrePrerequisites.h"
#include "OgreHeaderPrefix.h"
#include "OgreString.h"
#include <exception>
// Backwards compatibility with old assert mode
definitions
#if OGRE_RELEASE_ASSERT == 1
#
define OGRE_ASSERT_MODE 1
#endif
// Check for OGRE assert mode
//------------------------------------------------------以下是针对于不同判定模式所采用的错误机制------------------------------------------------------------//
// RELEASE_EXCEPTIONS mode
#if OGRE_ASSERT_MODE == 1
# ifdef
_DEBUG
#
define OgreAssert( a, b ) assert( (a)
&& (b) )
#
else
#
if OGRE_COMP != OGRE_COMPILER_BORL
#
define OgreAssert( a, b ) if( !(a) ) OGRE_EXCEPT(
Ogre::Exception::ERR_RT_ASSERTION_FAILED, (b), "no function info")
#
else
#
define OgreAssert( a, b ) if( !(a) ) OGRE_EXCEPT(
Ogre::Exception::ERR_RT_ASSERTION_FAILED, (b), __FUNC__
)
#
endif
#
endif
// EXCEPTIONS mode
#elif OGRE_ASSERT_MODE == 2
#
ifOGRE_COMP != OGRE_COMPILER_BORL
#
define OgreAssert( a, b ) if( !(a) ) OGRE_EXCEPT(
Ogre::Exception::ERR_RT_ASSERTION_FAILED, (b), "no function info")
#
else
#
define OgreAssert( a, b ) if( !(a) ) OGRE_EXCEPT(
Ogre::Exception::ERR_RT_ASSERTION_FAILED, (b), __FUNC__
)
#
endif
// STANDARD mode
#else
#
define OgreAssert( a, b ) assert( (a)
&& (b) )
#endif
namespace Ogre {
class _OgreExport Exception :
public std::exception //-----------------------定义了异常类的全部内容
{
protected:
long line;
int number;
String typeName;
String description;
String source;
String file;
mutable String fullDesc;
public:
enum ExceptionCodes
{
//===================================定义了异常代码的枚举类型
ERR_CANNOT_WRITE_TO_FILE,
ERR_INVALID_STATE,
ERR_INVALIDPARAMS,
ERR_RENDERINGAPI_ERROR,
ERR_DUPLICATE_ITEM,
ERR_ITEM_NOT_FOUND,
ERR_FILE_NOT_FOUND,
ERR_INTERNAL_ERROR,
ERR_RT_ASSERTION_FAILED,
ERR_NOT_IMPLEMENTED
};
Exception( int number, const String& description,
const String&
source );
Exception( int number, const String& description,
const String&
source, const char* type, const char*
file, long line );
Exception(const
Exception& rhs);
/// Needed for
compatibility with std::exception
~Exception() throw() {}
void operator = (const Exception&
rhs);
virtual const String&
getFullDescription(void)
const;
virtual int getNumber(void) const
throw();
virtual const String &getSource()
const { return source; }
virtual const String &getFile()
const { return file; }
virtual long getLine() const { return
line; }
virtual const String
&getDescription(void) const {
return description; }
/// Override
std::exception::what
const char* what() const throw() {
return
getFullDescription().c_str(); }
};
template
<int
num>
struct
ExceptionCodeType //里面包含了异常的编码
{
enum { number = num };
};
//通过继承上面的Exception类来定义不同的异常类型
// Specialised exceptions allowing each
to be caught specifically
// backwards-compatible since exception
codes still used
class _OgreExport
UnimplementedException : public
Exception
{
public:
UnimplementedException(int
inNumber, const
String& inDescription, const String& inSource,
const char* inFile, long inLine)
: Exception(inNumber, inDescription, inSource, "UnimplementedException", inFile, inLine)
{}
};
class _OgreExport
FileNotFoundException : public
Exception
{
public:
FileNotFoundException(int inNumber,
const String&
inDescription, const
String& inSource, const char*
inFile, long inLine)
: Exception(inNumber, inDescription, inSource, "FileNotFoundException", inFile, inLine)
{}
};
class _OgreExport IOException :
public Exception
{
public:
IOException(int inNumber,
const String&
inDescription, const
String& inSource, const char*
inFile, long inLine)
: Exception(inNumber, inDescription, inSource, "IOException", inFile, inLine) {}
};
class _OgreExport
InvalidStateException : public
Exception
{
public:
InvalidStateException(int inNumber,
const String&
inDescription, const
String& inSource, const char*
inFile, long inLine)
: Exception(inNumber, inDescription, inSource, "InvalidStateException", inFile, inLine)
{}
};
class _OgreExport
InvalidParametersException : public
Exception
{
public:
InvalidParametersException(int
inNumber, const
String& inDescription, const String& inSource,
const char* inFile, long inLine)
: Exception(inNumber, inDescription, inSource, "InvalidParametersException", inFile,
inLine) {}
};
class _OgreExport
ItemIdentityException : public
Exception
{
public:
ItemIdentityException(int inNumber,
const String&
inDescription, const
String& inSource, const char*
inFile, long inLine)
: Exception(inNumber, inDescription, inSource, "ItemIdentityException", inFile, inLine)
{}
};
class _OgreExport
InternalErrorException : public
Exception
{
public:
InternalErrorException(int
inNumber, const
String& inDescription, const String& inSource,
const char* inFile, long inLine)
: Exception(inNumber, inDescription, inSource, "InternalErrorException", inFile, inLine)
{}
};
class _OgreExport
RenderingAPIException : public
Exception
{
public:
RenderingAPIException(int inNumber,
const String&
inDescription, const
String& inSource, const char*
inFile, long inLine)
: Exception(inNumber, inDescription, inSource, "RenderingAPIException", inFile, inLine)
{}
};
class _OgreExport
RuntimeAssertionException : public
Exception
{
public:
RuntimeAssertionException(int
inNumber, const
String& inDescription, const String& inSource,
const char* inFile, long inLine)
: Exception(inNumber, inDescription, inSource, "RuntimeAssertionException", inFile, inLine)
{}
};
class
ExceptionFactory //异常工厂
，通过此类可以调用相关的静态函数create上面定义的所有异常类型，构造是通过异常号来判断的，返回的是
异常类的句柄
{
private:
/// Private constructor, no
construction
ExceptionFactory() {}
public:
static UnimplementedException
create(
ExceptionCodeType<Exception::ERR_NOT_IMPLEMENTED>
code,
const String&
desc,
const String& src,
const char* file, long line)
{
return
UnimplementedException(code.number, desc, src, file,
line);
}
static FileNotFoundException
create(
ExceptionCodeType<Exception::ERR_FILE_NOT_FOUND>
code,
const String&
desc,
const String& src,
const char* file, long line)
{
return
FileNotFoundException(code.number, desc, src, file,
line);
}
static IOException
create(
ExceptionCodeType<Exception::ERR_CANNOT_WRITE_TO_FILE>
code,
const String&
desc,
const String& src,
const char* file, long line)
{
return IOException(code.number,
desc, src, file, line);
}
static InvalidStateException
create(
ExceptionCodeType<Exception::ERR_INVALID_STATE>
code,
const String&
desc,
const String& src,
const char* file, long line)
{
return
InvalidStateException(code.number, desc, src, file,
line);
}
static InvalidParametersException
create(
ExceptionCodeType<Exception::ERR_INVALIDPARAMS>
code,
const String&
desc,
const String& src,
const char* file, long line)
{
return
InvalidParametersException(code.number, desc, src, file,
line);
}
static ItemIdentityException
create(
ExceptionCodeType<Exception::ERR_ITEM_NOT_FOUND>
code,
const String&
desc,
const String& src,
const char* file, long line)
{
return
ItemIdentityException(code.number, desc, src, file,
line);
}
static ItemIdentityException
create(
ExceptionCodeType<Exception::ERR_DUPLICATE_ITEM>
code,
const String&
desc,
const String& src,
const char* file, long line)
{
return
ItemIdentityException(code.number, desc, src, file,
line);
}
static InternalErrorException
create(
ExceptionCodeType<Exception::ERR_INTERNAL_ERROR>
code,
const String&
desc,
const String& src,
const char* file, long line)
{
return
InternalErrorException(code.number, desc, src, file,
line);
}
static RenderingAPIException
create(
ExceptionCodeType<Exception::ERR_RENDERINGAPI_ERROR>
code,
const String&
desc,
const String& src,
const char* file, long line)
{
return
RenderingAPIException(code.number, desc, src, file,
line);
}
static RuntimeAssertionException
create(
ExceptionCodeType<Exception::ERR_RT_ASSERTION_FAILED>
code,
const String&
desc,
const String& src,
const char* file, long line)
{
return
RuntimeAssertionException(code.number, desc, src, file,
line);
}
};
#ifndef OGRE_EXCEPT
#define OGRE_EXCEPT(num, desc, src) throw Ogre::ExceptionFactory::create(
\
Ogre::ExceptionCodeType<num>(), desc,
src, __FILE__, __LINE__ );
#endif
} // Namespace
Ogre
#include "OgreHeaderSuffix.h"
#endif
Ogre异常处理举例：
//Log.cpp
materialApplication
app;
try{
app.go();
}catch(Exception
& e){
#if OGRE_PLATFORM==PLATFORM_WIN32
//如果是WIN32平台，就弹出一个错误对话框，显示错误地详细信息。
MessageBox（NULL,e.getFullDescription().c_str(),"An exception has
occured!",MB_OK|MB_ICONERROR|MB_TASKMODAL);
#else
//如果不是Win32平台，则直接输出错误的详细信息
fprintf（stderr,"An exception
has occured:%s\n,e.getFullDescription().c_str());
//Log.h
//定义一个函数Wudi1，在内部无端地抛出一个异常
void Wudi1()
{
OgreGuard("Wudi1"); //将函数名称压入堆栈
Except（888,"wudi","wudi1");//抛出一个异常
OgreUnguard();
//弹出栈顶元素
}
//定义一函数Wudi2，在内部调用Wudi1
void Wudi2（）
{
OgreGuard("Wudi2");//将函数名称
压入堆栈
Wudi1();
//调用Wudi1
OgreUnguard();
//弹出栈顶元素
}
class
MaterialApplication：public ExampleApplication
{
public:
MaterialApplication(){}
protected:
//重载createScene函数
void createScene(void)
{
Wudi2();
//调用Wudi2函数
}
};
扫一扫
2104
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
