c++生成与读取二进制文件

代码

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

//读取int32类型的数据 
void read_int32(char * addr, int size){
	int* data = new int[size];
    //read
    std::ifstream inF(addr, std::ios::binary);
    inF.read(reinterpret_cast<char*>(data), sizeof(int) * (size));
    inF.close();
 
    std::cout << "read bin file start" << std::endl;
    for(int i=0; i<10; i++){
        std::cout << i << ": "<< data[i] << std::endl;
    }
    for(int i=size-10; i<size; i++){
    	std::cout << i << ": "<< data[i] << std::endl;
	}
	std::cout << "read bin file end" << std::endl;
} 
//读取int64类型的数据 
void read_int64(char * addr){
	long long* data = new long long[4*1024];
    std::cout<<"数据类型大小 long long:" << sizeof(long long) <<std::endl;
    //read
    std::ifstream inF(addr, std::ios::binary);
    inF.read(reinterpret_cast<char*>(data), sizeof(long long) * (4*1024));
    inF.close();
 
    std::cout << "read bin file" << std::endl;
    for(int i=0; i<10; i++){
        std::cout << i << ": "<< data[i] << std::endl;
    }
    for(int i=1024-10; i<1024; i++){
    	std::cout << i << ": "<< data[i] << std::endl;
	}
}
//生成int32类型的数据
void gen_data_int32(char * addr, int size){
	if(size <= 64 * 1024){
		int data[size];
        for(int i=0; i<size; i++){
        	data[i] = size-1-i;	//64*1024-1, 64*1024-2, 64*1024-3, ...., 3, 2, 1, 0 
    	}
    	std::ofstream outF(addr, std::ios::binary);
    	outF.write(reinterpret_cast<char*>(data), sizeof(data));
 
    	outF.close();
	}else{
		std::ofstream outF(addr, std::ios::binary|std::ios::app);
		int part = size / (64 * 1024);
    	for(int i=0; i<part; i++){
    		int data[64*1024];
	    	for(int j=0; j<64*1024; j++){
	        	data[j] = 64*1024-1-j + (64*1024*i);
	    	}
        	outF.write(reinterpret_cast<char*>(data), sizeof(data));   
		}
    	outF.close();
	}
	
} 

void gen_data_int64(char * addr, int size){
	if(size <= 64 * 1024){
		long long data[size];
    	for(int i=0; i<size; i++){
        	data[i] = (long long)(size-1-i);
    	}
    	std::ofstream outF(addr, std::ios::binary);
    	outF.write(reinterpret_cast<char*>(data), sizeof(data));
 		outF.close();
	}else{
		std::ofstream outF(addr, std::ios::binary|std::ios::app);
    	for(int i=0; i<(size/(64*1024)); i++){
    		long long data[64*1024];
	    	for(int j=0; j<64*1024; j++){
	        	data[j] = (long long)(64*1024-1-j + (64*1024*i));
	    	}
        	outF.write(reinterpret_cast<char*>(data), sizeof(data));   
		}
    	outF.close();
	}
	
}

int main(){
	
	char * int32_512b = "test_int32_512b.bin";
	gen_data_int32(int32_512b, 512/4);
	read_int32(int32_512b, 512/4);
	
	char * int32_1k = "test_int32_1k.bin";
	gen_data_int32(int32_1k, 1024/4);
	
	char * int32_4k = "test_int32_4k.bin";
	gen_data_int32(int32_4k, 4*1024/4);
	
	char * int32_8k = "test_int32_8k.bin";
	gen_data_int32(int32_8k, 8*1024/4);
	
	char * int32_16k = "test_int32_16k.bin";
	gen_data_int32(int32_16k, 16*1024/4);
	
	char * int32_32k = "test_int32_32k.bin";
	gen_data_int32(int32_32k, 32*1024/4);
	
	char * int32_64k = "test_int32_64k.bin";
    gen_data_int32(int32_64k, 64*1024/4);

	char * int32_128k = "test_int32_128k.bin";
	gen_data_int32(int32_128k, 128*1024/4);
	//read_int32(int32_128k, 128*1024);
	
	char * int32_256k = "test_int32_256k.bin";
	gen_data_int32(int32_256k, 256*1024/4);
	
	char * int32_512k = "test_int32_512k.bin";
	gen_data_int32(int32_512k, 512*1024/4);
	
	char * int32_1m = "test_int32_1m.bin";
	gen_data_int32(int32_1m, 1024*1024/4);
	
	char * int32_2m = "test_int32_2m.bin";
	gen_data_int32(int32_2m, 2*1024*1024/4);
	
	char * int32_8m = "test_int32_8m.bin";
	gen_data_int32(int32_8m, 8*1024*1024/4);
	
	
	char * int64_512b = "test_int64_512b.bin";
	gen_data_int64(int64_512b, 512/8);
	
	char * int64_1k = "test_int64_1k.bin";
	gen_data_int64(int64_1k, 1024/8);
	
	char * int64_4k = "test_int64_4k.bin";
	gen_data_int64(int64_4k, 4*1024/8);
	
	char * int64_8k = "test_int64_8k.bin";
	gen_data_int64(int64_8k, 8*1024/8);
	
	char * int64_16k = "test_int64_16k.bin";
	gen_data_int64(int64_16k, 16*1024/8);
	
	char * int64_32k = "test_int64_32k.bin";
	gen_data_int64(int64_32k, 32*1024/8);
	
	char * int64_64k = "test_int64_64k.bin";
    gen_data_int64(int64_64k, 64*1024/8);

	char * int64_128k = "test_int64_128k.bin";
	gen_data_int64(int64_128k, 128*1024/8);
	
	char * int64_256k = "test_int64_256k.bin";
	gen_data_int64(int64_256k, 256*1024/8);
	
	char * int64_512k = "test_int64_512k.bin";
	gen_data_int64(int64_512k, 512*1024/8);
	
	char * int64_1m = "test_int64_1m.bin";
	gen_data_int64(int64_1m, 1024*1024/8);
	
	char * int64_2m = "test_int64_2m.bin";
	gen_data_int64(int64_2m, 2*1024*1024/8);
	
	char * int64_8m = "test_int64_8m.bin";
	gen_data_int64(int64_8m, 8*1024*1024/8);
	
	return 0;
}