C++文件读写详解(ofstream,ifstream,fstream)及C++ string类

在看C++编程思想中，每个练习基本都是使用ofstream,ifstream,fstream，以前粗略知道其用法和含义，在看了几位大牛的博文后，进行整理和总结：

这里主要是讨论fstream的内容：

[java]view plaincopyprint?

1.#include

2.ofstream //文件写操作内存写入存储设备

3.ifstream //文件读操作，存储设备读区到内存中

4.fstream //读写操作，对打开的文件可进行读写操作

1.打开文件

在fstream类中，成员函数open（）实现打开文件的操作，从而将数据流和文件进行关联，通过ofstream,ifstream,fstream对象进行对文件的读写操作

函数：open（）

[cpp]view plaincopyprint?

1.

2.public member function

3.

4.void open ( const char * filename,

5. ios_base::openmode mode = ios_base::in | ios_base::out );

6.

7.void open(const wchar_t *_Filename,

8. ios_base::openmode mode= ios_base::in | ios_base::out,

9.int prot = ios_base::_Openprot)；

10.

11.

1.ofstream out;

2.out.open("Hello.txt", ios::in|ios::out|ios::binary) //根

据自己需要进行适当的选取

1.

2.ofstream out("...", ios::out);

3.ifstream in("...", ios::in);

4.fstream foi("...", ios::in|ios::out);

5.

6.

当使用默认方式进行对文件的操作时，你可以使用成员函数is_open()对文件是否打开进行验证

2.关闭文件

当文件读写操作完成之后，我们必须将文件关闭以使文件重新变为可访问的。成员函数close()，它负责将缓存中的数据排放出来并关闭文件。这个函数一旦被调用，原先的流对象就可以被用来打开其它的文件了，这个文件也就可以重新被其它的进程所访问了。为防止流对象被销毁时还联系着打开的文件，析构函数将会自动调用关闭函数close。

3.文本文件的读写

类ofstream, ifstream 和fstream 是分别从ostream, istream 和iostream 中引申而来的。这就是为什么fstream 的对象可以使用其父类的成员来访问数据。

一般来说，我们将使用这些类与同控制台(console)交互同样的成员函数(cin 和cout)来进行输入输出。如下面的例题所示，我们使用重载的插入操作符<<：

[cpp]view plaincopyprint?

1. // writing on a text file

2. #include

3.int main () {

4. ofstream out("out.txt");

5. if (out.is_open())

6. {

7. out << "This is a line.\n";

8. out << "This is another line.\n";

9. out.close();

10. }

11. return 0;

12. }

13.//结果: 在out.txt中写入：

14.This is a line.

15.This is another line

从文件中读入数据也可以用与cin>>的使用同样的方法：

[cpp]view plaincopyprint?

1.// reading a text file

2. #include

3. #include

4. #include

5.

6.int main () {

7.char buffer[256];

8. ifstream in("test.txt");

9. if (! in.is_open())

10. { cout << "Error opening file"; exit (1); }

11. while (!in.eof() )

12. {

13. in.getline (buffer,100);

14. cout << buffer << endl;

15. }

16. return 0;

17. }

18. //结果在屏幕上输出

19. This is a line.

20. This is another line

上面的例子读入一个文本文件的内容，然后将它打印到屏幕上。注意我们使用了一个新的成员函数叫做eof ，它是ifstream 从类ios 中继承过来的，当到达文件末尾时返回true 。

状态标志符的验证(Verification of state flags)

除了eof()以外，还有一些验证流的状态的成员函数（所有都返回bool型返回值）：?bad()

如果在读写过程中出错，返回true 。例如：当我们要对一个不是打开为写状态的文

件进行写入时，或者我们要写入的设备没有剩余空间的时候。

?fail()

除了与bad() 同样的情况下会返回true 以外，加上格式错误时也返回true ，例如

当想要读入一个整数，而获得了一个字母的时候。

?eof()

如果读文件到达文件末尾，返回true。

?good()

这是最通用的：如果调用以上任何一个函数返回true 的话，此函数返回false 。要想重置以上成员函数所检查的状态标志，你可以使用成员函数clear()，没有参数。

获得和设置流指针(get and put stream pointers)

所有输入/输出流对象(i/o streams objects)都有至少一个流指针：

?ifstream，类似istream, 有一个被称为get pointer的指针，指向下一个将被读取的元素。

?ofstream, 类似ostream, 有一个指针put pointer ，指向写入下一个元素的位置。

?fstream, 类似iostream, 同时继承了get 和put

我们可以通过使用以下成员函数来读出或配置这些指向流中读写位置的流指针：?tellg() 和tellp()

这两个成员函数不用传入参数，返回pos_type 类型的值(根据ANSI-C++ 标准) ，

就是一个整数，代表当前get 流指针的位置(用tellg) 或put 流指针的位置(用

tellp).

