[已解决]文件的定位读写问题，请各位大佬解惑

两手空空儿

我的设想是用一个文件来存放员工的【人数】和【员工信息】，添加或者删除时再更新文件的内容，示例代码如下

1. 
   
2. #include <iostream>
   
3. #include <fstream>
   
4. #include <string>
   
5. #define FILE "save.txt"
   
6. 
   
7. using namespace std;
   
8. 
   
9. class Employee{
   
10. public:
    
11.         //
    
12.         Employee(int num, string name, int age):m_number(num), m_name(name), m_age(age){               
    
13.         }
    
14.         //
    
15. //private:
    
16.         int m_number;
    
17.         string m_name;
    
18.         int m_age;               
    
19. };
    
20. 
    
21. int main(void)
    
22. {
    
23.         int cnt = 2; //员工的数量
    
24.         Employee emp[2] =  {
    
25.                 {11, "张三", 25},
    
26.                 {12, "李四", 33}};       
    
27.         //写入数据
    
28.         ofstream ofs(FILE, ios::out);
    
29.         ofs << cnt << endl;
    
30.         ofs << emp[0].m_number << " " << emp[0].m_name << " " << emp[0].m_age << endl;
    
31.         ofs << emp[1].m_number << " " << emp[1].m_name << " " << emp[1].m_age << endl;
    
32.         ofs.close();
    
33.        
    
34.         //增加数据，问题来了。。。。。。。。。。。。。。
    
35.         //单独写入cnt， 再往文件尾追加员工信息
    
36. 
    
37.         return 0;
    
38. }
    

复制代码

在文件中,2（cnt）这个数字是以字符形式存放的，只占文件的1个位置， cnt = 10时，就会占两个位置
随着人数的增加，当cnt为两们数，叁位数，或者更多时，
   ofs << cnt << endl; 这一句会覆盖第一位员工的数据，
怎么才能解决这个问题？难道只能每次更新数据的时候把所有数据读出来，再重新写入一次？
（用另外的文件单独存放cnt是可以的，但是我不想分开存放）       
有没有一种方法，让文件的开头给cnt留出足够的位置，在这之后再写入员工数据
比如 cnt是 int类型，4个字节，就用4个位置用内存的形式放进去，
或者是其它什么方法

最佳答案

月排行榜 / 总排行榜

dolly_yos2

2023-1-29 22:10:22

两手空空儿 发表于 2023-1-29 21:54
多放很多空格会不会影响后面数据的读取？
怎么在打开文件后直接定位到第一个员工的数据的开头呢?  
是 ...

C++ 标准库的输出流可以用 std::setw 来设置位宽，自动填充空格
先输入数量时会自动跳过前缀空白字符，应该不会影响后续读取？
不过还是建议用二进制，二进制指的是用 std::basic_ostream<CharT,Traits>::write 或类似方法直接把这个变量的内存表示写进文件，这个长度（基本）是固定的，如果配合 uint32_t 之类的类型使用则可以保证其写入文件必然是 32 / CHAR_BIT 个（通常是 4 个）字节，通常也不需要做填充之类的操作

跳转到最佳答案楼层

dolly_yos2

可以插空格之类的字符填充预留的位置吧
另外如果不需要保持生成文件人类可读，可能用二进制存储这个数量也是不错的选择

两手空空儿

dolly_yos2 发表于 2023-1-29 21:36
可以插空格之类的字符填充预留的位置吧
另外如果不需要保持生成文件人类可读，可能用二进制存储这个数量也 ...

多放很多空格会不会影响后面数据的读取？
怎么在打开文件后直接定位到第一个员工的数据的开头呢?  
是不是只能在初始创建文件时就把10个空格放进去，
要是先写入cnt，再补空格，这个操作有点管繁琐，还要计算每次要补多少个空格， 一个空格占两们位置，当cnt为奇数位时，写入cnt之后的读取是不是也会不准确？

二进制存储也是会覆盖后面数据的吧， 用二进制的方式，空格来占位好像还行，我试试

人造人

不要用ascii写，用二进制写

1. sh-5.1$ cat main.cpp
   
2. #include <iostream>
   
3. #include <fstream>
   
4. #include <string>
   
5. 
   
6. using namespace std;
   
7. 
   
