C++读取文件ecg还行吧，就是内存还不够优化，有时间在改改；；文件的读写

int** read_datas(char *filename, int *len)

{
int *data;
int **ecgdata;
FILE *pfile = NULL;
int length;
short tmp = 0;
int i;
int m;

fopen_s(&pfile, filename, "rb");
if (pfile == NULL)
{
printf("Can't open file: %s", filename);
return NULL;
}
fseek(pfile, 0L, SEEK_END);
length = ftell(pfile);
fseek(pfile, 0L, 0);

*len = length * 2 / sizeof(short);
data = (int *)malloc(sizeof(int) * (*len));
unsigned char *char_data = (unsigned char *)malloc(sizeof(unsigned char) * (*len));
if (data == NULL)
{
printf("out of memory.\n");
return NULL;
}

int dataNum = fread(char_data, 1, *len, pfile);
//将char类型的数据转换为int类型
for (int i = 0; i < dataNum; i++)
{
data[i] = char_data[i];
}
fclose(pfile);
//4s数据的长度4144   头文件+ 数据文件
int top_length = 48 * (*len / 4144);
//剩余数据的总长度
int data_lengths = 4096 * (*len / 4144);
//每一导联的数据的长度是
int lead_length = data_lengths / 4;
ecgdata = new int *[lead_length];
if (ecgdata == NULL)
{
printf("out of memory\n");
return NULL;
}

//4导联的数据
for (i = 0; i < lead_length; i++)
ecgdata[i] = new int[4];
//将每一个导联的数据均读出来
int j1 = 0, j2 = 0, j3 = 0, j4 = 0;
for (m = 0; m < *len / 4144; m++)   //一共有多少个4s段
{
int beign1 = m * 4144 + 48;//一段数据的开始
int end1 = (m + 1) * 4144; //一段数据的结束
int k = 0;
for (int i = beign1; i < end1; i++)
{
if (k == 0)
{
ecgdata[j1][k] = data[i];
j1++;
k++;
}
else if (k == 1)
{
ecgdata[j2][k] = data[i];
j2++;
k++;
}
else if (k == 2)
{
ecgdata[j3][k] = data[i];
j3++;
k++;
}
else if (k == 3)
{
ecgdata[j4][k] = data[i];
j4++;
k = 0;
}
}
}
free(char_data);
free(data);
*len = lead_length;    //返回每一个导联数据的长度
return ecgdata;
}

2，文件的写：

1）

size_t fwrite(const void* buffer, size_t size, size_t count, FILE* stream);
功能：向文件写入一个数据块(以二进制形式对文件进行操作，不局限于文本文件)
返回值：返回实际写入的数据块数目
参数说明：
1. buffer：要获取数据的地址；
2. size：要写入内容的单字节数；
3. count:要进行写入size字节的数据项的个数；
4. stream:目标文件指针；
注意：fwrite函数写到用户空间缓冲区，并未同步到文件中，所以修改后要将内存与文件同步可以用fflush（FILE *fp）函数同步

2）fprintf:根据指定的format格式发送信息参数到有stream指定的文件。成功返回输出的字符数，失败返回负值。

#include <stdio.h>
int fprintf( FILE *stream, const char *format, ... );

3）

 fwrite与fprintf的区别

1. fprintf(fp, "%d", buffer); 是将格式化的数据写入文件
fwrite(&buffer, sizeof(int),1, fp);是以二进位方式写入文件
2. fprintf写文本文件，用记事本可以打开查看
fwrite写二进制文件
3. fprintf写入时，对于整数来说，一位占一个字节，比如1，占1个字节；10，占2个字节；
所以文件的大小会随数据的大小而改变，对大数据空间占用很大。
fwrite是按二进制写入，写入数据所占空间是根据数据类型来确定，所以二进制写入比格式化写入更省空间

使用ifstream进行读取数据内容：

 string file_path = file_name + file_id + ".hea";
std::ifstream heafs(file_path.c_str());
vector<string> head_lines;
string line;
while (std::getline(heafs, line))
{
head_lines.push_back(line);
}
heafs.close();

使用ifstream，按照行的形式，每次读取一行，将内容存进vector

2，std::unique_ptr<char[]> ReadFileData(char const * file_name, int *file_len)

{
FILE *pfile = NULL;
pfile = fopen(file_name, "rb");

fseek(pfile, 0, SEEK_END);
size_t nFileLen = ftell(pfile);

fseek(pfile, 0, SEEK_SET);

std::unique_ptr<char[]> buf_data(new char[nFileLen]);  //生成单一的指针，这一块内存只有一个指针指向他
fread(buf_data.get(), 1, nFileLen, pfile);
fclose(pfile);
*file_len = nFileLen;
return buf_data;

}
vector<shared_ptr<float>> lead_datas;
for (int i = 0; i < lead_num; i++) {
shared_ptr<float> data_buf(new float[lead_data_len], std::default_delete<float[]>());
lead_datas.push_back(data_buf)
}共享内存生成空间，
std::unique_ptr<char[]> buf_data(new char[nFileLen]);  //单一智能指针生成空间。这是经常用到的两种方式

vector<shared_ptr<float>> lead_all_datas = std::get<0>(ret_tp); //这个是取得的vector
for (int j = 0; j < piece_count; j++) {
//读取文件到字符串中
vector<float*> lead_piece_datas;
for (int ii = 0; ii < lead_names.size(); ii++) {
lead_piece_datas.push_back(lead_all_datas[ii].get() + piece_len *j); //这里使用指针，取什么数据从什么位置开始存，使用指针，不用申请空间，比较节省空间
}
//进行其他的操作
}

//写入文件中
ofstream outfile;
string out_xml_file1 = out_file_path + std::to_string(piece_ind) + ".xml";
outfile.open(out_xml_file1, ios::out | ios::trunc);
outfile << content;
outfile.close();