1 视图形式

不同的二进制文件需要不同的软件来打开，例如BMP文件，需要一个读图的软件来打开才能看到里面保存的图像，MP3文件需要一个播放器软件才能听到里面的音频。而文本文件只需要记事本就可以打开查看里面的内容。

 2 存储形式

二进制文件里存储的东西是二进制数据，就是01串。而文本文件中存储的是字符串，比如汉字。这点是从逻辑层面上所说的，不完全正确，但是便于理解，下面我会进阶的细说这里。

3 性能

 二进制文件的读写速度非常快，因为它就是将数据在内存中的存储形式（二进制）原模原样放到文件中，读出来的东西不需要经过处理就可以直接放到内存中去用，但是这些二进制串我们是看不懂也处理不了的，所以就需要专门的解码软件来处理，才能将信息显现到我们面前，所以说二进制文件的读写比较快，但是对于我们程序员来说，可读性差。

 而文本文件首先有一个编码方式，例如ASCII或者Unicode，当我们要存一些东西时，会先用一定的编码方式将这些东西转为对应的编码，再将这个编码写进文件里，读的时候要先解码，才能将对应的字符显示出来，所以读写比较慢，但是读出来的东西是字符串，我们能看懂，可读性比较好。

4 拓展

 1 为什么记事本打开二进制文件会乱码？

        再详细说一下文本文件的存储过程：数据在内存中都是以二进制存储的，所以要先从内存中将数据的二进制取出来，用ASCII（或Unicode）编码方式将其编码，再将这个编码存进文件中。特别有趣的地方就是：如果这些数据是字符，那么他们在内存中本身就是按ASCII码编好的，所以存进文件文件时不需要再进行编码了，也是原模原样将内存中的东西放进了文件中（与二进制文件存储方式一样是不是？）。但如果不是字符型数据，例如int i=10，他在内存中存的是10的二进制：1010，这个二进制经过ASCII编码之后，再解码出来肯定就不是10了。

        这就解释了为什么用记事本打开二进制文件时会乱码的问题。首先记事本也是一种解码软件，但他是按ASCII或者Unicode来解码的，他会按自己的方式给二进制文件来解码并显示字符。所以用记事本打开二进制文件时，也不会全部乱码，仔细看那些用字符串形式存的数据肯定不会乱码。

2 文本文件也是二进制文件

        刚才说了在逻辑层面上：文本文件存的是字符，二进制文件存的是二进制数据。其实在物理层面上讲，我们的硬盘只能存储二进制。所以广义上讲文本文件也是二进制文件，只不过文本文件里只能存字符型数据，而字符型数据经过ASCII或Unicode解码之后我们能看懂。

        换一个角度想，所有二进制文件在硬盘上都是01串，我们都看不懂，所以需要一个解码软件将这堆二进制转换成我们想要的信息形式。所以这时就回到了文本文件和二进制文件的最表象区别：解码软件不同！用记事本打开二进制文件会乱码，而二进制的解码软件基本都打不开文本文件。

5 总结

        在实际存储中最好是将数据分成字符数据和非字符数据两类：

        如果存储的是字符数据，无论采用文本文件还是二进制文件都是没有任何区别的，这点上面解释过了。

        如果存储的是非字符数据，那么就要看我们使用的情况来决定：

        1、如果是需要频繁的保存和访问数据，那么应该采取二进制文件进行存放，这样可以节省存储空间和转换时间。

        2、如果需要频繁的向终端显示数据或从终端读入数据，那么就将这些数据转为字符串型，采用文本文件进行存放，这样可以节省转换时间。

c++读写文本文件
// 写
std::ofstream fout("a.txt");
int nNum = 20;
std::string str("hello");
fout << nNum << "," << std << std::endl;
fout.close()

// 读文本文件
std::ifstream fin("a.txt");
int nNum;
char szBuf[256] = {0};

fin >> nNum >> szBuf;
fin.close();

c++读写二进制文件
#include <fstream>

// 写二进制
std::ofstream fout("data.dat", std::ios::binary);
int nNum = 20;
int a[5] = {1, 2, 3, 4, 5};
std::string str("hello, world");

fout.write((char*)&nNum, sizeof(int));
fout.write(reinterpret_cast<const char*>(a), sizeof(int)*5);
fout.write(str.c_str(), sizeof(char)*(str.size()));
fout.close();

// 读二进制文件
std::ifstream fin("data.dat", std::ios::binary);
int nNum;
int b[5];
char szBuf[256] = {0};

fin.read((char*)&nNum, sizeof(int));
fin.read(reinterpret_cast<char*>(b), sizeof(int)*5);
fin.read(szBuf, sizeof(char) * 256);
fin.close();