?seekg() 和seekp()

这对函数分别用来改变流指针get 和put的位置。两个函数都被重载为两种不同的

原型：

seekg ( pos_type position );

seekp ( pos_type position );

使用这个原型，流指针被改变为指向从文件开始计算的一个绝对位置。要求传入的

参数类型与函数tellg 和tellp 的返回值类型相同。

seekg ( off_type offset, seekdir direction );

seekp ( off_type offset, seekdir direction );

使用这个原型可以指定由参数direction决定的一个具体的指针开始计算的一个位移

(offset)。它可以是：

1.// obtaining file size

2. #include

3. #include

4.

5. const char * filename = "test.txt";

6.

7.int main () {

8.long l,m;

9. ifstream in(filename, ios::in|ios::binary);

10. l = in.tellg();

11. in.seekg (0, ios::end);

12. m = in.tellg();

13. in.close();

14. cout << "size of " << filename;

15. cout << " is " << (m-l) << " bytes.\n";

16. return 0;

17. }

18.

19. //结果:

20. size of example.txt is 40 bytes.

4.二进制文件

在二进制文件中，使用<< 和>>，以及函数（如getline）来操作符输入和输出数据，没有什么实际意义，虽然它们是符合语法的。

文件流包括两个为顺序读写数据特殊设计的成员函数：write 和read。第一个函数(write) 是ostream 的一个成员函数，都是被ofstream所继承。而read 是istream 的一个成员函数，被ifstream 所继承。类fstream 的对象同时拥有这两个函数。它们的原型是：

write ( char * buffer, streamsize size );

read ( char * buffer, streamsize size );

这里buffer 是一块内存的地址，用来存储或读出数据。参数size 是一个整数值，表示要从缓存（buffer）中读出或写入的字符数。

[cpp]view plaincopyprint?

1.// reading binary file

2. #include

3. #include

4.

5. const char * filename = "test.txt";

6.

7.int main () {

8.char * buffer;

9.long size;

10. ifstream in (filename, ios::in|ios::binary|ios::ate);

11. size = in.tellg();

12. in.seekg (0, ios::beg);

13. buffer = new char [size];

14. in.read (buffer, size);

15. in.close();

16.

17. cout << "the complete file is in a buffer";

18.

19. delete[] buffer;

20. return 0;

21. }

22. //运行结果：

23. The complete file is in a buffer

5.缓存和同步(Buffers and Synchronization)

当我们对文件流进行操作的时候，它们与一个streambuf 类型的缓存(buffer)联系在一起。这个缓存（buffer）实际是一块内存空间，作为流(stream)和物理文件的媒介。例如，对于一个输出流，每次成员函数put (写一个单个字符)被调用，这个字符不是直接被写入该输出流所对应的

物理文件中的，而是首先被插入到该流的缓存（buffer）中。

当缓存被排放出来(flush)时，它里面的所有数据或者被写入物理媒质中（如果是一个输出流的话），或者简单的被抹掉(如果是一个输入流的话)。这个过程称为同步(synchronization)，它会在以下

任一情况下发生：

?当文件被关闭时:在文件被关闭之前，所有还没有被完全写出或读取的缓存都将被同步。

?当缓存buffer 满时:缓存Buffers 有一定的空间限制。当缓存满时，它会被自动同步。

?控制符明确指明:当遇到流中某些特定的控制符时，同步会发生。这些控制符包括：flush 和endl。

?明确调用函数sync():调用成员函数sync() (无参数)可以引发立即同步。这个函数返回一个int 值，等于-1 表示流没有联系的缓存或操作失败。

标准C++中的string类的用法总结

相信使用过MFC编程的朋友对CString这个类的印象应该非常深刻吧？的确，MFC中的CString类使用起来真的非常的方便好用。但是如果离开了MFC框架，还有没有这样使用起来非常方便的类呢？答案是肯定的。也许有人会说，即使不用MFC框架，也可以想办法使用MFC 中的API，具体的操作方法在本文最后给出操作方法。其实，可能很多人很可能会忽略掉标准C++中string类的使用。标准C++中提供的string类得功能也是非常强大的，一般都能满足我们开发项目时使用。现将具体用法的一部分罗列如下，只起一个抛砖引玉的作用吧，好了，废话少说，直接进入正题吧！

要想使用标准C++中string类，必须要包含

#include // 注意是，不是，带.h的是C语言中的头文件using std::string;

using std::wstring;

或

using namespace std;

下面你就可以使用string/wstring了，它们两分别对应着char和wchar_t。

string和wstring的用法是一样的，以下只用string作介绍：

string类的构造函数：

string(const char *s); //用c字符串s初始化

string(int n,char c); //用n个字符c初始化

