CODE:

#include 
#include 
#include 
#include 

using namespace std;

struct addsize{
	void * myadd;
	long mysize;
	string * stradd;
	bool addmode;

	addsize(){}

	void strinit(string & input, long size){
		stradd = &input;
		addmode = true;
		mysize = size;
	}
	addsize(string &input, long size){ strinit(input, size); }
	addsize(string &input){ strinit(input, -1); }

	template 
	void init(X & address, long size){
		addmode = false;
		myadd = address;
		mysize = size;
	}
	template 
	addsize(X & address, long size){ init(address, size); }
	template 
	addsize(X & address){ init(address, -1); }
};

struct addsizeref :public addsize{
	addsizeref(string &input, long & size){ strinit(input, size); }

	template 
	addsizeref(X & address, long & size){ init(address, size); }
};

struct cls{};

class bfilew{
	bool crePerm;

protected:

	bool wstate;
	ofstream ofs;
	string fName;

public:

	bfilew(){}
	bool init(const string &fileName, bool createPermission = true){
		wstate = true;
		if(!createPermission && GetFileAttributes(fileName.c_str() )!=-1) wstate = false;
		if(!wstate) return false;
		fName = fileName;
		crePerm = createPermission;

		ofs.open(fileName.c_str(), ios::binary|ios::app);

		if(!ofs){ wstate=false; return false; }
		return true;
	}
	bfilew(const string &fileName, bool createPermission = true){ init(fileName, createPermission); }

	bool fell(){ return !wstate; }

	bfilew & clear(){
		if(!wstate) return *this;
		ofs.close();
		ofs.open(fName.c_str(), ios::binary);
		return *this;
	}

	bfilew & operator! (){
		clear();
		return *this;
	}

	bfilew & operatorsubstr(0, output.mysize).c_str();
		else ofs.write( (const char *)output.myadd, output.mysize);
		return *this;
	}

	template 
	bfilew & operator content;
	int contPoint;
	size_t unsint;
	bool rstate;

public:

	bfile(){}
	bool init2(const string &fileName, bool createPermission = true){
		rstate = true;
		if(!createPermission && GetFileAttributes(fileName.c_str() )!=-1) return rstate = false;

		contPoint = 0;
		unsint = 0;

		ifstream ifs(fileName.c_str(), ios::binary);
		int contNum = 0;
		while(!ifs.eof() ){
			content.resize(contNum+1);
			ifs.read( (char*)&(content[contNum]), sizeof(char) );
			contNum++;
		}

		rstate = init(fileName, createPermission);

		return rstate;
	}
	bfile(const string &fileName, bool createPermission = true){ init2(fileName, createPermission); }

	bool fell(){
		if(wstate || rstate) return false;
		return true;
	}
	bool wfell(){ return !wstate; }
	bool rfell(){ return !rstate; }

	template 
	bfile & read (X &input){
		if(!rstate) return *this;
		memcpy(&input, &content[0]+contPoint, sizeof(input) );
		contPoint += sizeof(input);
		return *this;
	}

	bfile & operator>> (addsize &input){
		if(!rstate) return *this;

		if(input.addmode){
			char c;
			size_t num = input.mysize;
			if(input.mysize==-1) num = unsint;
			*(input.stradd) = "";
			for(size_t i=0;i> (string & input){
		*this >> addsize(input, (long &)unsint);
		return *this;
	}

	template 
	bfile & operator>> (X &input){
		read(input);
		if(sizeof(unsint) >= sizeof(input) ){
			unsint = 0;
			memcpy(&unsint, &input, sizeof(input) );
		}
		return *this;
	}
};