プログラマ専用SNS ミクプラ

コード:

#include <stdio.h>
#include <bitset>
#include <fstream>
#include <string>
#include <vector>
#include <windows.h>

using namespace std;

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

	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 <typename X>
	void init(X & address, long size){
		addmode = false;
		myadd = address;
		mysize = size;
	}
	template <typename X>
	addsize(X & address, long & size){ init(address, size); }
	template <typename X>
	addsize(X & address){ init(address, -1); }
};

class bfilew{
	string fName;
	bool crePerm;
	ofstream ofs;

public:

	bool state;

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

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

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

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

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

	bfilew & operator<< (const char * output){
		if(!state) return *this;
		ofs.write(output, strlen(output)*sizeof(char) );
		return *this;
	}

	bfilew & operator<< (const string & output){
		*this << output.c_str();
		return *this;
	}

	bfilew & operator<< (const addsize & output){
		if(!state) return *this;
		if(output.addmode) *this << output.stradd->substr(0, output.mysize).c_str();
		else ofs.write( (const char *)output.myadd, output.mysize);
		return *this;
	}

	template <typename X>
	bfilew & operator<< (const X &output){
		if(!state) return *this;
		ofs.write( (const char *)&output, sizeof(output) );
		return *this;
	}

	bfilew & close(){ ofs.close(); }
};

class bfile : public bfilew{
	vector<char> content;
	int contPoint;
	size_t unsint;

public:

	bfile(){}
	bool init2(const string &fileName, bool createPermission = true){
		state = true;
		if(!createPermission && GetFileAttributes(fileName.c_str() )!=-1) return state = 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++;
		}

		state = init(fileName, createPermission);

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

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

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

		if(input.addmode){
			char c;
			size_t num = input.mysize;
			if(input.mysize==-1) num = unsint;
			for(size_t i=0;i<num;i++){
				read(c);
				*(input.stradd) += c;
			}
		}
		else{
			size_t size = input.mysize;
			if(input.mysize==-1) size = unsint;
			memcpy(input.myadd, &content[0]+contPoint, size);
			contPoint += size;
		}

		return *this;
	}

	bfile & operator>> (string & input){
		*this >> addsize( (string &)input, (long)unsint);
		return *this;
	}

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