此外，string类还支持默认构造函数和复制构造函数，如string s1；string s2="hello"；都是正确的写法。当构造的string太长而无法表达时会抛出length_error异常；

string类的字符操作：

const char &operator[](int n)const;

const char &at(int n)const;

char &operator[](int n);

char &at(int n);

operator[]和at()均返回当前字符串中第n个字符的位置，但at函数提供范围检查，当越界时会抛出out_of_range异常，下标运算符[]不提供检查访问。

const char *data()const;//返回一个非null终止的c字符数组

const char *c_str()const;//返回一个以null终止的c字符串

int copy(char *s, int n, int pos = 0) const;//把当前串中以pos开始的n个字符拷贝到以s为起始位置的字符数组中，返回实际拷贝的数目

string的特性描述:

int capacity()const; //返回当前容量（即string中不必增加内存即可存放的元素个数）int max_size()const; //返回string对象中可存放的最大字符串的长度

int size()const; //返回当前字符串的大小

int length()const; //返回当前字符串的长度

bool empty()const; //当前字符串是否为空

void resize(int len,char c);//把字符串当前大小置为len，并用字符c填充不足的部分

string类的输入输出操作:

string类重载运算符operator>>用于输入，同样重载运算符operator<<用于输出操作。函数getline(istream &in,string &s);用于从输入流in中读取字符串到s中，以换行符'\n'分开。

string的赋值：

string &operator=(const string &s);//把字符串s赋给当前字符串

string &assign(const char *s);//用c类型字符串s赋值

string &assign(const char *s,int n);//用c字符串s开始的n个字符赋值

string &assign(const string &s);//把字符串s赋给当前字符串

string &assign(int n,char c);//用n个字符c赋值给当前字符串

string &assign(const string &s,int start,int n);//把字符串s中从start开始的n个字符赋给当前字符串

string &assign(const_iterator first,const_itertor last);//把first和last迭代器之间的部分赋给字符串

string的连接：

string &operator+=(const string &s);//把字符串s连接到当前字符串的结尾

string &append(const char *s); //把c类型字符串s连接到当前字符串结尾string &append(const char *s,int n);//把c类型字符串s的前n个字符连接到当前字符串结尾

string &append(const string &s); //同operator+=()

string &append(const string &s,int pos,int n);//把字符串s中从pos开始的n个字符连接到当前字符串的结尾

string &append(int n,char c); //在当前字符串结尾添加n个字符c

string &append(const_iterator first,const_iterator last);//把迭代器first和last之间的部分连接到当前字符串的结尾

string的比较：

bool operator==(const string &s1,const string &s2)const;//比较两个字符串是否相等运算符">","<",">=","<=","!="均被重载用于字符串的比较；

int compare(const string &s) const;//比较当前字符串和s的大小

int compare(int pos, int n,const string &s)const;//比较当前字符串从pos开始的n个字符组成的字符串与s的大小

int compare(int pos, int n,const string &s,int pos2,int n2)const;//比较当前字符串从pos开始的n个字符组成的字符串与s中

//pos2开始的n2个字符组成的字符串的大小

int compare(const char *s) const;

int compare(int pos, int n,const char *s) const;

int compare(int pos, int n,const char *s, int pos2) const;

compare函数在>时返回1，<时返回-1，==时返回0

string的子串：

string substr(int pos = 0,int n = npos) const;//返回pos开始的n个字符组成的字符串

string的交换：

void swap(string &s2); //交换当前字符串与s2的值

string类的查找函数：

int find(char c, int pos = 0) const;//从pos开始查找字符c在当前字符串的位置

