l3_miniiostream.h

此为破解装载器一书中的源代码,在看雪论坛下载的,

#ifndef _INCLUDED_L3_MINIIOSTREAM_H
#define _INCLUDED_L3_MINIIOSTREAM_H

#include <stdio.h>

///////////////////////

namespace ios
{
	const int in=1;
	const int out=2;
	const int app=4;
	const int binary=8;
	const int nocreate=16;
}

const char endl='\n';

///////////////////////

class stream
{
protected:
	FILE * _file;
	inline stream()
		: _file(NULL)
	{
	}
	inline explicit stream(FILE * file)
		: _file(file)
	{
	}
	inline void initialize(FILE * file)
	{
		_file=file;
	}
	virtual ~stream()
	{
	}

public:
	inline void flush()
	{
		assert(_file!=NULL);
		if(_file!=NULL)
		{
			fflush(_file);
			/*
			const int retval=fflush(_file);
			assert(retval==0);
			*/
		}
	}
	virtual bool good() const
	{
		return _file!=NULL;
	}
	inline FILE * get_file_struct() const
	{
		return _file;
	}

private:
	stream& operator=(stream&);// Forbidden.
	explicit stream(stream&);// Forbidden.
};

///////////////////////

class istream: public virtual stream
{
public:
	inline istream()
		: stream(stdin)
	{
	}
	virtual ~istream()
	{
	}
	inline bool get(char & c)
	{
		const int retval=fscanf(_file, "%c", &c);
        return retval>0;
	}
	friend istream & operator>>(istream & obj, char str[]);
	friend istream & operator>>(istream & obj, char & c);
	friend istream & operator>>(istream & obj, unsigned char & uc);
	friend istream & operator>>(istream & obj, short & s);
	friend istream & operator>>(istream & obj, unsigned short & us);
	friend istream & operator>>(istream & obj, int & i);
	friend istream & operator>>(istream & obj, unsigned & u);
	friend istream & operator>>(istream & obj, long & l);
	friend istream & operator>>(istream & obj, unsigned long & ul);
	friend istream & operator>>(istream & obj, float & f);
	friend istream & operator>>(istream & obj, double & d);

private:
	istream& operator=(istream&);// Forbidden.
	explicit istream(istream&);// Forbidden.
};

inline istream & operator>>(istream & obj, char str[])
{
	fscanf(obj._file, "%s", str);
	return obj;
}

inline istream & operator>>(istream & obj, char & c)
{
	fscanf(obj._file, "%c", &c);
	return obj;
}

inline istream & operator>>(istream & obj, unsigned char & uc)
{
	fscanf(obj._file, "%c", &uc);
	return obj;
}

inline istream & operator>>(istream & obj, short & s)
{
	fscanf(obj._file, "%d", &s);
	return obj;
}

inline istream & operator>>(istream & obj, unsigned short & us)
{
	fscanf(obj._file, "%d", &us);
	return obj;
}

inline istream & operator>>(istream & obj, int & i)
{
	fscanf(obj._file, "%d", &i);
	return obj;
}

inline istream & operator>>(istream & obj, unsigned & u)
{
	fscanf(obj._file, "%d", &u);
	return obj;
}

inline istream & operator>>(istream & obj, long & l)
{
	fscanf(obj._file, "%ld", &l);
	return obj;
}

inline istream & operator>>(istream & obj, unsigned long & ul)
{
	fscanf(obj._file, "%ld", &ul);
	return obj;
}

inline istream & operator>>(istream & obj, float & f)
{
	fscanf(obj._file, "%f", &f);
	return obj;
}

inline istream & operator>>(istream & obj, double & d)
{
	fscanf(obj._file, "%lf", &d);
	return obj;
}

///////////////////////

enum WhatOutput
{
	standard_stdout,
	standard_stderr,
	logfile_stdout,
	logfile_stderr,
};

class ostream: public virtual stream
{
protected:
	int _precision;

public:
	inline ostream()
		: stream(stdout),
		_precision(6)
	{
	}
	inline explicit ostream(WhatOutput what_output)
		: stream(stdout),
		_precision(6)
	{
		switch(what_output)
		{
		case standard_stdout:
			stream::initialize(stdout);
			break;
		case standard_stderr:
			stream::initialize(stdout);
			break;
		case logfile_stdout:
			stream::initialize(fopen("cout.txt", "wt"));
			#ifdef UNDER_CE
				_wfreopen(L"stdout.txt", L"wt", stdout);
			#else
				freopen("stdout.txt", "wt", stdout); // not in wince
			#endif
			break;
		case logfile_stderr:
			stream::initialize(fopen("cerr.txt", "wt"));
			#ifdef UNDER_CE
				_wfreopen(L"stderr.txt", L"wt", stderr);
			#else
				freopen("stderr.txt", "wt", stderr); // not in wince
			#endif
			break;
		default:
			stream::initialize(stdout);
		}
	}
	virtual ~ostream()
	{
	}
	inline void precision(int prec)
	{
		assert(prec>1);
		assert(prec<64);
		_precision=prec;//xxx ignored, not implemented
	}
	friend ostream & operator<<(ostream & obj, const char str[]);
	friend ostream & operator<<(ostream & obj, const char c);
	friend ostream & operator<<(ostream & obj, const unsigned char uc);
	friend ostream & operator<<(ostream & obj, const short s);
	friend ostream & operator<<(ostream & obj, const unsigned short us);
	friend ostream & operator<<(ostream & obj, const int i);
	friend ostream & operator<<(ostream & obj, const unsigned u);
	friend ostream & operator<<(ostream & obj, const long l);
	friend ostream & operator<<(ostream & obj, const unsigned long ul);
	friend ostream & operator<<(ostream & obj, const float f);
	friend ostream & operator<<(ostream & obj, const double d);

private:
	ostream& operator=(ostream&);// Forbidden.
	explicit ostream(ostream&);// Forbidden.
};