参考：C++读写二进制文件
// 获取文件的大小
ifstream fin;
fin.open("test.jpg", ios::binary | ios.ate);
long size = fin.tellg();

参考：[C++]读写二进制文件和文本文件
python读写文本文件
f = open('test.txt')
f.read()
f.close()

f.readline() # 整行读取数据，若没读取到数据则返回空
f.readlines() # 将文件内容以列表形式存放
f.next() # 和f.readline()相似，逐行读取数据，若没读取到数据则报错

# 写入txt, 文件如果存在会先清空再写入
f = open('test.txt', 'w', buffering=1) # 行缓冲，python3文本读写不能使用无缓冲，但二进制写可以使用buffering=0
f.write('hello')
f.close()

f.writelines(['\nhello dear!', '\nhello baby!']) # 多行写入


参考：Python读写txt文本文件
python读写二进制文件

np.save & np.load 将数组以未压缩的原始二进制格式保存在扩展名为 npy 的文件中

np.save('name.npy', data)
data = np.load('name.npy')


tofile & fromfile 读写二进制文件。文件后缀名没有要求，且读取数据需要指定 dtype ，需要与保存时的类型一致。

data.tofile("data.bin")
data = np.fromfile("data.bin", dtype=np.float32)

参考：Numpy数组的保存与读取

    
参考博客：
C++二进制文件的读取和写入（精华版） （先看且全看）
C/C++读写文本文件、二进制文件 （我只看了 五）
13.14C++对二进制文件的读写操作 （很好，可只看读写部分）
 
学习此内容的目的是我需要将原本存储内容的csv文件转移至dat二进制文件
在test5000.csv中保存了5000*128的float数
 
写入binary.dat

#include <iostream>

#include <fstream>

#include <string>
#include <vector>
#include<algorithm>
using namespace std;
 
vector<vector<float> >a;  //��ά����洢�������
vector<float>b;

inline void file_to_string(vector<string> &record, const string& line, char delimiter);

inline float string_to_float(string str);

void read()
{
    vector<string> row;
    string line;
    string filename;
    ifstream in("test5000.csv");  
    if (in.fail())  { cout << "File not found" <<endl; return ; } 
    while(getline(in, line)  && in.good() )
    {
        file_to_string(row, line, ',');  //��line��ĵ�Ԫ�������ַ���ȡ��������,��Ϊ��Ԫ��ָ���
        for(int i=0, leng=row.size(); i<leng; i++){
            b.push_back(string_to_float(row[i]));
        }
        a.push_back(b);
        b.clear();
    }
    in.close();
    return ;
}


inline void file_to_string(vector<string> &record, const string& line, char delimiter)
{
    int linepos=0;
    char c;
    int linemax=line.length();
    string curstring;
    record.clear();
    while(linepos<linemax)
    {
        c = line[linepos];
        if(isdigit(c)||c=='.'){
            curstring+=c;
        }
        else if(c==delimiter&&curstring.size()){
            record.push_back(curstring);
            curstring="";
        }
        ++linepos;
    }
    if(curstring.size())
        record.push_back(curstring);
    return;
}
 

inline float string_to_float(string str){
    int i=0,len=str.length();
    float sum=0;
    while(i<len){
        if(str[i]=='.') break;
        sum=sum*10+str[i]-'0';
        ++i;
    }
    ++i;
    float t=1,d=1;
    while(i<len){
        d*=0.1;
        t=str[i]-'0';
        sum+=t*d;
        ++i;
    }
    return sum;
}


int main(){
    read();
    printf("total numbers of people: %d\n",a.size());
    vector<float> fea;
    ofstream outFile("binary.dat", ios::out | ios::binary);
    for (int i=0; i<a.size(); i++){
        fea = a[i];
        outFile.write((char*)&fea[0], 128*sizeof(float));
    }
    outFile.close();
    return 0;
}

View Code

ofstream outFile("binary.dat", ios::out | ios::binary);
for (int i=0; i<a.size(); i++){
　　fea = a[i];
　　outFile.write((char*)&fea[0], 128*sizeof(float));
}
outFile.close();


a为vector<vector<float> >类型
fea为vector<float> 类型
 
读binary.dat

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

int main(){
    ifstream inFile("binary.dat", ios::in | ios::binary);
    if(!inFile){
        cout<< "error" <<endl;
        return 0;
    }
    float fea[128];
    int n=0;
    while(inFile.read((char *)&fea[0], 128*sizeof(float))){
        //print dim1 of each img
        n++;
    }
    inFile.close();
    
    cout<<n<<endl;
    for(int i=0;i<128;i++)
        cout<<fea[i]<<" ";
    return 0;
}


