精华内容
下载资源
问答
  • 输入/输出流简介 C++流类库简介 输入/输出流 自定义类型的输入/输出 文件的输入/输出 输入/输出流简介 C++流类库简介 输入/输出流 自定义类型的输入/输出 文件的输入/输出 ...

    感谢 https://blog.csdn.net/qq_38289815/article/details/82388157

    输入/输出流简介
    C++流类库简介
    输入/输出流
    自定义类型的输入/输出
    文件的输入/输出

    输入/输出流简介

    数据的输入输出是最重要的操作,C++的输入输出有iostream库提供支持,它利用多继承和虚拟继承实现了面向对象类层次结构。C++的输入、输出机制为内置数据类型的输入、输出提供了支持,同时也支持文件的输入输出。在此基础上,设计者可以通过扩展iostream库,为新类型的数据读写进行扩展。
    在这里插入图片描述

    C++流类库简介

    今天把这节整理完,还有多态底层再理解整理,就开始看网络编程,之后的这个月就白天上课晚上看看弄弄论文。加油争取四月底就把课上完,项目有个样。然后就开始源码剖析,刷题整理,知识点深入(五月)加油加油。要早起,休息时间做做运动。

    C语言中的scanf和printf很灵巧高效,但不是类型安全的,而且没有扩展性。scanf/printf系列函数要求把读写的变量和控制读写的格式信息分开。而C++正是克服了这些缺点,使用cin/cout控制输入/输出。(类型安全就是指如果两个类型要相互转换,必须显示地转换,不能隐式地只用一个等号就转换了

    • 1,cin,表示标准输入的istream类对象,cin从终端读入数据
    • 2,cout,表示标准输出的ostream类对象,cout向终端写数据
    • 3,cerr,表示标准错误输出(非缓冲方式),导出程序错误信息
    • 4,clog,表示标准错误输出(缓冲方式),导出程序错误信息

    为了在程序中使用cin/cout,必须要加iostream库的相关头文件#include <iostream>

    iostream类同时从istream类和ostream类派生而来,允许双向输入/输出。输入有重载的操作符>>完成,输出由重载的操作符<<来完成。输入输出格式:

    cin >> 变量名;
    cout << 变量名或常量;
    

    除了用户终端的输入/输出,C++还提供了文件的输入/输出类:

    • 1,ifstream,从istream派生而来,把文件绑定到程序上输入
    • 2,ofstream,从ostream派生而来,把文件绑定到程序输出
    • 3,fstream,从iostream派生而来,把文件绑定到程序输入/输出

    使用iostream库的文件流,必须包含相关的头文件:#include

    文件读写示例👇:⭐⭐⭐

    #include<iostream>
    #include<string>
    #include<fstream>
    using namespace std;
    //文件操作需要用到头函数fstream
    //用ifstream打开源文件,备读
    //用ofstream打开目标文件,备写
    int main()
    {
    	string sourcName("asdfile.txt");//定义源文件
    	ifstream sourceFile(sourceName.c_str());//打开源文件流类
    	if(!sourceFile)
    	{
    		cout<<"Error:打不开"<<sourceName<<endl;
    		return -1;
    	}
    	string destinationName("z");//定义目标文件
    	ofstream destinationFile(destinationName.c_str());//打开目标文件流
    	if(!destinationFile)
    	{
    		cout<<"Error:打不开"<<destinationName<<endl;
    		return -1;
    	}
    	string buf;
    	while(sourceFile >> buf)
    	{
    		destinationFile << buf;//输出到目标文件
    	}
    	return 0;
    }
    

    输入/输出流

    基本输出流

    C++的ostream提供了丰富的格式化和无格式化的输出功能:
    流插入符输出标准数据类型;
    put库成员函数输出字符;
    以八进制、十进制、十六进制输出数据;
    以各种精确方式输出浮点型数据;
    以科学计数法定点输出数据;
    以指定宽度输出数据;
    在区域内用指定字符填充等

    流输出可以用流插入运算符,即重载的<<来完成。运算符<<左边的操作数是istream类的一个对象如cout,右边是C++的合法表达式。

    👇用插入运算符实现流输出:

    using namespace std;
    int main()
    {
    	cout<<"hello C++\n";
    	return 0;
    }
    

    输出操作符可以接受任何内置数据类型的实参, 包括const char*,以及标准库string和complex类类型。任何表达式包括函数调用,都可以是输出操作符的实参,只要它的计算结果是一个被输出操作符实例接受的数据类型即可。
    👇函数调用操作符的实参:

    using namespace std;
    int main()
    {
    	cout<<strlen("hello!")<<endl;
    	return 0;
    }
    

    C++还提供了指针预定义输出操作符,允许输出项为显示对象的地址。默认情况下,地址以十六进制的形式显示:👇

    #include <iostream>
    using namespace std;
     
    int main()
    {
    	int i = 10;
    	int *p = &i;
    	cout << "i:" << i << " &i:" << &i <<endl;
    	cout << "*p" << *p << "  p:" << p << " &p:" << &p <<endl;
    	return 0;
    }
    

    在这里插入图片描述👇关于输入操作符的优先级

    #include <iostream>
    using namespace std;
     
    int main()
    {
    	int i = 10, j = 20;
    	cout << "The max is ";
    	cout << (i>j)?i:j;
            cout <<endl;
    	return 0;
    }
    

    结果:
    在这里插入图片描述
    结果输出0问题在于输入操作符的优先级高于条件操作符,所以输出i、j的比较结果的bool值。即表达式被解析为(cout<<(i>j))?i:j;因为i<j,所以结果为false,输出结果0.为了得到正确结果,整个表达式必须放在括号中:cout<<((i>j)?i:j);由此得到正确结果:the max is 20

    基本输入流

    对应于输出,C++提供了实用的输入功能,类似于输出流中的流插入符,输入中引入了流读取符

    流输入可以用流读取运算符,即重载的>>,读取符是个双目运算符,左边的操作数是istream类的一个对象如cin,右边的操作数是系统定义的任何数据类型的变量,例如:int i; cin>>i;从键盘输入的数据会自动转换成i的类型,存储到变量i中。

    注意:
    (1)输入运算符>>也支持级联输入。在默认情况下,运算符>>跳过空格,读入后面与变量类型相应的值。因此给一组变量输入值时,用空格或换行将输入的数值间隔开,例如:

    int i;
    float f;
    cin >> i >> f;
    

    (2)当输入字符串(char*类型)时,输入运算符>>会跳过空格,读入后面的非空格符,直到遇到另外一个空格结束,并在字符串末尾自动放置字符’\0’作为结束标志,例如:

    char s[20];
    cin>> s;
    

    (3)数据输入时,不仅检查数据间的空格,还做类型检查、自动匹配

    格式化输入/输出

    在很多情况下,用户希望自己控制输出格式。C++提供两种格式控制方法:
    1,通过使用ios类中的格式控制函数
    2,使用称为操纵符的特殊类型函数

    一、在ios类中,格式控制函数主要是通过对状态字、域宽、填充字及其精度来完成的。输入/输出格式由一个long int类型的状态字确定。在ios类的public部分进行了枚举。

    skipws             跳过输入中的空白
    left               左对齐格式输出
    right              右对齐格式输出
    internal           在符号位和数值之间填入字符
    dec                十进制显示
    oct                八进制显示
    hex                十六进制显示
    showbase           产生前缀,指示数值的进制基数
    shwopoint          总是显示小数
    uppercase          在十六进制下显示0X,科学计数法显示E
    showpos            在非负数值中显示+
    boolalpha          把truefalse表示为字符串
    scientific         以科学计数法形式显示浮点数
    fixed              以小数形式显示浮点数
    unitbuf            输出操作后立即刷新所有流
    stdio              输出操作后刷新stdoutstderr
    
    1. 设置状态标识
    2. 清除状态标识
    3. 取状态标识
    4. 设置域宽
    5. 设置填充字符
    6. 设置显示精度
      ====就之后再看吧555

    二、操纵符控制格式,类似于函数的运算符,使用操纵符方法可以嵌入到输入、输出语句中。
    所有不带参数的操作符定义在头文件iostream中,带形参的操纵符定义在头文件iomanip中,常见的有:

    ws                      在输入时跳过开头的空白符,仅用于输入
    endl                    换行并刷新输出流,仅用于输出
    ends                    插入一个空字符,仅用于输出
    dec                     十进制显示
    oct                     八进制显示
    hex                     十六进制显示
    setfill(ch)             用ch填充空白字符
    setprecision(n)         将浮点数精度设置为n
    setw(w)                 按照w个字符来读或写数值
    setbase(b)              以进制基数b来输出整数值
    setiosflags(n)          设置由n指定的格式标志
    resetiosflags(n)        清除由n指定的格式标志
    

    例子👇

    #include <iostream>
    #include <iomanip>
    using namespace std;
     
    int main()
    {
    	int i = 123;
    	float f =2018.0903;
    	const char* const str = "hello! every one!";
    	cout << "default width is:" << cout.width() <<endl;
    	cout << "default fill is:" << cout.fill() <<endl;
    	cout << "default precision is:" << cout.precision() <<endl;
    	cout << "i = " << i << "  f = " << f << "  str = " << str <<endl;
    	cout << "i = " << setw(12) << setfill('*') << i <<endl;
    	cout << "i(hex) = " << hex << i << "  i(oct) = " << oct << i << endl;
    	cout << "f = " << setw(12) << setprecision(3) << f <<endl;
    	cout << "f = " << setw(12) << fixed << f <<endl;
    	cout << "str = " << setw(20) << left << str <<endl;
    	return 0;
    }
    

    在这里插入图片描述

    另外除了系统提供的预定义操纵符之外,C++还允许用户自己定义操纵符,便于控制一些频繁使用的格式操作,使得格式控制更加方便。

    自定义输出流操纵符算子格式如下:

    ostream & 自定义输出操纵符算子函数名 (ostream& stream)
    {
        ...//自定义代码
        return stream;
    }
    

    自定义输入流操纵符算子格式如下:

    istream & 自定义输出操纵符算子函数名 (istream& stream)
    {
        ...//自定义代码
        return stream;
    }
    

    例子👇

    #include <iostream>
    #include <iomanip>
    using namespace std;
     
    ostream &myoutput(ostream& stream)
    {
    	stream << setw(10) << setfill('#') <<left;
    	return stream;
    }
     
    int main()
    {
    	int i = 123;
    	cout << i <<endl;
    	cout << myoutput << i <<endl;
    	return 0;
    }
    

    自定义操纵符函数myoutput(),功能是设置域宽为10,填充字符为#,并采用左对齐。函数参数为引用方式,cout的返回值为引用方式且可以多级输出,所以在主函数中只写myoutput即可。

    自定义输入操作函数👇:

    #include <iostream>
    using namespace std;
     
    istream &myinput(istream& stream)
    {
    	cout << "please input a hex integer:";
    	stream >> hex;
    	return stream;
    }
     
    int main()
    {
    	int i;
    	cin >> myinput >> i;
    	cout << "i(dec) = " << i << "  i(hex) = " << hex << i <<endl;
    	return 0;
    }
    

    其他的输入/输出函数

    仅仅靠cin只能得到不包括空格的字符串,因此C++还提供了以下输入/输出函数

    get()put()函数
    

    get(char &ch)从输入流中提取一个字符,包括空白字符,并把它存储在ch中,返回被引用的istream对象。此函数在类istream中 对应于get(),类ostream提供了put(char ch)函数,用于输出字符

    get()的重载版本:get(char *str, streamsize size, char delimiter = '\n');
    

    str代表一个字符数组,用来存放被读取的字符。size代表可以从istream中读入的字符的最大数目。delimiter表示如果遇到它就结束读取字符的动作,delimiter本身不会被读入,而是留在istream中,作为istream的下一个字符。

    下面例子使用istream的成员函数ignore()来去掉delimiter。默认情况下,delimiter为换行符。👇

    using namespace std;
    int main()
    {
    	const int str_len = 100;
    	char str[str_len];
    	while(cin.get(str,str_len))
            //当读入的数据不为空时循环下一次,每次最多读入str_len个
    	{
    		int count = cin.gcount();    //当前实际读入多少个字符
    		cout << "the number is:" << count <<endl;
     
    		if(count < str_len)
    			cin.ignore();        //在下一行之前去掉换行符,没有到达目标数字就继续读取
    	}
    	return 0;
    }
    

    在这里插入图片描述====》getline()函数:

    使用get()函数输入字符串时,经常忘记去掉delimiter,所以引入函数getline(),其原型与get()的重载版本相同

    getline(char *str, streamsize size, char delimiter = '\n');
    

    ostream类成员函数write()提供一种输出字符数组的方法。它不是输出”直到终止字符为止”,而是输出某个长度的字符序列,包括空字符。函数原型如下:

    ====》 write(), read()函数

    write(char *str, streamsize length);
    

    str是要输出的字符数组,length是要显示的字符个数。write()返回当前被调用的ostream类对象。

    istream类的read()函数,原型如下:

    read(char *str, streamsize size);
    

    read()函数从输入流中读取size个连续的字符,并将其放在地址从str开始的内存中。

    gcount()方法返回最后一个非格式化的抽取方法读取的字符数。这意味着字符由get()、getline()、ignore()、或read()方法读取的,不是由抽取操作符( >> )读取的,抽取操作符对输入进行格式化,使之与特定的数据类型匹配。

    输入/输出综合实例👇:(まだ)

    #include <iostream>
    using namespace std;
     
    int main()
    {
    	const int str_len = 100;
    	char str[str_len];
    	int iline = 0;       //行数
    	int max = -1;        //最长行的长度
    	while(iline < 3)
    	{
    		cin.getline(str, str_len);
    		int num = cin.gcount();//gcount的返回值是获取的字符数,但是这个获取值要被统计,就是肉眼可见+1
    		cout << "the number is:" << num <<endl;
    		iline++;
    		if(num > max)
    			max = num;
    		cout << "Line#" << iline << "\t chars read:" << num <<endl;
    		cout.write(str, num).put('\n').put('\n');
    	}
    	cout << "Total lines:" << iline <<endl;
    	cout << "The longest line:" << max <<endl;
    	return 0;
    }
    

    自定义类型的输入/输出

    当实现一个类的类型时,有时希望这个类支持输入和输出操作,以便可以将类对象嵌入到输入或输出流中。前面的函数都是C++系统预定义数据类型的输入/输出。对于用户自己定义的数据类型的输入/输出,可以通过重载运算符”>>”和”<<”实现。

    重载输出运算符 “<<”

    其重载函数的格式如下:

    ostream & operator << (ostream &out, class_name &obj)
    {
    	out<<obj.data1;
    	out<<obj.data2;
    	......
    	return out;
    }
    

    函数中第一个参数out是对ostream对象的引用,即out必须是输出流对象;第二个参数是用户自定义要输出的类对象的引用,data1,data2……datan是类内要输出的数据成员。输出运算符“<<”不能作为类的成员函数,只能作为友元函数(要访问类的私有成员)来实现。

    输出运算符重载:👇

    #include <iostream>
    #include <string.h>
    using namespace std;
     
    class Word
    {
    	char *word;
    	size_t num;       //存储的字符个数
    public:
    	Word(const char* const str = NULL);
    	virtual ~Word()
    	{
    		if(word)  //清除指针
    			delete []word;
    	}
    	friend ostream& operator<<(ostream& out, Word& sword);//友元
    };
     
    Word::Word(const char* const str)
    {
    	if(str != NULL)
    	{
    		num = strlen(str);
    		word = new char[num+1];
    		strcpy(word,str);
    	}
    }
     
    ostream& operator<<(ostream& out, Word& sword)
    {
    	out << "<" << sword.num << ">" << sword.word <<endl;
    	return out;
    }
     
    int main()
    {
    	Word word("hello");
    	cout << word;
    	return 0;
    }
    

    程序为类word重载输出运算符”<<”,使得可以通过cout简单地输出word类对象的内容:字符串和字符串长度。在类word的构造函数里,为类成员word申请空间(包括字符串结束标志’\0’),在析构函数中,相应地释放成员word的空间。重载函数的第二个参数为引用形式,可以转为普通形式,但是引用减少了调用开销。

    重载输入运算符 “>>”

    输入运算符”>>”,又称为提取运算符,定义其重载函数的格式如下:

    istream &operator>>(istream &in, class_name& obj)
    {
        in >> obj.data1;
        in >> obj.data2;
        ......
        in >> obj.datan;
        return out;
    }
    

    输入运算符也不能作为类的成员函数,只能作为类的友元函数或独立函数。重载函数第二个参数必须为引用,且不能为常引用,因为要对参数进行修改。

    输入运算符重载:👇

    #include <iostream>
    #include <string.h>
    using namespace std;
     
    class Word
    {
    	char *word;
    	size_t num;
    	public:
    	Word(const char* const str = NULL);
    	virtual ~Word()
    	{
    		if(word)
    			delete []word;
    	}
    	friend ostream& operator<<(ostream& out, Word& sword);//友元
    	friend istream& operator>>(istream& in, Word& sword);//友元
    };
     
    Word::Word(const char* const str)
    {
    	if(str != NULL)
    	{
    		num = strlen(str);
    		word = new char[num+1];
    		strcpy(word,str);
    	}
    }
     
    ostream& operator<<(ostream& out, Word& sword)
    {
    	out << "<" << sword.num << ">" << sword.word <<endl;
    	return out;
    }
     
    istream& operator>>(istream& in, Word& sword)
    {
    	char str[100];
    	in.getline(str, 100);
    	if(in.gcount() > 0)
    	{
    		delete []sword.word;
    		sword.num = strlen(str);
    		sword.word = new char[sword.num+1];
    		strcpy(sword.word, str);
    	}
    	return in;
    }
     
    int main()
    {
    	Word word("hello");
    	cout << word;
    	cin >> word;
    	cout << word;
    	return 0;
    }
    

    文件的输入/输出

    变量中的数据保存在内存中,是临时的;文件数据保存在外存储器上,用于永久的保存大量的数据。根据数据的组织形式,
    文件分为文本文件和二进制文件。文本文件的每个字节存放一个ASCII代码,代表一个字符;二进制文件把内存中的数据,按照其在内存中的存储形式原样写到磁盘上存放。

    C++把每个文件看成一个有序的字节流(字符流或二进制流)。每个文件不是以文件结束符结束,就是以在系统维护和管理的数据结构中特定的字符结束。
    文件打开时,就会创建一个对象,将这个对象和某个流关联起来。C++中,要进行文件的输入/输出,必须首先创建一个流,与文件关联,才能进行读写操作

    C++进行文件处理时,需要包含头文件<iostream.h>和<fstream.h>
    <fstream.h>头文件包括流类ifstream(从文件输入)、ofstream(向文件输出)和fstream(从文件输入/输出)的定义。这三个流分别从istream、ostream和iostream类继承而来。
    #include<iostream.h>是非标准输入输出流,#include是标准输入输出流。C++中为了避免名字定义冲突,特别引入了”名字空间的定义”,即namespace。当代码中用<iostream.h>时,输出可直接引用cout<<x;,<iostream.h>继承C语言的标准库文件,未引入名字空间定义,所以可直接使用。当代码中引入时,输出需要引用std::cout<<x;如果还是按原来的方法就会有错。使用时,引入std::有以下方法:

    using namespace std; 
    cout<<x;using std::cout;
    cout<<x;
     
    ③最基本的std::cout<<x;
    

    顺序访问文件:

    要正确地进行文件地输入/输出,需要遵循以下步骤:

    1. 定义相关地流对象
      包含头文件<fstream.h>建立流,定义流对象
    2. 文件的打开
      打开文件有两种方法:①使用open函数 ②流类构造函数打开
      一、open()函数
      open函数是ifstream、ofstream和fstream类的成员函数。原型定义如下:
    void open ( const char *,ios_base::openmode mode = ios_base::in | ios_base::out );
    void open ( const unsigned char *, int mode, int access = filebuf::openprot );
    

    第一个参数用来传递文件名称;第二个参数mode决定文件的打开方式

    打开方式:
    ios::app             将输出写入文件末尾
    ios::ate             打开文件,并将文件指针移到文件末尾
    ios::in              打开文件进行输入
    ios::out             打开文件进行输出
    ios::nocreate        文件不存在,则open()失败
    ios::noreplace       文件存在,则open()失败
    ios::trunc           删除文件中现有数据(覆盖同名文件)
    ios::binary          以二进制方式打开,进行输入/输出(默认方式为文本方式)
     
    打开文件的属性:
    0 	             普通文件,打开操作
    1	             只读文件
    2	             隐含文件
    4	             系统文件
    

    例如👇

    例如:
    ofstream out;
    out.open("test.tt", ios::out);   //表示用输出流对象out打开一个"test.tt"文件。
    

    当一个文件需要多种方式打开时,可以用”或”操作符把几种方式连接在一起。例如打开一个能用于输入\输出的二进制文件:

    fstream inout;
    inout.open("test.tt", ios::in | ios::out | ios::binary);
    

    打开文件后要判断是否打开成功:

    if(inout.is_open())    //如果打开成功则进行读写操作
    {...}
    

    二、流类构造函数打开

    虽然完全可以用open()函数打开文件,但是类ifstream、ofstream和fstream中的构造函数都有自动打开文件功能,这些构造函数的参数及默认值与open()函数完全相同。因此,打开文件的最常见形式简化为:文件输入/输出流类 流对象名(“文件名称”);

    例如:ofstream out("test.tt");
    

    使用构造函数打开文件后,直接使用流对象判断是否打开成功。

    if(!out)
    {
        cout << "文件打开失败!" <<endl;
        //错误处理
    }
    
    1. 文件的读写:
      文件一旦打开,从文件中读取数据或向文件中写入数据将变得十分容易,只需要使用运算符”>>”和”<<”就可以了,只是必须用与文件相连接的流对象代替cin和cout。例如:
    ofstream out("test.tt");
    if(out)
    {
        out << 10 << "hello!\n";
        out.close();
    }
    
    1. 文件的关闭
      使用完文件后,应该把它关闭,即把打开的文件与流分开。对应于open()函数,使用close()函数关闭文件。在流对象的析构函数中,也具有自动关闭功能。

    例子👇文本文件读写(文件的打开方式默认为文本方式)⭐⭐

    #include <iostream>
    #include <fstream>
    using namespace std;
     
    int main()
    {
    	char str[20] = "Welcome to C++!";
    	int i = 1234;
    	char ch;
    	ofstream out("test.tt");     //打开输出文件流
    	if(out)                      //如果成功
    	{
    		out << str << '\n' << i;   //向文件输入信息
    		out.close();               //关闭
    	}
     
    	ifstream in("test.tt");            //打开输入文件流
    	if(in)                          
    	{                
    		while(in.get(ch))          //输出显示
    			cout << ch;
    		cout <<endl;
    		in.close();
    	}
    	return 0;
    }
    

    例子👇二进制文件读写⭐
    文本文件中存放的是字符,而二进制文件中存放的是二进制位。对二进制文件读写有两种方式,一种是使用get()和put()函数。一种是使用read()和write()函数。当然,这4个函数也可用于文本文件的读写。

    get()函数和put()函数原型如下:

    istream& get(unsigned char& ch);
    ostream& put(char ch);
    

    get()是类istream的成员函数,功能是从文件流中只读取一个字节,并把值放在ch中,put()是类ostream的成员函数,功能是向文件流中写入一个字节ch。当读文件过程中遇到结束符时,与之相连的文件流值变为0,所以可以根据此判断文件是否结束。

    实例:

    #include <iostream>
    #include <fstream>
    using namespace std;
     
    void myread(const char* fname)
    {
    	ifstream file_read(fname, ios::binary);
    	char c;
    	if(file_read)
    	{
    		while(file_read.get(c))       //文件没有结束时
    			cout << c;              
    	}
    }
     
    void mywrite(const char* fname)
    {
    	ofstream file_write(fname, ios::binary);
    	char c = 'A';
    		if(file_write)
    		{
    			for(int i = 0; i < 26; i++)
    				file_write.put(c+i);
    		}
    }
     
    int main()
    {
    	char fname[20] = "word.file";
    	mywrite(fname);
    	myread(fname);
            cout <<endl;
    	return 0;
    }
    

    有时需要读写一组数据到文件,read()函数是类istream的成员函数,它从相应的流中读取num个字节放在buf所指向的缓冲区中。write()函数是ostream的成员函数,它从buf所指的缓冲区中向相应的流写入num个字节。例如:

    int list[] = {12, 13, 14, 15};
    write((unsigned char*)&list, sizeof(list));
    

    定义了一个整形数组list,为了写入它的全部数据,必须在函数write()中指定它的首地址&list,并转换为unsigned char*类型,由sizeof()指定要写入的字节数。
    一组数据的文件读写实例:👇☆★

    #include <iostream>
    #include <fstream>
    using namespace std;
     
    void myread(const char* fname)
    {
    	ifstream file_read(fname, ios::binary);
    	char c[30];
    	if(file_read)
    	{
    		file_read.read(c, 26*sizeof(char));
    		c[26] = '\0';
    		cout << c <<endl;
    	}
    }
     
    void mywrite(const char* fname)
    {
    	char c[30];
    	for(int i = 0; i < 26; i++)
    		c[i] = 'A' + i;
    	ofstream file_write(fname, ios::binary);
    	if(file_write)
    		file_write.write(c, 26*sizeof(char));
    }
     
    int main()
    {
    	char fname[20] = "word.file";
    	mywrite(fname);
    	myread(fname);
    	return 0;
    }
    

    随机访问文件

    顺序访问文件不适合快速访问的应用程序。为了增加程序的灵活性和快捷性,立即找到特定记录信息,C++提供了随机移动文件访问指针的函数,可以移动输入/输出流中的文件指针,从而对文件数据进行随机读写。

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

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

    fstream, 类似istream, 有一个被称为get pointer的指针,指向下一个将被读取的元素。
    ofstream, 类似 ostream, 有一个指针 put pointer ,指向写入下一个元素的位置。
    fstream, 类似 iostream, 同时继承了get 和 put
    

    tellg() 和 tellp()
    这两个成员函数不用传入参数,返回pos_type 类型的值(根据ANSI-C++ 标准) ,就是一个整数,代表**当前get 流指针的位置 (用tellg) 或 put 流指针的位置(**用tellp)。

    C++支持的文件流中,通过文件指针方式从相应的文件位置进行读写。
    其中的get()函数指针用于指出下一次输入操作的位置;
    put()函数指针用于指出下一个输出操作的位置。
    每当发生一次读写操作时,相应的get()函数指针或put()函数指针会自动连续地增加。
    另外也可以使用seekg()函数和seekp()函数迅速定位,找到指定的位置访问文件。函数原型如下:
    ostream& seekp(streamoff off, ios::seek_dir dir); istream& seekg(streamoff off, ios::seek_dir dir);

    函数seekp()用于输出文件,将相应的文件指针get从dir的位置移动off个字节;函数seekg()用于输入文件,将相应的文件指针put从dir的位置移动到off个字节。
    其中类型streamoff相当于long类型,定义文件指针要偏移的位置范围。参数dir表示文件指针的起始位置,off表示相对于这个位置移动的位偏移量。Dir取值如下:

    ios::beg:从文件头开始,此时off取值为正。
    ios::cur:从文件当前位置开始,此时off取值为负。
    ios::end:从文件末尾开始,此时off取值可正可负。
    

    获取一个二进制文件的大小:👇

    #include <iostream.h>
    #include <fstream.h>
        
    const char * filename = "test.txt";
        
    int main()
    {
        long l,m;
        ifstream in(filename, ios::in|ios::binary);
        l = in.tellg();
        in.seekg (0, ios::end);
        m = in.tellg();
        in.close();
        cout << "size of " << filename;
        cout << " is " << (m-l) << " bytes.\n";
        return 0;
    }
     
    

    随机访问文件实例👇:

    #include <iostream>
    #include <fstream>
    using namespace std;
     
    void myread(const char* fname)
    {
    	ifstream file_read(fname, ios::binary);
    	char c[10];
    	if(file_read)
    	{
    		file_read.seekg(1, ios::beg);       //从开始位置移动1位
    		file_read.get(c[0]);                //读取一个字符
    		file_read.seekg(2, ios::cur);       //从当前位置移动2位
    		file_read.get(&c[1], 4*sizeof(char));
                    //一次读取1个字符,连续读取3次,最后一个'\0'
    		cout << c;
    	}
    }
     
    void mywrite(const char* fname)
    {
    	char c[30];
    	for(int i = 0; i < 26; i++)
    		c[i] = 'A' + i;
    	ofstream file_write(fname, ios::binary);
    	if(file_write)
    		file_write.write(c, 26*sizeof(char));
    }
     
    int main()
    {
    	char fname[20] = "word.file";
    	mywrite(fname);
    	myread(fname);
            cout <<endl;
    	return 0;
    }
    
    展开全文
  • C++输入输出流重载

    千次阅读 2014-07-30 21:17:00
    ”是C++在类库中提供的,所有C++编译系统都在类库中提供输入流类istream和输出流类ostream。cin和cout分别是istream类和ostream类的对象。在类库提供的头文件中已经对“&lt;&lt;”和“&gt;&gt;”...

    C++的流插入运算符“<<”和流提取运算符“>>”是C++在类库中提供的,所有C++编译系统都在类库中提供输入流类istream和输出流类ostream。cin和cout分别是istream类和ostream类的对象。在类库提供的头文件中已经对“<<”和“>>”进行了重载,使之作为流插入运算符和流提取运算符,能用来输出和输入C++标准类型的数据。因此,凡是用“cout<<”和“cin>>”对标准类型数据进行输入输出的,都要用#include 把头文件包含到本程序文件中。

    用户自己定义的类型的数据,是不能直接用“<<”和“>>”来输出和输入的。如果想用它们输出和输入自己声明的类型的数据,必须对它们重载。

    对“<<”和“>>”重载的函数形式如下:
        istream & operator >> (istream &, 自定义类 &);
        ostream & operator << (ostream &, 自定义类 &);
    即重载运算符“>>”的函数的第一个参数和函数的类型都必须是istream&类型,第二个参数是要进行输入操作的类。重载“<<”的函数的第一个参数和函数的类型都必须是ostream&类型,第二个参数是要进行输出操作的类。因此,只能将重载“>>”和“<<”的函数作为友元函数或普通的函数,而不能将它们定义为成员函数

    重载流插入运算符“<<”

    在程序中,人们希望能用插入运算符“<<”来输出用户自己声明的类的对象的信息,这就需要重载流插入运算符“<<”。

    用重载的“<<”输出复数

    #include <iostream>
    using namespace std;
    class Complex
    {
       public:
       Complex( ){real=0;imag=0;}
       Complex(double r,double i){real=r;imag=i;}
       Complex operator + (Complex &c2);  //运算符“+”重载为成员函数
       friend ostream& operator << (ostream&,Complex&);  //运算符“<<”重载为友元函数
       private:
       double real;
       double imag;
    };
    
    Complex Complex::operator + (Complex &c2)//定义运算符“+”重载函数
    {
       return Complex(real+c2.real,imag+c2.imag);
    }
    ostream& operator << (ostream& output,Complex& c) //定义运算符“<<”重载函数
    {
       output<<"("<<c.real<<"+"<<c.imag<<"i)"<<endl;
       return output;
    }
    
    int main( )
    {
       Complex c1(2,4),c2(6,10),c3;
       c3=c1+c2;
       cout<<c3;
       return 0;
    }

    运行结果如下:

    运行结果为:
    (8+14i)

    可以看到在对运算符“<<”重载后,在程序中用“<<”不仅能输出标准类型数据,而且可以输出用户自己定义的类对象。用“cout<<c3”即能以复数形式输出复数对象c3的值。形式直观,可读性好,易于使用。

    下面对怎样实现运算符重载作一些说明。程序中重载了运算符“<<”,运算符重载函数中的形参output是ostream类对象的引用,形参名output是用户任意起的。分析main函数最后第二行:
        cout<<c3;
    运算符“<<”的左面是cout,前面已提到cout是ostream类对象。“<<”的右面是c3,它是Complex类对象。由于已将运算符“<<”的重载函数声明为Complex类的友元函数,编译系统把“cout<<c3”解释为
        operator<<(cout, c3)
    即以cout和c3作为实参,调用下面的operator<<函数:
        ostream& operator<<(ostream& output,Complex& c)
        {
           output<<"("<<c.real<<"+"<<c.imag<<"i)"<<endl;
           return output;
        }
    调用函数时,形参output成为cout的引用,形参c成为c3的引用。因此调用函数的过程相当于执行:
        cout<<″(″<<c3.real<<″+″<<c3.imag<<″i)″<<endl; return cout;
    请注意,上一行中的“<<”是C++预定义的流插入符,因为它右侧的操作数是字符串常量和double类型数据。执行cout语句输出复数形式的信息。然后执行return语句。

    请思考,return  output的作用是什么?回答是能连续向输出流插入信息。output是ostream类的对象,它是实参cout的引用,也就是cout通过传送地址给output,使它们二者共享同一段存储单元,或者说output是cout的别名。因此,return output就是return cout,将输出流cout的现状返回,即保留输出流的现状。

    请问返回到哪里?刚才是在执行
        cout<<c3;
    在已知cout<<c3的返回值是cout的当前值。如果有以下输出:
        cout<<c3<<c2;
    先处理
        cout<<c3

       (cout<<c3)<<c2;
    而执行(cout<<c3)得到的结果就是具有新内容的流对象cout,因此,(cout<<c3)<<c2相当于cout(新值)<<c2。运算符“<<”左侧是ostream类对象cout,右侧是Complex类对象c2,则再次调用运算符“<<”重载函数,接着向输出流插入c2的数据。现在可以理解了为什么C++规定运算符“<<”重载函数的第一个参数和函数的类型都必须是ostream类型的引用,就是为了返回cout的当前值以便连续输出。

    请读者注意区分什么情况下的“<<”是标准类型数据的流插入符,什么情况下的“<<”是重载的流插入符。如
        cout<<c3<<5<<endl;
    有下划线的是调用重载的流插入符,后面两个“<<”不是重载的流插入符,因为它的右侧不是Complex类对象而是标准类型的数据,是用预定义的流插入符处理的。

    还有一点要说明,在本程序中,在Complex类中定义了运算符“<<”重载函数为友元函数,因此只有在输出Complex类对象时才能使用重载的运算符,对其他类型的对象是无效的。如
        cout<<time1;  //time1是Time类对象,不能使用用于Complex类的重载运算符

    重载流提取运算符“>>”

    C++预定义的运算符“>>”的作用是从一个输入流中提取数据,如“cin>>i;”表示从输入流中提取一个整数赋给变量i(假设已定义i为int型)。重载流提取运算符的目的是希望将“>>”用于输入自定义类型的对象的信息。

    增加重载流提取运算符“>>”,用“cin>>”输入复数,用“cout<<”输出复数。

    #include <iostream>
    using namespace std;
    class Complex
    {
       public:
       friend ostream& operator << (ostream&,Complex&); //声明重载运算符“<<”
       friend istream& operator >> (istream&,Complex&); //声明重载运算符“>>”
       private:
       double real;
       double imag;
    };
    ostream& operator << (ostream& output,Complex& c)
    {
       output<<"("<<c.real;
       if(c.imag>=0) output<<"+";//虚部为正数时,在虚部前加“+”号
       output<<c.imag<<"i)"<<endl;  //虚部为负数时,在虚部前不加“+”号
       return output;
    }
    istream& operator >> (istream& input,Complex& c)  //定义重载运算符“>>”
    {
       cout<<"input real part and imaginary part of complex number:";
       input>>c.real>>c.imag;
       return input;
    }
    int main( )
    {
       Complex c1,c2;
       cin>>c1>>c2;
       cout<<"c1="<<c1<<endl;
       cout<<"c2="<<c2<<endl;
       return 0;
    }

    可以看到,在C++中,运算符重载是很重要的、很有实用意义的。它使类的设计更加丰富多彩,扩大了类的功能和使用范围,使程序易于理解,易于对对象进行操作,它体现了为用户着想、方便用户使用的思想。有了运算符重载,在声明了类之后,人们就可以像使用标准类型一样来使用自己声明的类。类的声明往往是一劳永逸的,有了好的类,用户在程序中就不必定义许多成员函数去完成某些运算和输入输出的功能,使主函数更加简单易读。好的运算符重载能体现面向对象程序设计思想。

    可以看到,在运算符重载中使用引用(reference)的重要性。利用引用作为函数的形参可以在调用函数的过程中不是用传递值的方式进行虚实结合,而是通过传址方式使形参成为实参的别名,因此不生成临时变量(实参的副本),减少了时间和空间的开销。此外,如果重载函数的返回值是对象的引用时,返回的不是常量,而是引用所代表的对象,它可以出现在赋值号的左侧而成为左值(left value),可以被赋值或参与其他操作(如保留cout流的当前值以便能连续使用“<<”输出)。但使用引用时要特别小心,因为修改了引用就等于修改了它所代表的对象。

    展开全文
  • 这是C++面向对象程序设计第七版的一个案例分析,里面包含了很多内容,有些我还没有掌握,比如输入输出流运算符的重载等等,但是我感觉这个案例很好,对于不会程序分块的读者该案例也有许多借鉴的地方。程序如下...

    这是C++面向对象程序设计第七版的一个案例分析,里面包含了很多内容,有些我还没有掌握,比如输入输出流运算符的重载等等,但是我感觉这个案例很好,对于不会程序分块的读者该案例也有许多借鉴的地方。

    程序如下

    头文件dtime.h:这是DigitalTime类的接口部分

    这个类的值表示一天当中的时间。值采取24小时制进行输入输出

    例如,9:30表示9:30AM,14:45表示2:45PM

    #ifndef DTIME_H
    #define DTIME_H
    #include<iostream>
    using namespace std;
    
    class DigitalTime
    {
    public:
    	friend bool operator ==(const DigitalTime& time1, const DigitalTime& time2);
    	//如果time1和time2代表相同的时间,就返回true;否则返回false
    
    	DigitalTime(int the_hour, int the_minute);
    	//前条件:0<= the_hour <=23,而且0<=the_minute<=59
    	//将时间初始化为the_hour和the_minute
    
    	DigitalTime();
    	//将时间初始化为0:00(代表午夜)
    
    	void advance(int minutes_added);
    	//前条件:对象已经有一个时间值
    	//后条件:时间更改为minutes_added分钟之后
    
    	void advance(int hours_added,int minutes_added);
    	//前条件:对象已有一个时间值
    	//后条件:将时间值调后hours_added小时加minutes_added分钟
    
    	friend istream& operator >>(istream& ins,DigitalTime& the_object);
    	//重载>>操作符,允许输入DigitalTime类型的值
    	//前条件:如果ins是一个文件输入流,那么ins已经与一个文件连接
    
    	friend ostream& operator <<(ostream& outs,const DigitalTime& the_object);
    	//重载<<操作符,允许输入DigitalTime类型的值
    	//前条件:如果outs是一个文件输出流,那么outs已经与一个文件连接
    private:
    	int hour;
    	int minute;
    };
    
    #endif

    实现文件dtim.cpp

    这是ADT类DigitalTime的“实现”部分

    DigitalTime类的接口放在头文件dtime.h中

    #include<iostream>
    #include<cctype>
    #include<cstdlib>
    #include"dtime.h"
    using namespace std;
    
    //一下函数声明在重载的输入操作符>>的定义中使用:
    
    void read_hour(istream& ins, int& the_hour);
    //前条件;流ins中的下一个输入是一个采用24小时制的时间,比如9:45或者14:45
    //后条件:the_hour被设为时间的小时部分.冒号被舍弃,读取的下一个输入将是分钟数
    
    void read_minute(istream& ins, int& the_minute);
    //read_hour函数读取了小时数之后,这个函数从流ins中读取分钟数
    
    int digit_to_int(char c);
    //前条件:c是'0'~'9'的一个数值
    //返回数字的整数值;例如,digit_to_int('3')返回3
    
    bool operator ==(const DigitalTime& time1, const DigitalTime& time2)
    {
    	return (time1.hour==time2.hour&&time1.minute==time2.minute);
    }
    
    //使用iostream和cstdlib:
    DigitalTime::DigitalTime(int the_hour,int the_minute)
    {
    	if(the_hour<0||the_hour>23||the_minute<0||the_minute>59)
    	{
    		cout<<"Illegal argument to DigitalTime constructor.";
    		exit(1);
    	}
    	else
    	{
    		hour=the_hour;
    		minute=the_minute;
    	}
    }
    
    DigitalTime::DigitalTime() : hour(0),minute(0)
    {
    	//主体有意留空
    }
    
    void DigitalTime::advance(int minutes_added)
    {
    	int gross_minutes = minute+minutes_added;
    	minute=gross_minutes%60;
    
    	int hour_adjustment=gross_minutes/60;
    	hour=(hour+hour_adjustment)%24;
    }
    
    void DigitalTime::advance(int hours_added, int minutes_added)
    {
    	hour=(hour+hours_added)%24;
    	advance(minutes_added);
    }
    
    //使用iostream:
    ostream& operator <<(ostream& outs, const DigitalTime& the_object)
    {
    	outs<<the_object.hour<<':';
    	if(the_object.minute<10)
    		outs<<'0';
    	outs<<the_object.minute;
    	return outs;
    }
    
    //使用iostream:
    istream& operator >>(istream& ins,DigitalTime& the_object)
    {
    	read_hour(ins, the_object.hour);
    	read_minute(ins, the_object.minute);
    	return ins;
    }
    
    int digit_to_int(char c)
    {
    	return (int(c)-int('0'));
    }
    
    //使用iostream,cctype和cstdlib:
    void read_minute(istream& ins,int& the_minute)
    {
    	char c1,c2;
    	ins>>c1>>c2;
    	if(!(isdigit(c1)&&isdigit(c2)))
    	{
    		cout<<"Error illegal input to read_minute\n";
    		exit(1);
    	}
    	the_minute = digit_to_int(c1)*10+digit_to_int(c2);
    	if(the_minute<0||the_minute>59)
    	{
    		cout<<"Error illegal input to read_minute\n";
    		exit(1);
    	}
    }
    
    //使用iostream, cctype和cstdlib:
    void read_hour(istream& ins,int& the_hour)
    {
    	char c1,c2;
    	ins>>c1>>c2;
    	if(!(isdigit(c1)&&(isdigit(c2)||c2==':')))
    	{
    		cout<<"Error illegal input to read_hour\n";
    		exit(1);
    	}
    	if(isdigit(c1)&&c2==':')
    	{
    		the_hour=digit_to_int(c1);
    	}
    	else //(isdigit(c1)&&isdigit(c2))
    	{
    		the_hour=digit_to_int(c1)*10+digit_to_int(c2);
    		ins>>c2;  //舍弃':'
    		if(c2!=':')
    		{
    			cout<<"Error illegal input to read_hour\n";
    			exit(1);
    		}
    	}
    	if(the_hour<0||the_hour>23)
    	{
    		cout<<"Error illegal input to read_hour\n";
    		exit(1);
    	}
    }

    应用程序文件timedemo.cpp

    该程序演示了DigitalTime类的使用

    #include<iostream>
    #include"dtime.h"
    using namespace std;
    
    int main()
    {
    	DigitalTime clock,old_clock;
    
    	cout<<"Enter the time in 24 hour notation: ";
    	cin>>clock;
    
    	old_clock=clock;
    	clock.advance(15);
    	if(clock==old_clock)
    		cout<<"something is wrong.";
    	cout<<"you entered "<<old_clock<<endl;
    	cout<<"15 minutes later the time will be "
    		<<clock<<endl;
    	clock.advance(2,15);
    	cout<<"2 hours and 15minutes after that\n"
    		<<"the time will be"
    		<<clock<<endl;
    	return 0;
    }

    有问题或者想一起学习的评论区留言。

    展开全文
  • C++输入输出流

    2016-04-23 12:29:41
    C++输入输出流

    C++里并没有任何关于输入输出流的定义,而是在标准库 (standard library)中包含了iostream库 (iostream library)iostream库 包含了istreamostream两个基础类型,istream表示输入流ostream表示输出流
    (一个stream就是一个字符序列,术语”stream“想要表达的意思是:随着时间推移,字符是顺序生成或消耗的。)
    standard library中定义了四个IO对象(object):

    1. cin 标准输入(standard input)istream对象,用于输入。
    2. cout 标准输出(standard output)
    3. cerr 标准错误(standard error)
    4. clog

    后三个都为ostream 对象 ,用于输出。

    其中cerr 用于输出警告和错误信息,clog 用于输出程序运行时的一般信息。

    在程序中,若我们要使用标准库设施,那我们必须先包含相关的头文件header file),所以若我们要用到iostream设施,必须先包含iostream 这个头文件

    #include<iostream>

    一、先来讲讲输出流

    下面是一个表达式:
    
    std::cout << "Enter two numbers:" << std::endl;

    首先指出,标准库中定义的多有名字都在命名空间(namespacestd 中, 所以当使用标准库 的设施时,都要在名字前面加std并用作用于运算符::指向std命名空间.

    for example:

    
    std::cout
    std::cin 
    std::cerr 
    std::clog 
    

    再来讲讲上面那个表达式,表达式中“<<” 是一个输出运算符,用于在标准输出(standard output)中打印消息。
    “<<” 运算符接受两个运算对象,左侧必须是一个ostream对象,右侧的运算对象是要打印的值“<<” 运算符将给定的值写到给定的ostream对象中,运算结果就是写如给定值的这个ostream对象,即运算结果是一个ostream对象,只是这个ostream对象中已经写入了给定的数据。
    上面那个表达式也等于:

    (std::cout << "Enter two numbers:") << std::endl;
    //or
    std::cout << "Enter two numbers:";
    std::cout << std::endl; 

    最后再讲一下表达式中的数据:
    1.双引号里的是一个字符串字面值常量*(string literal*),顾名思义,字符串字面值常量的值就是表面看到的字符串
    2.第二个被打印的消息是endl (end line),他的名称是操纵符(manipulator),endl 的功能不仅仅是结束当前行,更重要的功能是endl能够刷新缓冲区,即将与设备相关的缓冲去区里的内容冲刷到设备中,这个动作的意义在于可以保证到目前为止,程序所产生的所有输出都真正的写入输出流中,而不是停留在内存中等待输入流。

    二、再来讲讲输入流

    下面是一个表达式:
    
    int v1 = 0, v2 = 0;
    std::cin >> v1 >> v2;

    首先是初始化(initialize)了两个int型变量,用来存储数据。
    “>>” 是一个输入运算符,与输出运算符相类似,“>>”
    接受一个istream作为其左侧运算对象,并接受一个对象作为其右侧运算对象 用于保存从输入流中读取的数据,这里是v1v2。同样的与输出运算对象类似,“>>” 返回其左侧运算对象最为运算结果,即一个数据已被读取了的istream对象
    所以上面那个表达式也等价于:

    (sdt::cin >> v1) >> v2;
    //or
    std::cin >> v1;
    std::cin >>v2;

    三、最后的最后

    再来看看一个表达式:
    
    std::cout << "The sum of" << v1 << " and " << v2 << " is "
          << v1 + v2 << std::endl;

    上面可以看到一个有意思的地方:
    就是运算对象并不都是相同的类型,”The sum of”是字符串字面值常量,而v1,v2则是int型。
    这是因为,标准库定义了不同版本的输入输出运算符,用于处理这些不同的数据类型,这也是一种运算符重载

    下一篇再来讲讲这些输入输出运算符的聪明之处。

    展开全文
  • 包含头文件#include2. 建立文件对象3. 打开文件夹4. 测试是否打开成功5. 进行读写操作6. 关闭文件#include#includeusing namespace std;int main(){ifstream ifile;ofstream ofile;ifile.open("d:\\fileIn.txt...
  • java之九 基本输入输出流

    千次阅读 2016-05-23 18:48:10
    流的概念   ...Java程序通过流来完成输入/输出。流是生产或消费信息的抽象。流通过Java的输入/输出系统与物理设备链接。尽管与它们链接的物理设备不尽相同,所有流的...同样,一个输出流可以输出到控制台,磁盘文
  • 包含头文件#include<fstream> 2. 建立文件对象 3. 打开文件夹 4. 测试是否打开成功 5. 进行读写操作 6. 关闭文件 #include<iostream> #include<fstream> using namespace std;...
  • 2. 输入输出流

    2021-01-13 08:49:22
    输入输出流 流类型 标准 I/O - 对系统指定的标准设备的输入和输出。即从键盘输入数据,输出到显示器屏幕。 文件 I/O - 以外存磁盘文件为对象进行输入和输出,即从磁盘文件输入数据,数据输出到磁盘文件。以外存 ...
  • C++--输入输出流

    2021-04-21 20:35:17
    输入输出流1. 输入输出2. 输入输出流2.1 流2.2 C++标准IO流2.3 C++文件IO流3. stringstream 1. 输入输出 程序的输入:从输入文件将数据传送给程序; 程序的输出:从程序将数据传送给输出文件; C++输入输出包括: ...
  • 输入输出流

    2018-05-21 20:28:55
    输出流输入流cout是一个输出流对象,它是“console out”(控制台输出)的缩写,又称为插入运算符,是输出数据的,是属于basic_ostream类中的对象。而ostream类在iostream头文件中定义。cin是一个输入流对象,又称为...
  • C/C++,Java 重定向输入输出流至文件

    千次阅读 2014-04-05 13:44:25
    在我们做Online Judge的时候,OJ基本上都是用标准输入输出。...使用函数freopen(), freopen是被包含与stdio.h头文件中,用于重定向输入输出流的函数。该函数可以在不改变代码原貌的情况下改变输入输出环
  • 当程序员在编写程序的时候,最不可分割的是对文件做的相应的操作,总结C++中输入输出流及文件流操作大家都了解吗?想要了解的朋友,就随爱站技术频道小编来看看吧。1、流的控制iomanip 在使用格式化I/O时应包含此...
  • 以外存磁盘文件为对象进行输入输出,即从磁盘文件输入数据,数据输出到磁盘文件。 串I/O 对内存中指定的空间进行输入输出。通常指定一个字符数组作为存储空间(实际上可以利用该空间存储任何信息)。 C++的...
  • 下面先来看C++的标准输入输出流 对象标准流 头文件 #include <iostream> // #include <istream> // input stream输入流 // #include <stream> // output stream输出流 iostream库定义了三个...
  • C++输入输出运算符的重载

    千次阅读 多人点赞 2018-07-26 10:49:48
    ”在C++类库中提供的,所有的C++编译系统都会在提供输入流istream和输出流ostream,cin、cout是分别是istream类和ostream类的对象,在类库的头文件中已经对“&amp;amp;lt;&amp;amp;lt;”、“&amp;amp;gt...
  • 2.C++基本的输入输出流(简单介绍一下就行)   cout;输出  cin>>"hello">>endl;输入 3.重载  定义:函数重载:对一个函数名重新赋予它新的含义,使一个函数名可以多用,所谓重载就是一物多用。  限制:...
  • 实验八 输入输出流(二)

    千次阅读 多人点赞 2018-05-17 11:25:05
    (1) 新建一个工程demo2,设计一个类Student,其成员变量包括学号(no)、姓名(name)、性别(sex)、专业(major)、联系方式(phone)和地址(addr)。 (2) 为类Student定义成员函数writeTo,实现从给定文本文件中读取学生...
  • 输入输出的含义 从操作系统角度来看,每一个与主机相连的输入输出设备都看作一个文件。...C++输入输出包括3个方面: 对系统指定的标准设备的输入输出。即从键盘输入数据,输出到显示屏。这种输入输出称为标准的输...
  • C++之输入输出流

    2019-10-04 20:16:01
    输入输出流:1. I/O(输入/输出)流类库提供对象之间的数据交互服务 流类库预定义了一批流对象,连接常用的外部设备 程序员可以定义所需的I/O流对象,使用流库提供的工作方式 实现数据传输2.流类和流对象: 程序中,...
  • c++输入输出流

    2018-07-12 23:20:23
    C++输入输出包含以下三个方面的内容: 对系统指定的标准设备的输入和输出。即从键盘输入数据,输出到显示器屏幕。这种输入输出称为标准的输入输出,简称标准I/O。 以外存磁盘文件为对象进行输入和输出,即从磁盘...
  • 【C++】输入输出流及文件流操作

    千次阅读 2019-01-31 19:49:32
    C++中输入输出流及文件流操作 1、流的控制  iomanip 在使用格式化I/O时应包含头文件。  stdiostream 用于混合使用C和C + +的I/O机制时,例如想将C程序转变为C++程序 2、类继承关系 ios是抽象基类,由它...
  • 使用这两种迭代器可以把输入输出流当作容器来操作。(头文件iterator) 下面是输入输出流常见的简单用法: #include &lt;iostream&gt; #include &lt;iterator&gt; #includ...
  • C++学习 | 输入输出流
  • 原标题:C++ 中输入输出流及文件流操作笔记(点击上方公众号,可快速关注)来源: 伯乐在线专栏作者/沙米笔记链接:http://blog.jobbole.com/105682/1、流的控制iomanip在使用格式化I/O时应包含头文件。stdiostream...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,639
精华内容 5,055
关键字:

包含重载输入输出流的头文件