int find(const char *s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置int find(const char *s, int pos, int n) const;//从pos开始查找字符串s中前n个字符在当前串中的位置

int find(const string &s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置//查找成功时返回所在位置，失败返回string::npos的值

int rfind(char c, int pos = npos) const;//从pos开始从后向前查找字符c在当前串中的位置

int rfind(const char *s, int pos = npos) const;

int rfind(const char *s, int pos, int n = npos) const;

int rfind(const string &s,int pos = npos) const;

//从pos开始从后向前查找字符串s中前n个字符组成的字符串在当前串中的位置，成功返回所在位置，失败时返回string::npos的值

int find_first_of(char c, int pos = 0) const;//从pos开始查找字符c第一次出现的位置int find_first_of(const char *s, int pos = 0) const;

int find_first_of(const char *s, int pos, int n) const;

int find_first_of(const string &s,int pos = 0) const;

//从pos开始查找当前串中第一个在s的前n个字符组成的数组里的字符的位置。查找失败返回string::npos

int find_first_not_of(char c, int pos = 0) const;

int find_first_not_of(const char *s, int pos = 0) const;

int find_first_not_of(const char *s, int pos,int n) const;

int find_first_not_of(const string &s,int pos = 0) const;

//从当前串中查找第一个不在串s中的字符出现的位置，失败返回string::npos

int find_last_of(char c, int pos = npos) const;

int find_last_of(const char *s, int pos = npos) const;

int find_last_of(const char *s, int pos, int n = npos) const;

int find_last_of(const string &s,int pos = npos) const;

int find_last_not_of(char c, int pos = npos) const;

int find_last_not_of(const char *s, int pos = npos) const;

int find_last_not_of(const char *s, int pos, int n) const;

int find_last_not_of(const string &s,int pos = npos) const;

//find_last_of和find_last_not_of与find_first_of和find_first_not_of相似，只不过是

从后向前查找

string类的替换函数：

string &replace(int p0, int n0,const char *s);//删除从p0开始的n0个字符，然后在p0处插入串s

string &replace(int p0, int n0,const char *s, int n);//删除p0开始的n0个字符，然后在p0处插入字符串s的前n个字符

string &replace(int p0, int n0,const string &s);//删除从p0开始的n0个字符，然后在

p0处插入串s

string &replace(int p0, int n0,const string &s, int pos, int n);//删除p0开始的n0个字符，然后在p0处插入串s中从pos开始的n个字符

string &replace(int p0, int n0,int n, char c);//删除p0开始的n0个字符，然后在p0处

插入n个字符c

string &replace(iterator first0, iterator last0,const char *s);//把[first0，last0）之间

的部分替换为字符串s

string &replace(iterator first0, iterator last0,const char *s, int n);//把[first0，last0）之间的部分替换为s的前n个字符

string &replace(iterator first0, iterator last0,const string &s);//把[first0，last0）之

间的部分替换为串s

string &replace(iterator first0, iterator last0,int n, char c);//把[first0，last0）之间的部分替换为n个字符c

string &replace(iterator first0, iterator last0,const_iterator first, const_iterator last);//把[first0，last0）之间的部分替换成[first，last）之间的字符串

string类的插入函数：

string &insert(int p0, const char *s);

string &insert(int p0, const char *s, int n);

string &insert(int p0,const string &s);

string &insert(int p0,const string &s, int pos, int n);

//前4个函数在p0位置插入字符串s中pos开始的前n个字符

string &insert(int p0, int n, char c);//此函数在p0处插入n个字符c

iterator insert(iterator it, char c);//在it处插入字符c，返回插入后迭代器的位置

void insert(iterator it, const_iterator first, const_iterator last);//在it处插入[first，last）之间的字符

void insert(iterator it, int n, char c);//在it处插入n个字符c

string类的删除函数

iterator erase(iterator first, iterator last);//删除[first，last）之间的所有字符，返回删除后迭代器的位置

iterator erase(iterator it);//删除it指向的字符，返回删除后迭代器的位置

string &erase(int pos = 0, int n = npos);//删除pos开始的n个字符，返回修改后的字符串

string类的迭代器处理：

string类提供了向前和向后遍历的迭代器iterator，迭代器提供了访问各个字符的语法，类似于指针操作，迭代器不检查范围。

用string::iterator或string::const_iterator声明迭代器变量，const_iterator不允许改变迭代的内容。常用迭代器函数有：

const_iterator begin()const;

iterator begin(); //返回string的起始位置

const_iterator end()const;

iterator end(); //返回string的最后一个字符后面的位置

const_iterator rbegin()const;

iterator rbegin(); //返回string的最后一个字符的位置

const_iterator rend()const;

iterator rend(); //返回string第一个字符位置的前面

rbegin和rend用于从后向前的迭代访问，通过设置迭代器

string::reverse_iterator,string::const_reverse_iterator实现

字符串流处理：

通过定义ostringstream和istringstream变量实现，#include 头文件中

例如：

string input("hello,this is a test");

istringstream is(input);

string s1,s2,s3,s4;

is>>s1>>s2>>s3>>s4;//s1="hello,this",s2="is",s3="a",s4="test"

ostringstream os;

os<

cout<

以上就是对C++ string类的一个简要介绍。用的好的话它所具有的功能不会比MFC中的CString类逊色多少，呵呵，个人意见！

最后要介绍如何在Win32 应用程序中引用MFC中的部分类，例如CString。

1.在工程目录下右键选择"Properties”--->"Configuration

Properties”--->“General”--->"Use of MFC"--->"Use MFC in a Static Library"，

默认的是："Use Standard Windows Libraries"，如下图：

2.在你所用的所有头文件之前包含#include ，例如：可以在stdafx.h文件的最前面包含#include 头文件，这样在你的源代码中就可以使用

CString类了，不过这样也有一个缺点，就是编译出来的程序要比原来的大很多。我试过一个小程序，选择"Use Standard Windows Libraries" 编译出来

的Release版本大概92kb，使用"Use MFC in a Static Library"编译出来的Release版本大概192kb，足足大了100kb，这个就个人考虑了......