可以看到确实读出了这5000个向量，并存进了float数组
 
以上为测试内容，下面为我实际使用的情况
我在尝试过程中结构体内使用了向量和string，结果报错，我猜测这里的数据类型需要确定，尽量用数组，这样可以准确的算出字节数。

class Face{
　　public:
　　　　float fea[128];
　　　　char name[30];
};

读取图片保存至binary.dat二进制文件

//write binary.dat
void img2dat(){
    struct dirent *ptr, *ptr1;
    DIR *dir, *dir1;
    dir = opendir("../lfw_crop/");

    string file_path, temp;
    std::vector<Anchor> result_copy;
    int num = 0,count = 1;
    ofstream outFile("binary.dat", ios::out | ios::binary);
    Face face_temp[6000];

    // printf("lists of files:\n");
    while((ptr = readdir(dir)) != NULL){
        if(ptr->d_name[0] == '.')
            continue;

        //search subdirectory
        char sub_dir[50] = "../lfw_crop/";
        strcpy(face_temp[num].name, ptr->d_name);
        strcat(sub_dir, ptr->d_name);
        file_path = sub_dir;
        dir1 = opendir(sub_dir);

        while((ptr1 = readdir(dir1)) != NULL){
            if(ptr1->d_name[0] == '.')
                continue;

            temp = ptr1->d_name;
            file_path = file_path + "/" + temp;

            cv::Mat img = imread(file_path);
            count = 1;
            cout<<temp<<endl;
            Mat face = mt(img, result_copy, count);
            if (count){
                fea = extract_feature(face);
                for(int i=0;i<128;i++)
                    face_temp[num].fea[i] = fea[i];
                outFile.write((char*)&face_temp[num], sizeof(face_temp[num]));
                cout<<++num<<endl;
            }
            //just one img
            break;
        }
        closedir(dir1);
    }
    closedir(dir);
    outFile.close();
}

View Code
读binary.dat并进行特征比对

if(count)
        {
            clock_t start_2, finish_2;
            start_2 = clock();
            vector<float> feature2 = extract_feature(face2);
            finish_2 = clock();

            cout << "mobilefacenet cost " << (float)(finish_2 - start_2) / CLOCKS_PER_SEC * 1000 << " ms" << endl;
            
            //2019.6.12
            int i=0, num=0;
            double curcal, max=0;
            string forecast_name;

            //2019.6.17
            // float fea[128];
            string name;
            clock_t start_3, finish_3;
            start_3 = clock();
            Face face_temp[6000];
            while(inFile.read((char *)&face_temp[num], sizeof(face_temp[num]))){
                curcal = calculSimilar(feature2, face_temp[num].fea);
                if(curcal > max){
                    max = curcal;
                    forecast_name = face_temp[num].name;
                } 
               }
            finish_3 = clock();

            cout << "search binary.dat cost & calculSimilar:" << (float)(finish_3 - start_3) / CLOCKS_PER_SEC * 1000 << " ms" << endl;
            cout << "max similarity is: "<< max << endl;
            cout << "forecast name is: "<< forecast_name <<endl <<endl;
        }

View Code
 

转载于:https://www.cnblogs.com/exciting/p/11041996.html

    文本文件与二进制文件我的体会总结如下：
    1.文本文件与二进制文件的区别存在于逻辑层面上，即文件的编码翻译方式不一，但是在磁盘上的物理文件，都是以二进制形式保存的。
    2.在访问和读写文件时会才会产生两种文件的区分，用文本方式打开，用fgets,fputs之类的文件I/O访问就是文本文件，而用fread/fwrite等文件I/O访问就是二进制文件。
    3.unix和DOS的文本文件的区分在于回车换行，unix是'/n'而DOS则是"/r/n",所以DOS文本输出到控制台时需要把"/r/n"转换成"/n"（控制台回车符是"/n"），而unix则不需要。
    4.为什么unix中使用fopen时，字符b作为type的一部分实际上无用？参考3，这是因为这两种方式在读写文件时的操作是不一样的。二进制方式很简单，读文件时，会原封不动的读出文件的全部內容，写的時候，也是把內存缓冲区的內容原封不动的写到文件中。而文本方式就不一样了，在读文件时，会将换行符号CRLF(0x0D 0x0A)全部转换成单个的0x0A，并且当遇到结束符CTRLZ(0x1A)时，就认为文件已经结束。相应的，写文件时，会将所有的0x0A换成0x0D0x0A。由于DOS/Windows定义的换行符和C语言的不一致，C语言的标准输入输出函数适行读写文本文件时，就适行了CRLF->LF的转换。而Unix的定义和C语言的是一样的，就不必转换了。