8. class Employee {
   
9. public:
   
10.     Employee(int num = 0, const string &name = "", int age = 0): number(num), name(name), age(age) {}
    
11.     friend ostream &operator<<(ostream &os, const Employee &e) {
    
12.         return os << e.number << " " << e.name << " " << e.age;
    
13.     }
    
14.     friend ofstream &operator<<(ofstream &ofs, const Employee &e) {
    
15.         ofs.write((char *)&e.number, sizeof(e.number));
    
16.         size_t size = e.name.size();
    
17.         ofs.write((char *)&size, sizeof(size));
    
18.         ofs.write(e.name.c_str(), size);
    
19.         ofs.write((char *)&e.age, sizeof(e.age));
    
20.         return ofs;
    
21.     }
    
22.     friend ifstream &operator>>(ifstream &ifs, Employee &e) {
    
23.         ifs.read((char *)&e.number, sizeof(e.number));
    
24.         size_t size; ifs.read((char *)&size, sizeof(size));
    
25.         char buff[size]; ifs.read(buff, size);
    
26.         e.name = string(buff, buff + size);
    
27.         ifs.read((char *)&e.age, sizeof(e.age));
    
28.         return ifs;
    
29.     }
    
30. private:
    
31.     int number;
    
32.     string name;
    
33.     int age;
    
34. };
    
35. 
    
36. int main(void) {
    
37.     Employee emp[2] = {{11, "张三", 25}, {12, "李四", 33}};
    
38.     ofstream ofs("data.dat");
    
39.     ofs << emp[0] << emp[1];
    
40.     ofs.close();
    
41.     ifstream ifs("data.dat");
    
42.     Employee buff[2];
    
43.     ifs >> buff[0] >> buff[1];
    
44.     ifs.close();
    
45.     cout << buff[0] << std::endl;
    
46.     cout << buff[1] << std::endl;
    
47.     return 0;
    
48. }
    
49. sh-5.1$ ./main
    
50. 11 张三 25
    
51. 12 李四 33
    
52. sh-5.1$
    

复制代码

人造人

1. sh-5.1$ cat main.cpp
   
2. #include <iostream>
   
3. #include <fstream>
   
4. #include <string>
   
5. 
   
6. using namespace std;
   
7. 
   
8. class Employee {
   
9. public:
   
10.     Employee(int num = 0, const string &name = "", int age = 0): number(num), name(name), age(age) {}
    
11.     Employee(ifstream &ifs) {ifs >> *this;}
    
12.     friend ostream &operator<<(ostream &os, const Employee &e) {
    
13.         return os << e.number << " " << e.name << " " << e.age;
    
14.     }
    
15.     friend ofstream &operator<<(ofstream &ofs, const Employee &e) {
    
16.         ofs.write((char *)&e.number, sizeof(e.number));
    
17.         size_t size = e.name.size();
    
18.         ofs.write((char *)&size, sizeof(size));
    
19.         ofs.write(e.name.c_str(), size);
    
20.         ofs.write((char *)&e.age, sizeof(e.age));
    
21.         return ofs;
    
22.     }
    
23.     friend ifstream &operator>>(ifstream &ifs, Employee &e) {
    
24.         ifs.read((char *)&e.number, sizeof(e.number));
    
25.         size_t size; ifs.read((char *)&size, sizeof(size));
    
26.         char buff[size]; ifs.read(buff, size);
    
27.         e.name = string(buff, buff + size);
    
28.         ifs.read((char *)&e.age, sizeof(e.age));
    
29.         return ifs;
    
30.     }
    
31. private:
    
32.     int number;
    
33.     string name;
    
34.     int age;
    
35. };
    
36. 
    
37. int main(void) {
    
38.     Employee emp[2] = {{11, "张三", 25}, {12, "李四", 33}};
    
39.     ofstream ofs("data.dat");
    
40.     ofs << emp[0] << emp[1];
    
41.     ofs.close();
    
42.     /*
    
43.     ifstream ifs("data.dat");
    
44.     Employee buff[2];
    
45.     ifs >> buff[0] >> buff[1];
    
46.     ifs.close();
    
47.     */
    
48.     ifstream ifs("data.dat");
    
49.     Employee buff[2] = {ifs, ifs};
    
50.     ifs.close();
    
51.     cout << buff[0] << std::endl;
    
52.     cout << buff[1] << std::endl;
    
53.     return 0;
    
54. }
    
55. sh-5.1$ ./main
    
