C / C++ / MFC

<br />
#pragma once<br />
<br />
// Functor interface class<br />
template < typename _TReturn, typename _TArg><br />
class IExecute<br />
{<br />
public:<br />
	// WARNING: USE OF TYPE void AS ARGUMENT TYPE IS NOT SUPPORTED! (REQUIRES MORE DERIVED CLASSES)<br />
	typedef typename _TReturn		_return_type;									// Interface functor return type<br />
	typedef typename _TArg			_arg_type;										// Interface functor parameter type<br />
	typedef void					_class_type;									// Dummy required for template consistency<br />
<br />
	virtual ~IExecute(void) = 0;<br />
<br />
	virtual _TReturn				Execute(_TArg _Arg) = 0;						// Interface functor execute function<br />
};<br />
<br />
// Interface functor inline pure virtual destructor defined<br />
template < typename _TReturn, typename _TArg><br />
inline IExecute< _TReturn, _TArg >::~IExecute(void)<br />
{	}<br />
<br />
// Functor derived class for pointers to functions that are non-const class or namespace members (const members REQUIRES MORE DERIVED CLASSES)<br />
template < typename _TClass, typename _TReturn = unsigned int, typename _TArg = void * ><br />
class CExecuteMember : public IExecute < _TReturn, _TArg ><br />
{<br />
protected:<br />
	// _ptr_type is a typedef for a pointer to a class member function of which the return and parameter type<br />
	// are defined at instantiation of CExecuteMember. If multiple return or parameter values are required use a<br />
	// struct pointer instead<br />
	typedef _return_type (_TClass::*_ptr_type)(_arg_type);							// Derived functor pointer-to-function type<br />
	typedef typename _TClass		_class_type;									// Override for derived functor class type<br />
<br />
	_class_type *					m_lpClass;										// Derived functor class pointer<br />
	_ptr_type						m_lpRoutine;									// Derived functor pointer-to-function<br />
<br />
public:<br />
	CExecuteMember(void) : m_lpClass(NULL), m_lpRoutine(NULL)<br />
	{	}<br />
	CExecuteMember(_class_type * _Class, _ptr_type _Routine) : m_lpClass(_Class), m_lpRoutine(_Routine)<br />
	{	}<br />
	~CExecuteMember(void)<br />
	{	}<br />
<br />
	_return_type					Execute(_arg_type _Arg)							// Execute a class member function<br />
	{<br />
		if (this->m_lpRoutine == NULL)<br />
			throw std::runtime_error("No routine pointer exists");<br />
		if (this->m_lpClass == NULL)<br />
			throw std::runtime_error("No class pointer exists");<br />
		return (m_lpClass->*m_lpRoutine)(_Arg);<br />
	}<br />
<br />
	inline _ptr_type				GetRoutinePtr(void) const						{	return this->m_lpRoutine;			}<br />
	inline _class_type *			GetClassPtr(void) const							{	return this->m_lpClass;				}<br />
	inline void						SetRoutinePtr(_ptr_type _Routine)				{	this->m_lpRoutine = _Routine;		}<br />
	inline void						SetClassPtr(_class_type * _Class)				{	this->m_lpClass = _Class;			}<br />
};<br />
<br />
// Functor derived class for pointers to functions existing globally<br />
template < typename _TReturn = unsigned int, typename _TArg = void * ><br />
class CExecuteNonMember : public IExecute < _TReturn, _TArg ><br />
{<br />
protected:<br />
	// _ptr_type is a typedef for a pointer to a global function of which the return and parameter type<br />
	// are defined at instantiation of CExecuteNonMember. If multiple return or parameter values are<br />
	// required use a struct pointer instead<br />
	typedef _return_type (* _ptr_type)(_arg_type);									// Derived functor pointer-to-function type<br />
<br />
	_ptr_type						m_lpRoutine;									// Derived functor pointer-to-function<br />
<br />
public:<br />
	CExecuteNonMember(void) : m_lpRoutine(NULL)<br />
	{	}<br />
	CExecuteNonMember(_ptr_type _Routine) : m_lpRoutine(_Routine)<br />
	{	}<br />
	~CExecuteNonMember(void)<br />
	{	}<br />
<br />
	_return_type					Execute(_arg_type _Arg)							// Execute a global function<br />
	{<br />
		if (this->m_lpRoutine == NULL)<br />
			throw std::runtime_error("No routine pointer exists");<br />
		return this->m_lpRoutine(_Arg);<br />
	}<br />
<br />
	inline _ptr_type				GetRoutinePtr(void) const						{	return this->m_lpRoutine;			}<br />
	inline void						SetRoutinePtr(_ptr_type _Routine)				{	this->m_lpRoutine = _Routine;		}<br />
};<br />

<br />
#pragma once<br />
<br />
class IFunctionoid																	// Functionoid interface class for encapsulated function calls<br />
{<br />
public:<br />
	virtual							~IFunctionoid(void) = 0;<br />
	virtual unsigned int			operator()(void * lpArg) = 0;					// Interface functionoid execute function<br />
																					// NOTE: returntype always unsigned int, parametertype always void *<br />
};<br />
<br />
inline								IFunctionoid::~IFunctionoid(void)				{										}<br />
<br />
typedef IFunctionoid *				LPFUNCTIONOID;<br />
<br />
//class CMyFunctionoid1 : public IFunctionoid<br />
//{<br />
//public:<br />
//	// TODO: Declare (additional) constructors taking possible un-common / non-shared function variables here<br />
//	// ...<br />
//	virtual unsigned int operator()(void * lpArg)<br />
//	{<br />
//		// TODO: Define your function here or call it through a function pointer, whatever suits you<br />
//	}<br />
//private:<br />
//	// TODO: Declare (additional) possible un-common / non-shared function variables here<br />
//	// ...<br />
//};<br />

Debug Assertion Failed!

Program: ...
File: fopen.c
Line: 53

Expression: file != NULL

<br />
#include <iostream><br />
#include <fstream><br />
<br />
using namespace std;<br />
<br />
unsigned char *openFile(char *, int&);<br />
<br />
int main(int argc, char **argv) {<br />
	unsigned char *buffer; // unsigned char = 8-bits<br />
	char *fileName;<br />
	int length;<br />
<br />
	if (argc != 1) {<br />
		cout << "Usage: " << argv[0] << " <pcap_file>" << endl;<br />
		exit(1);<br />
	} else {<br />
		fileName = argv[1];<br />
		buffer = openFile(fileName, length);<br />
	}<br />
<br />
	return 0;<br />
}<br />
<br />
unsigned char *openFile(char *fileName, int &length) {<br />
	char *temp_buffer;<br />
	unsigned char *buffer;<br />
	ifstream theFile;<br />
<br />
	theFile.open(fileName, ios::in|ios::binary);<br />
	if (!theFile) {<br />
		cout << "Can't open file " << *fileName << "!" << endl;<br />
		exit(1);<br />
	}<br />
<br />
	// get length of file<br />
	theFile.seekg(0, ios::end);<br />
	length = theFile.tellg();<br />
	theFile.seekg(0, ios::beg);<br />
<br />
	// allocate memory<br />
	temp_buffer = new char [length];<br />
	buffer = new unsigned char [length];<br />
<br />
	// read data<br />
	theFile.read(temp_buffer,length);<br />
	theFile.close();<br />
<br />
	buffer = (unsigned char *) temp_buffer;<br />
	<br />
//	delete[] temp_buffer; // why not!?<br />
	// What's an assertion failure?<br />
	// That doesn't sound good. ;)<br />
	return buffer;<br />
}<br />