inline ostream & operator<<(ostream & obj, const char str[])
{
	fprintf(obj._file, "%s", str);
	return obj;
}

inline ostream & operator<<(ostream & obj, const char c)
{
	if(c==endl)
	{
		obj.flush();
	}
	fprintf(obj._file, "%c", c);
	return obj;
}

inline ostream & operator<<(ostream & obj, const unsigned char uc)
{
	if(uc==endl)
	{
		obj.flush();
	}
	fprintf(obj._file, "%c", uc);
	return obj;
}

inline ostream & operator<<(ostream & obj, const short s)
{
	fprintf(obj._file, "%d", s);
	return obj;
}

inline ostream & operator<<(ostream & obj, const unsigned short us)
{
	fprintf(obj._file, "%d", us);
	return obj;
}

inline ostream & operator<<(ostream & obj, const int i)
{
	fprintf(obj._file, "%d", i);
	return obj;
}

inline ostream & operator<<(ostream & obj, const unsigned u)
{
	fprintf(obj._file, "%d", u);
	return obj;
}

inline ostream & operator<<(ostream & obj, const long l)
{
	fprintf(obj._file, "%ld", l);
	return obj;
}

inline ostream & operator<<(ostream & obj, const unsigned long ul)
{
	fprintf(obj._file, "%ld", ul);
	return obj;
}

inline ostream & operator<<(ostream & obj, const float f)
{
	fprintf(obj._file, "%f", f);
	return obj;
}

inline ostream & operator<<(ostream & obj, const double d)
{
	fprintf(obj._file, "%f", d);
	return obj;
}

///////////////////////

#ifdef PLATFORM_HAS_FILESYSTEM

class fstream: public virtual stream
{
public:
	inline fstream()
	{
	}
	inline fstream(const char name[], int flags)
	{
		open(name, flags);
	}
	virtual ~fstream()
	{
		close();
	}
	void open(const char name[], int flags);
	inline void close()
	{
		if(_file!=NULL)
		{
			fclose(_file);
			//const int retval=fclose(_file);
			//assert(retval==0); Of course closing stdio, stderr or  stdout will fail.
		}
	}

private:
	fstream& operator=(fstream&);// Forbidden.
	explicit fstream(fstream&);// Forbidden.
};

void fstream::open(const char name[], int flags)
{
	close();
	char flagtext[3]="rt";
	if(flags&ios::app)
	{
		assert((flags&ios::in)==0);
		assert((flags&ios::out)==0);
		assert((flags&ios::app)!=0);
		flagtext[0]='a';
	}
	else if(flags&ios::out)
	{
		assert((flags&ios::in)==0);
		assert((flags&ios::out)!=0);
		assert((flags&ios::app)==0);
		flagtext[0]='w';
	}
	else
	{
		assert((flags&ios::in)!=0);
		assert((flags&ios::out)==0);
		assert((flags&ios::app)==0);
	}
	if(flags&ios::binary)
	{
		flagtext[1]='b';
	}
	_file=fopen(name, flagtext);
}

///////////////////////

class ifstream: public istream, public fstream
{
public:
	inline ifstream()
	{
	}
	inline ifstream(const char name[], int flags=ios::in)
	{
		open(name, flags);
	}
	virtual ~ifstream()
	{
		close();
	}
	inline void open(const char name[], int flags)
	{
		assert(flags&ios::in);
		assert((flags&ios::out) == 0);
		assert((flags&ios::app) == 0);
		fstream::open(name, flags);
	}
	inline bool good() const
	{
		return stream::good() && !eof();
	}
	inline bool eof() const
	{
		assert(_file!=NULL);
		return feof(_file)!=0;
	}

private:
	ifstream& operator=(ifstream&);// Forbidden.
	ifstream(ifstream&);// Forbidden.
};

///////////////////////

class ofstream: public ostream, public fstream
{
public:
	inline ofstream()
		: ostream(),
		fstream()
	{
	}
	inline ofstream(const char name[], int flags=ios::out)
		: ostream(),
		fstream(name, flags)
	{
		assert(flags&ios::out || flags&ios::app);
		assert((flags&ios::in) == 0);
	}
	virtual ~ofstream()
	{
		close();
	}
	inline void open(const char name[], int flags)
	{
		assert(flags&ios::out || flags&ios::app);
		assert((flags&ios::in) == 0);
		fstream::open(name, flags);
	}

private:
	ofstream& operator=(ofstream&);// Forbidden.
	ofstream(ofstream&);// Forbidden.
};

#endif // PLATFORM_HAS_FILESYSTEM

///////////////////////

istream cin;

#ifdef UNDER_CE
	ostream cout(logfile_stdout);
	ostream cerr(logfile_stderr);
#else
	ostream cout(standard_stdout);
	ostream cerr(standard_stderr);
#endif

///////////////////////

#endif // _INCLUDED_L3_MINIIOSTREAM_H