56. 11 张三 25
    
57. 12 李四 33
    
58. sh-5.1$
    

复制代码

dolly_yos2

两手空空儿 发表于 2023-1-29 21:54
多放很多空格会不会影响后面数据的读取？
怎么在打开文件后直接定位到第一个员工的数据的开头呢?  
是 ...

C++ 标准库的输出流可以用 std::setw 来设置位宽，自动填充空格
先输入数量时会自动跳过前缀空白字符，应该不会影响后续读取？
不过还是建议用二进制，二进制指的是用 std::basic_ostream<CharT,Traits>::write 或类似方法直接把这个变量的内存表示写进文件，这个长度（基本）是固定的，如果配合 uint32_t 之类的类型使用则可以保证其写入文件必然是 32 / CHAR_BIT 个（通常是 4 个）字节，通常也不需要做填充之类的操作

两手空空儿

人造人 发表于 2023-1-29 22:03

谢谢大佬~~~
你的用法好高级，我要好好消化一下，
有没有哪个地方可以查询 标准类库的函数的地方，>>  <<   和 read, write  这些东西我要好好学习一下
还有string类内的函数，现在学的有点乱

人造人

1. sh-5.1$ cat main.cpp
   
2. #include <iostream>
   
3. #include <fstream>
   
4. #include <string>
   
5. #include <vector>
   
6. 
   
7. using namespace std;
   
8. 
   
9. class Employee {
   
10. public:
    
11.     Employee(int num = 0, const string &name = "", int age = 0): number(num), name(name), age(age) {}
    
12.     Employee(ifstream &ifs) {ifs >> *this;}
    
13.     friend ostream &operator<<(ostream &os, const Employee &e) {
    
14.         return os << e.number << " " << e.name << " " << e.age;
    
15.     }
    
16.     friend ofstream &operator<<(ofstream &ofs, const Employee &e) {
    
17.         ofs.write((char *)&e.number, sizeof(e.number));
    
18.         size_t size = e.name.size();
    
19.         ofs.write((char *)&size, sizeof(size));
    
20.         ofs.write(e.name.c_str(), size);
    
21.         ofs.write((char *)&e.age, sizeof(e.age));
    
22.         return ofs;
    
23.     }
    
24.     friend ifstream &operator>>(ifstream &ifs, Employee &e) {
    
25.         ifs.read((char *)&e.number, sizeof(e.number));
    
26.         size_t size; ifs.read((char *)&size, sizeof(size));
    
27.         char buff[size]; ifs.read(buff, size);
    
28.         e.name = string(buff, buff + size);
    
29.         ifs.read((char *)&e.age, sizeof(e.age));
    
30.         return ifs;
    
31.     }
    
32. private:
    
33.     int number;
    
34.     string name;
    
35.     int age;
    
36. };
    
37. 
    
38. const vector<Employee> load(const string &filename) {
    
39.     vector<Employee> result;
    
40.     ifstream ifs(filename);
    
41.     size_t size; ifs.read((char *)&size, sizeof(size));
    
42.     for(size_t i = 0; i < size; ++i) result.push_back(Employee(ifs));
    
43.     return result;
    
44. }
    
45. 
    
46. void save(const vector<Employee> &v, const string &filename) {
    
47.     ofstream ofs(filename);
    
48.     size_t size = v.size();
    
49.     ofs.write((char *)&size, sizeof(size));
    
50.     for(size_t i = 0; i < size; ++i) ofs << v[i];
    
51. }
    
52. 
    
53. ostream &operator<<(ostream &os, const vector<Employee> &v) {
    
54.     bool flag = false;
    
55.     for(size_t i = 0; i < v.size(); ++i) {
    
56.         if(flag) os << std::endl;
    
57.         flag = true;
    
58.         os << v[i];
    
59.     }
    
60.     return os;
    
61. }
    
62. 
    
63. int main(void) {
    
64.     {
    
65.         vector<Employee> emp = {{11, "张三", 25}, {12, "李四", 33}};
    
66.         save(emp, "data.dat");
    
67.     }
    
68.     vector<Employee> emp = load("data.dat");
    
69.     cout << emp << endl;
    
70.     return 0;
    
71. }
    
72. sh-5.1$ ./main
    
73. 11 张三 25
    
74. 12 李四 33
    
75. sh-5.1$
    

复制代码

两手空空儿

dolly_yos2 发表于 2023-1-29 21:36
可以插空格之类的字符填充预留的位置吧
另外如果不需要保持生成文件人类可读，可能用二进制存储这个数量也 ...

用二进制的方式 ，10个空格占位，这个方法是可行的

1. //写入数据
   
2.         ofstream ofs(FILE, ios::trunc | ios::binary);
   
3.         ofs << "          " <<endl;
   
4.         ofs.seekp(ios::beg);
   
5.         ofs << cnt;
   
6.         ofs.seekp(10);
   
7.         ofs << emp[0].m_number << " " << emp[0].m_name << " " << emp[0].m_age << endl;
   
8.         ofs << emp[1].m_number << " " << emp[1].m_name << " " << emp[1].m_age << endl;
   
9.         cout << "第一次写入完成" << endl;
   
10.         system("pause");
    
11.         //更改人数
    
12.         ofs.seekp(ios::beg);
    
13.         cnt = 9999;
    
14.         ofs << cnt;
    
15.         ofs.close();

复制代码

人造人

两手空空儿 发表于 2023-1-29 22:25
谢谢大佬~~~
你的用法好高级，我要好好消化一下，
有没有哪个地方可以查询 标准类库的函数的地方，>>

https://cplusplus.com/reference/iostream/
https://zh.cppreference.com/w/cpp/header
https://www.apiref.com/cpp/index.html
https://cn.bing.com/
有这4个大概就够了

两手空空儿

dolly_yos2 发表于 2023-1-29 22:10
C++ 标准库的输出流可以用 std::setw 来设置位宽，自动填充空格
先输入数量时会自动跳过前缀空白字符， ...

好的，谢谢~~~
C++标准库从哪里可以查到啊，学C的时候查了库函数让自己明白了不少，学C++又不行了，
iostream就会 << , >> , string 类用起来也不太清楚

dolly_yos2

两手空空儿 发表于 2023-1-29 22:34
好的，谢谢~~~
C++标准库从哪里可以查到啊，学C的时候查了库函数让自己明白了不少，学C++又不行了，
i ...

我赞同人造人大佬的回答，这四个网站应该足够使用了

两手空空儿

人造人 发表于 2023-1-29 22:26

辛苦大佬啦，模版，容器 ，这些我还没学，还看不懂，哈哈哈哈哈

加油学，学完再回过头来再学习大佬的这段代码

人造人

两手空空儿 发表于 2023-1-29 22:40
辛苦大佬啦，模版，容器 ，这些我还没学，还看不懂，哈哈哈哈哈

加油学，学完再回过头来再学习大佬的 ...

^_^

两手空空儿

人造人 发表于 2023-1-29 22:29
https://cplusplus.com/reference/iostream/
https://zh.cppreference.com/w/cpp/header
https://www.a ...

谢谢~~~~ 全部收藏啦，把常用的东西仔细学一下

两手空空儿

dolly_yos2 发表于 2023-1-29 22:10
C++ 标准库的输出流可以用 std::setw 来设置位宽，自动填充空格
先输入数量时会自动跳过前缀空白字符， ...

谢谢~~~ ，帮我解决了暂时的问题，二进制读写的操作我还要好好学习一下

两手空空儿

人造人 发表于 2023-1-29 21:58
不要用ascii写，用二进制写

我终于悟了，打开文件的方式是不是用binary和读写完全没什么关系，我前面以为打开方式不同决定写入和读取的方式
是不是用binary的打开方式，只影响换行符这个东西
用write的方式写入数字，都不用考虑会覆盖问题，内存里怎么放的，文件里就是怎么放的
字符串加长的话会有覆盖的问题，这个要自己注意
用<<  或者 fprintf 这种方式向文件里写东西是把数字转成了字符串写进去的
谢谢大佬提点

人造人

两手空空儿 发表于 2023-1-31 12:11
我终于悟了，打开文件的方式是不是用binary和读写完全没什么关系，我前面以为打开方式不同决定写入和读 ...

^_^

dolly_yos2

两手空空儿 发表于 2023-1-31 12:11
我终于悟了，打开文件的方式是不是用binary和读写完全没什么关系，我前面以为打开方式不同决定写入和读 ...

可以看看这里对 Binary and text modes 的说法
https://en.cppreference.com/w/cpp/io/c/FILE#Binary_and_text_modes