精华内容
下载资源
问答
  • c++文件流
    千次阅读
    2022-04-19 21:23:45

    彻底搞懂C++文件流。
    首先需要头文件#include< fstream >
    fstream可以把它理解成一个父类,包含的子类有ifstream和ofstream等,
    所以一般直接创建一个父类对象即可(即fstream类的对象)

    下边的代码讲解了
    1:4种文件的读写操作
    2:如何使用get(),put(),getline(),write()以及read()函数。
    3:如何得到文件的大小。
    4:seekg()和teelg()配套使用的真谛,seekp()和teelp()同理

    //文件流;
    #include<iostream>
    #include<fstream>  //ifstream  ofstream
    using namespace std;
    /*
    	No1.文件流流类
    	ofstream:打开文件,写文件
    	ifstream:打开文件,读操作
    	fstream:可读可写
    	No2.一般用包含#include<fstream>
    	No3.打开文件,关闭文件
    	打开文件:
    	void open(const char* URL,ios::openmode mode);
    	mode: 
    		ios:in  读的方式打开文件
    		ios:out 写的方式打开文件
    		ios::app 追加的方式写文件
    		ios::ate  在已有的文件,文件指针在文件末尾
    		ios::trunc  文件不存在,创建文件
    		ios::binary  二进制形式打开文件,默认方式ASCII码方式打开
    		ios::nocreate  不创建的方式
    		ios::norepalce  不替换
    	组合方式:用的是位或
    		ios::in|ios::out 可读写
    		ios::out|ios::binary 二进制写的方式打开文件,
    	判断文件是否打开成功:
    		1.is_open() 判断打开是否成功
    		2.!文件对象  判断文件是否打开成佛那个
    	关闭文件:close()成员函数关闭;
    	*/
    void testOpenFile() {    //用于测试用的函数
    	//C++中打开文件是文件对象,不是文件指针。
    
    	fstream File,File1;
    	File.open("2.txt", ios::in | ios::out );
    	File1.open("3.txt", ios::in | ios::out | ios::trunc);
    	//使用open函数和直接用构造函数是一样的效果。
    	if (!File.is_open()) {
    		cerr << "2.txt 打开文件失败!!\n";
    	}
    	if (!File) {
    		cerr << "2.txt打开文件失败!!!\n";
    	}//这个if语句和上一个if语句作用相同
    	if (!File1.is_open()) {
    		cerr << "3.txt打开文件失败!!\n";
    	}
    	else {
    		cout << "3.txt 打开成功!!!\n";
    	}
    	File.close();
    	File1.close();
    }
    //No2.读写方式:
    void asciiReadWriteFile(const char* readFileName, const char* writeFileName) {
    	fstream read(readFileName, ios::in);
    	fstream write(writeFileName, ios::out);
    	//第一种读写方式:ASCII  直接流的方式读写, >>  <<
    	/*while (1) {
    		char temp;
    		read >> temp;
    		if (read.eof()) {
    			break;
    		}
    		write << temp;
    	}*/
    	//第二种方式读写方式:可以保留空格和换行,用get()和put();
    	/*while (1) {
    		char temp;
    		read.get(temp);
    		//temp=read.get();一样的效果!
    		if (read.eof()) {
    			break;
    		}
    		write.put(temp);
    	}*/
    	//第三种读写方式:不能保留空格和换行,用getline()和write().
    	char str[40]; 
    	while (!read.eof()) {
    		memset(str, ' ', 40);
    		read.getline(str,40);
    		int len = strlen(str);
    		write.write(str,len);
    		write.put('\n');
    	}
    }
    //使用二进制读写方式  使用read()和write()函数来实现
    void binaryReadWriteFile(const char* readFile, const char* writeFile) {
    	fstream read(readFile, ios::in | ios::binary);
    	fstream write(writeFile, ios::out | ios::binary);
    	while (!read.eof()) {
    		char str[1024]="";
    		read.read(str, 1024);
    		
    		write.write(str, 1024);
    	}
    	read.close();
    	write.close();
    }
    //
    void testSeekReadFile(const char* fileName) {
    	fstream fread(fileName, ios::in);
    	fstream fwrite(fileName, ios::app|ios::out);
    	if (!fread) {
    		cerr << "打开文件\"fileName\"!失败!";
    	}
    	int f = fread.tellg();
    	fread.seekg(0,ios::end);
    	int l = fread.tellg();
    	cout << "size  of  " << fileName << "is "<<(l - f) << "bytes.";
    	fread.seekg(5);//表示将指针位置设置到绝对位置5;
    	cout << (char)fread.get() << endl;
    	fread.seekg(-1, ios::cur);		//seekg的第一个参数为负,表示从当前位置往前移
    	cout << (char)fread.get() << endl;
    	fread.seekg(1, ios::cur);//第一个参数为正,表示从当前位置往后数的第一个位置。
    	
    	fwrite.put('w');//在末尾追加写。
    }
    int main() {
    	testOpenFile();
    	asciiReadWriteFile("read.txt","write.txt");
    	binaryReadWriteFile("read.txt", "binaryTest.txt");
    	testSeekReadFile("read.txt");
    	return 0;
    }
    
    更多相关内容
  • C++ 文件流详解

    千次阅读 多人点赞 2020-02-05 14:20:31
    C++使用进行操作文件

    前言:
    我们刚开始学习C 时,都是使用iostream里面的cin和cout进行控制台的输入和输出,现在我们学习如何从文件读取流和向文件写入流。

    IO: 向设备输入数据和输出数据

    C 的IO流:
    在这里插入图片描述

    设备:

    1. 文件
    2. 控制台
    3. 特定的数据类型(stringstream)

    c 中,必须通过特定的已经定义好的类, 来处理IO(输入输出)
    在这里插入图片描述


    欲要使用文件流,这就需要用到 C 中的标准库 #include < fstream >,它定义了三个数据类型:
    ofstream:该数据类型表示输出文件流,用于创建文件并向文件写入信息。
    ifstream:该数据类型表示输入文件流,用于从文件读取信息。
    fstream:该数据类型表示输入和输出文件流,且同时具有 ofstream 和 ifstream 两种功能,这意味着它可以创建文件,向文件写入信息,从文件读取信息。


    定义文件流

    想要使用文件流对文件进行操作,修必须要先定义它。
    定义时须包含头文件#include< fstream >

    三种定义方法:

    #include <fstream>
    
    using namespace std;	// 声明命名空间
    
    int main(void) {
    	// 1》
    	// 声明输出文件流,用于创建文件并向文件写入信息。
    	ofstream outFile;
    
    	// 2》
    	// 声明输入文件流,用于从文件读取信息。
    	ifstream inFIle;
    
    	// 3》
    	// 声明输入和输出文件流,且同时具有 ofstream 和 ifstream 两种功能,这意味着它可以创建文件,向文件写入信息,从文件读取信息。
    	fstream stream;
    
    	return 0}
    

    打开文件

    在从文件读取信息或者向文件写入信息之前,必须先打开文件。ofstream 和fstream 对象都可以用来打开文件进行写操作,如果只需要打开文件进行读操作,则使用 ifstream 和 fstream对象。

    打开文件的方法:
    使用open()函数进行文件的打开

    #include < fstream >
    void open( const char *filename );

    例1:ofstream打开文件的方式(写数据进文件中)

    ofstream outFile;
    outFile.open("demo.txt");		// 默认方式打开文件
    

    例2:ifstream打开文件的方式(读取文件中的数据)

    ifstream inFile;
    inFile.open("demo.txt");		// 默认当方式打开文件
    

    例3: fstream打开文件的方式(读写文件中的数据)

    fstream stream
    stream.open("demo.txt");		// 默认方式打开文件
    

    文件的打开方式

    模式标志描述
    ios::in读方式打开文件
    ios::out写方式打开文件
    ios::trunc如果此文件已经存在, 就会打开文件之前把文件长度截断为0
    ios::app尾部最加方式(在尾部写入)
    ios::ate文件打开后, 定位到文件尾
    ios::binary二进制方式(默认是文本方式)

    以上打开方式, 可以使用位操作 | 组合起来

    例:
    如果你只是想对文件进行写入操作,当文件已经存在时,你希望对该文件进行截断操作,那么就可这样组合:

    fstream stream;
    stream.open("demo.txt", ios::out | ios::trunc);
    

    如果你只是想对文件进行读取操作,而且想在文件尾部读取,那么就可以这样组合:

    fstrem inFile;
    inFile.open("demo.txt", ios::in | ios::ate);
    

    判断文件是否打开成功

    使用is_open()函数进行文件的判断
    当成功打开文件返回真(true),失败返回假(false)

    例:

    fstream stream;
    
    stream.open("demo.txt");
    // 判断文件是否打开成功
    if (!stream.is_open()) {
    	cout << "文件打开失败!" << endl;
    	system("pause");
    	exit(-1);
    }
    

    关闭文件

    使用close()函数进行关闭文件
    函数的作用是:关闭相关的文件流。

    例:

    // 定义文件流
    fstream stream;
    // 打开文件
    stream.open("demo.txt");
    // 关闭文件
    stream.close();
    ///
    

    我们要养成好习惯,打开文件后,一定义要关闭文件再结束程序。


    写文件

    在C 中,写文件除了要用到ofstream 或者 fstream 外,我们还需要用到一个流插入运算符(<<)。

    例:

    需求:
    让用户来输入姓名和年龄,并保存到文件中。
    直到用户输入ctrl z

    /*
    需求:
    让用户来输入姓名和年龄,并保存到文件中。
    直到用户输入ctrl z
    */
    
    #include <iostream>
    #include <Windows.h>
    #include <string>
    #include <fstream>
    
    // 写文件
    using namespace std;
    
    int main1(void) {
    	string name;
    	int age;
    	ofstream outfile;	// 定义写文件流
    
    	// 打开文件
    	outfile.open("text.txt", ios::out | ios::trunc);
    	if (!outfile.is_open()) {	// 判断文件是否打开失败
    		cout << "文件打开失败!" << endl;
    		system("pause");
    		exit(-1);
    	}
    
    	while (1) {
    		cout << "请输入姓名:";
    		cin >> name;
    
    		if (cin.eof()) {
    			break;
    		}
    		
    		// *******************************
    		outfile << name << "\t";		// 将从键盘读取的数据写入文件中
    		// *******************************
    
    		cout << "请输入年龄:";
    		cin >> age;
    
    		// 将从键盘读取的数据写入文件中
    		outfile << age << endl;
    
    		// 可以连环写入文件
    		// outfile << name << "\t" << age << endl;
    	}
    
    	// 关闭文件
    	outfile.close();
    	system("pause");
    	return 0;
    }
    

    运行截图:
    在这里插入图片描述
    在这里插入图片描述


    读文件

    在C 中,读文件除了要用到ifstream 或者 fstream 外,我们还需要用到一个流插入运算符(>>)。

    例:
    需求:
    在上一个写入文件的例子中,把它写入的text.txt文件中的所有内容都读取出来,并打印出来。

    #include <iostream>
    #include <Windows.h>
    #include <string>
    #include <fstream>
    
    // 读文件
    using namespace std;
    
    int main(void) {
    	ifstream inFile;
    	string name;
    	int age;
    
    	// 打开文件
    	inFile.open("text.txt");
    	if (!inFile.is_open()) {	// 判断文件是否打开失败
    		cout << "文件打开失败!" << endl;
    		system("pause");
    		exit(-1);
    	}
    
    	while (1) {
    		// 从文件中读取第一个数据,并将其打印出来
    		inFile >> name;
    		if (inFile.eof()) {
    			break;
    		}
    		cout << name << "\t";
    
    		// 从文件读取第二数据,并将其打印出来
    		inFile >> age;
    		cout << age << endl;
    	}
    
    	system("pause");
    	inFile.close();
    	return 0;
    }
    

    运行截图:
    在这里插入图片描述


    读取文件中的一行数据

    使用getline()可以读取文件中的一行数据

    例:

    stream inFile;
    string line;
    
    inFile("text.txt");
    
    // 从文件中读取一行数据,并将读取到的数据写入字符串变量line中
    getline(inFile, line);
    

    总结:

    好了,这就是文件的基本用法,C 文件并不难,只要理解好,读取文件要用到搞混文件流,写入文件要用到哪个文件流;需要用到什么方式打开文件等等。不要搞混。

    展开全文
  • C++文件流

    2014-08-14 13:49:11
    C++文件流操作.ppt 程序设计实习 输入输出流和文件操作
  • C++文件操作和文件流

    千次阅读 2022-03-10 19:49:04
    C++文件操作和文件流1文件的概念2 文件流的分类2 打开文件2.1 通过类对象调用`open`函数打开一个文件2.2 通过类对象构造函数打开文件3 关闭文件4 读写文件4.1 文本文件的读写4.2 二进制文件的读写 1文件的概念 根据...

    1文件的概念

    根据文件中数据的组织方式,可以将文件分为文本文件二进制文件

    • 文本文件:又称字符文件或ASCII文件,它的每一个字节放一个ASCII代码,代表一个字符。
    • 二进制文件:又称内部格式文件或字节文件,是把内存中的数据按其在内存中的存储形式原样输出到磁盘中存放。

    比如:数字 64 在内存中表示为 0100 0000,若将其保存为 文本文件,则要分别存放十位 6 和个位 4 的 ASCII 码,为 0011 0110 0011 0100,占用两个字节;若将其保存为二进制文件,则按内存中形式直接输出,为 0100 0000,占用一个字节。

    文本文件中数据与字符一一对应,一个字节代表一个字符,可以直接在屏幕上显示或打印出来,这种方式使用方便,比较直观,便于阅读,但一般占用存储空间较大,而且输出时要将二进制转化为 ASCII 码比较花费时间。

    二进制文件,输出时不需要进行转化,直接将内存中的形式输出到文件中,占用存储空间较小,但一个字节并不对应一个文件,不能直观显示文件中的内容。

    2 文件流的分类

    文件流是以外存文件未输入输出对象的数据流。输出文件流是从内存流向外存文件的数据,输入文件流是从外存文件流向内存的数据。每一个文件流都有一个内存缓冲区与之对应。

    C++有三个用于文件操作的文件类:

    ofstream //文件的写操作(输出),主要是从内存写入存储设备(如磁盘),继承了istream类
    ifstream //文件的读操作(输入),主要是从存储设备中读取数据到内存,继承了ostream类
    fstream //文件的读写操作,对打开的文件可进行读写操作,继承了iostream类
    

    操作的过程:要以磁盘文件(外存文件)为对象进行输入输出,必须定义一个文件流类的对象,通过文件流对象将数据从内存输出到磁盘文件,或者将磁盘文件输入到内存。

    定义文件流对象后,我们还需要将文件流对象和指定的磁盘文件建立关联,以便使文件流流向指定的磁盘文件,并确定文件的工作方式(是输入还是输出,二进制还是文本)。我们可以在定义流对象的时候指定参数来调用构造函数,或者通过成员函数open()来进行文件流对象和指定文件的关联(后面会讲)。

    C++中输入输出流关系如下:
    在这里插入图片描述

    以上,箭头表示继承关系。

    istream,ostream,iostream三者为例,看一下具体的继承关系,如下:

    template<typename _CharT, typename _Traits>
        class basic_istream : virtual public basic_ios<_CharT, _Traits>;
    template<typename _CharT, typename _Traits>
        class basic_ostream : virtual public basic_ios<_CharT, _Traits>;
    template<typename _CharT, typename _Traits>
        class basic_iostream
        : public basic_istream<_CharT, _Traits>,
          public basic_ostream<_CharT, _Traits>;
    
       /// Base class for @c char streams.
       typedef basic_ios<char>         ios; //基础类
     
       /// Base class for @c char buffers.
       typedef basic_streambuf<char>     streambuf;
     
       /// Base class for @c char input streams.
       typedef basic_istream<char>         istream;
     
      /// Base class for @c char output streams.
      typedef basic_ostream<char>         ostream;
    
      /// Base class for @c char mixed input and output streams.
      typedef basic_iostream<char>         iostream;
    
      /// Class for @c char memory buffers.
      typedef basic_stringbuf<char>     stringbuf;
    
      /// Class for @c char input memory streams.
      typedef basic_istringstream<char>     istringstream;
    
      /// Class for @c char output memory streams.           
      typedef  basic_ostringstream<char>     ostringstream;
    
      /// Class for @c char mixed input and output memory streams.
      typedef basic_stringstream<char>     stringstream;
    
      /// Class for @c char file buffers.
      typedef basic_filebuf<char>         filebuf;
    
     /// Class for @c char input file streams.
      typedef basic_ifstream<char>         ifstream;
    
      /// Class for @c char output file streams.
      typedef basic_ofstream<char>         ofstream;
    
      /// Class for @c char mixed input and output file streams.
      typedef basic_fstream<char>         fstream;
    

    可以看到basic_istreambasic_ostream都是虚继承于basic_iosbasic_iostream是继承于basic_istreambasic_ostream,注意这里继承于basic_ios的时候之所以要用虚拟继承,是为了防止多重继承时,多个父类共用基类产生二义性。

    2 打开文件

    打开文件操作主要是把我们的文件流类对象和一个文件相关联起来,这样这个被打开的文件可以用类对象表示,之后我们对文件流类对象所做的输入和输出操作其实就是对这个文件所做的操作。

    2.1 通过类对象调用open函数打开一个文件

    在每个文件流的类中都定义了一个打开文件的成员函数open,函数原型如下

    void open(const char* filename,ios_base::openmode mode);
    //参数的含义:
       filename:  要打开的文件名
      mode:    要打开文件的方式
    

    其中mode定义在所有IO的基类中:即ios类,它包括如下几种方式:

    //文件的输入和输出是从内存的角度看的:数据载入内存叫输入,数据从内存到其他地方叫输出。
    os::app     //追加模式,即所有写入都追加到文件末尾
    ios::ate     //文件打开后定位到文件尾
    ios::binary   //以二进制方式打开文件,缺省的方式是文本方式
    ios::in    //文件以输入方式打开(文件数据输入到内存)(ifstream对象默认方式就是这个)
    ios::out    //文件以输出方式打开(内存数据输出到文件)(ofstream对象默认的打开方式)
    ios::nocreate //不建立文件,所以文件不存在时打开失败
    ios::noreplace//不覆盖文件,所以打开文件时如果文件存在失败
    ios::trunc   //如果文件存在,把文件长度设为0
    

    mode参数可以组合起来使用,但是两个参数之间必须要用操作符|隔开,如下

    ofstream out;  //声明一个ofstream对象out
    out.open("text.txt",ios::out|ios::app);  //往text.txt文件中输入内容,输入方式在文件的末尾追加内容,且不清空原有的内容
    

    或者

    //这个声明方式是调用了ofstream有参构造函数,该构造函数会自动调用open函数。
    ofstream out("text.txt",ios::out|ios::app)

    2.2 通过类对象构造函数打开文件

    ofstream, ifstreamfstream的对象所进行的第一个操作通常都是打开文件,这些类都有一个构造函数可以直接调用open 函数,并拥有同样的参数。这样,我们就可以通过以下方式进行与上面同样的定义对象和打开文件的操作:

    ofstream file ("example.bin", ios::out | ios::app | ios::binary);
    
    //例如:以二进制输入方式打开文件c:\config.sys 
    fstream file1;
    file1.open("c:\\config.sys",ios::binary|ios::in,0);
    
    //如果open函数只有文件名一个参数,则是以读/写普通文件打开,即:
    file1.open("c:\\config.sys");<=>file1.open("c:\\config.sys",ios::in|ios::out,0);
    
    //另外,fstream还有和open()一样的构造函数,对于上例,在定义的时侯就可以打开文件了:
    fstream file1("c:\\config.sys");
    

    3 关闭文件

    当我们完成对文件的操作后,需要调用成员函数close来关闭我们的文件流,close函数的作用其实就是清空该类对象在缓存中的内容并且关闭该对象和文件的关联关系,那个该对象可以和其他文件进行关联。

    ofstream file;  //声明一个ofstream对象file
    file.open("text.txt",ios::out|ios::app);  
    file.close();  //关闭"text.txt"文件
    

    为了防止一个类对象被销毁后,还和某个文件保留关联关系,所以文件流类的析构函数都会自动调用close函数。

    4 读写文件

    对文件读写操作要分两种:文本文件的读写、二进制文件的读写

    4.1 文本文件的读写

    文本文件的读写很简单:用插入器(<<)向文件输出;用析取器(>>)从文件输入。

    插入器(<<) 向流输出数据。比如说系统有一个默认的标准输出流(cout),一般情况下就是指的显示器,所以,cout<<“Write
    Stdout”<<‘n’;就表示把字符串"Write Stdout"和换行字符(‘n’)输出到标准输出流。

    析取器(>>)
    从流中输入数据。比如说系统有一个默认的标准输入流(cin),一般情况下就是指的键盘,所以,cin>>x;就表示从标准输入流中读取一个指定类型(即变量x的类型)的数据

    比如读取写入txt文件,如下

       #include "iostream"
       #include<fstream>
       void main()
       {
           std::fstream f("d:\\test.txt", ios::out);//定义了一个对象f,只写,"d:\\test.txt"文件不存在则创建,存在则清空原内容
           f << 1234 << ' ' << 3.14 << 'A' << "How are you"; //写入数据
           f.close();//关闭文件以使其重新变为可访问,函数一旦调用,原先的流对象就可以被用来打开其它的文件
           f.open("d:\\try.txt", ios::in);//打开文件,只读
           int i;
           double d;
           char c;
           char s[20];
           f >> i >> d >> c;               //读取数据
           f.getline(s, 20);
           std::cout << i << std::endl;    //显示各数据
           std::cout << d << std::endl;   //endl是一种格式,表示输出一个换行符,并刷新此流
           std::cout << c << std::endl;
           std::cout << s << std::endl;
           f.close();
       }
    

    还有一些其他的格式如下

    操纵符功能
    dec格式化为十进制数值数据
    endl输出一个换行符并刷新此流
    ends输出一个空字符
    hex格式化为十六进制数值数据
    oct格式化为八进制数值数据
    setpxecision(int p)设置浮点数的精度位数

    也可以利用文件流对象的成员函数 get, put 等,其用法如下:
    put()
    put()函数向流写入一个字符,其原型是ofstream &put(char ch),使用也比较简单,如file1.put('c');就是向流写一个字符'c'

    get()
    get()函数比较灵活,有3种常用的重载形式:

    一种就是和put()对应的形式:ifstream &get(char &ch);
    功能是从流中读取一个字符,结果保存在引用ch中,如果到文件尾,返回空字符。如file2.get(x);表示从文件中读取一个字符,并把读取的字符保存在x中。

    另一种重载形式的原型是: int get();这种形式是从流中返回一个字符,如果到达文件尾,返回EOF,如x=file2.get();和上例功能是一样的。

    还一种形式的原型是:
    ifstream &get(char *buf,int num,char delim='n');
    这种形式把字符读入由buf指向的数组,直到读入了num个字符或遇到了由 delim指定的字符,如果没使用 delim这个参数,将使用缺省值换行符'n'。例如:
    file2.get(str1,127,'A');//从文件中读取字符到字符串str1,当遇到字符’A’或读取了127个字符时终止。

    4.2 二进制文件的读写

    二进制文件的操作需要在打开文件的时候指定打开方式为ios::binary,并且还可以指定为既能输入又能输出的文件,我们通过成员函数 readwrite来读写二进制文件。

    //这里 buffer 是一块内存的地址,用来存储或读出数据。参数size 是一个整数值,表示要从缓存(buffer)中读出或写入的字符数。
    istream& read ( char * buffer, streamsize size);
    ostream& write (char * buffer, streamsize size);
    
    展开全文
  • C++文件流,指针

    千次阅读 2017-11-13 21:28:32
    1、简单文件输出 ofstream outFile; outFile.open("filetest.txt"); outFile &lt;&lt; "这是文本输出的测试文件" &lt;&lt; endl; outFile.close();9 2、文本输入测试 ...

    1、简单文件输出流

    ofstream outFile;
    outFile.open("filetest.txt");
    outFile << "这是文本输出流的测试文件" << endl;
    outFile.close();9

    2、文本输入测试

    ifstream infile("filetest.txt");
    if (infile.is_open()==false){   
        cout << "不能打开 " << endl;
    }
    else
    {
        char buffer[50];
        infile.getline(buffer, 50);
        cout << buffer << endl;
    }

    3、函数原型中可以不含变量名

    void cheers (int );
    

    4、形参传递中数组名和实际和指针代表的含义相同.使用sizeof 打印传递的数组的长度,实际上智能显示指针的长度,因为实际算上传递的就是指针。

    int sum_arr(int arr[], int n) ;
    int sum_arr(int *arr,  int n);
    

    5、

    void show_array(const double arr[], int n);
    

    意味着 其中在本函数中 ,通过 arr[]指向的那个数组,通过使用arr[x]的方式不能修改其值

    6、const 与指针

    • const 变量地址 –>const指针 合法
    • const 变量地址 –>普通指针 非法
    • 非const变量指针–>const指针 合法
    • const变量地址 –>const指针 合法
    int age =39;
    const int * pt=&age;
    
    const float g_earth =9.80;
    const float *pe =&g_earth;
    
    const float g_moon 1.163;
    float *p =&g_moon;
    
    • 哪个参数是const 的注意看const后面是什么,是指针还是解引用
    int * const finger =&sloth;       //const 后面是指针finger 故指针不能变化,指向的内容可以变
    int const * finger =&sloth;       //const 后面的是* finger 故解引用不可变,指针可以变化
    const int * const finger &sloth; //两个const 故指针和解引用均不可变
    

    image

    7、指针数组与数组指针

    • 通过结合性分析,若没有括号,则应该为右结合性,说明是个数组;若有括号,则括号内先结合,应该是个指针
    int  * arr[4];     //指针数组,存储4int* 的数组
    int  (*arr)[4]     //数组指针,指针指向一个形如 int a[4] 的数组

    8、函数指针,返回函数的指针

    double pam (int );
    double (*pf)(int);
    
    pf=pam;
    
    pam(5);
    (*pf)(5);     //以上两种都是调用pam 函数,功能相同。
    • 以下几项等价
    double *f1 (const double ar[], int n);
    double *f2 (const double []  , int n);
    double *f3 (const double *   ,int n);
    展开全文
  • C++文件流操作的读与写,这里是作者初学的一些终结,希望各位海涵啊
  • C++文件流方式写入excel文件

    千次阅读 2018-11-06 15:52:26
    由于项目中要用到excel文件的写入,特地上网查了一些C++写入excel文件的方法,看到网上许多方法都利用了MFC库函数,感觉添加库比较麻烦,所以自己找了一种比较简单明了的方法,对于一般excel格式的写入应该足以应付...
  • C++文件流的建立与关闭

    千次阅读 2017-04-23 15:55:58
    文件流以磁盘文件以及其他可按文件方式进行管理的外部设备作为输入输出对象。ifstream是文件输入流类,ofstream是文件输出流类,fstream是文件输如输出流类。要利用这些类来定义文件流对象,必须在程序的开始部分...
  • C++文件流状态的判别与定位

    千次阅读 2017-04-23 16:29:51
    文件流状态的判别  可以用文件流对象的下列成员函数来判别文件流的当前状态:  # is_open():判定流对象是否与一个打开的文件相联系,若是,返回true,否则返回false  # good():刚进行的操作成功时返回true...
  • C++ 简单的文件流

    2022-04-07 22:26:23
    C++ 文件流 ifstream 、ofstream、fstream
  • C++文件流: 代码如下:fstream // 文件流ifstream // 输入文件流ofstream // 输出文件流//创建一个文本文件并写入信息//同向屏幕上输出信息一样将信息输出至文件#include<iomanip>#include<fstream>void main(){...
  • C++文件流在ios类中定义

    千次阅读 2019-04-17 10:37:53
    最近用到了C++输入输出操作,所以顺手记了下来。以后再慢慢补充 ofstream(默认是ios::in | ios::trunc)、ifstream(默认是ios::in)、fstream(默认是ios::in | ios::out)不同的对应操作不一样 ios::app Opens an...
  • C++ 文件操作之文件流操作

    千次阅读 2022-03-15 09:50:19
    (后续进行更多补充) 常见的操作如下: #include ofstream //文件写操作 内存写入存储设备 ifstream //文件读操作,存储设备读区到内存中 fstream //读写操作,对打开的文件可进行读写操作 具体一些代码功能实现 ...
  • 事情是这样,我最近需要一个c++的简单的记log到文件的功能,就是一个比较临时的功能,我第一反应就是用c++文件流标准库简单实现。很自然我就凭着记忆写下了下边的代码(因为算是临时的一个功能,错误判断也就没有加...
  • C++ 文件读写操作文件流

    千次阅读 2020-12-06 21:55:33
    到目前为止,我们已经使用了 iostream 标准库,它提供了 cin 和 cout 方法分别用于从标准输入读取流和向标准输出写入流。 本教程介绍如何从文件读取流和向文件写入流...该数据类型通常表示文件流,且同时具有 ofstream
  • C++文件输入/输出

    千次阅读 2022-03-24 19:16:48
    文章目录文件输入/输出类表5: 文件读写模式表6:ios_base 标识的组合意义ofstream:写入文件类例8:输出文本文件例9:输出二进制文件ifstream:从文件中读取的类例10:输入文本文件例11:输入二进制文件表7:...
  • 在看C++编程思想中,每个练习基本都是使用ofstream,ifstream,fstream,以前粗略知道其用法和含义,在看了几位大牛的博文后,进行整理和总结: 这里主要是讨论fstream的内容: [java] view plain ...
  • C++ STL 实现的文件处理函数大全,包括一些常用的但标准库中没有字符串处理。内部含有的正则部分,是采用的boost库,不需要的完全可以去掉,不影响其他函数的使用。
  • C++ 文件流的定位

    千次阅读 2020-02-01 20:27:49
    设置该输入的位置(只能ifstream和fstream定义的文件类型使用) seekg(参数一,参数二); 参数一:偏移量 参数二:相对位置 beg 相对于开始位置 cur 相对于当前位置 end 相对于结束位置 例: 1.beg:定位到...
  • C++流(读写文件)

    千次阅读 2021-08-18 21:12:39
    C++流读写文本文件二进制读写文件按指定格式读写文件文件流的状态检查文件流的三种定位 seekg tellg seekp常见的错误 读写文本文件 C++的IO流: IO:向设备输入数据和输出数据 设备有: 1)文件 2)控制台 3)特定的...
  • c++文件流基本用法(fstream, ifstream)

    万次阅读 2017-03-13 21:33:18
    本文将会讲述c++文件流的用法。 有错误和疏漏的地方,欢迎批评指证。 需要包含的头文件:   名字空间: std 也可以试用 fstream提供了三个类,用来实现c++对文件的操作。(文件的创建,读写)。 ifstream -- 从已有...
  • c++文件流操作.

    2013-07-10 12:16:29
    c++文件流操作.
  • C++文件流读写操作

    千次阅读 2019-06-24 14:27:28
    C++中,有一个stream这个类,所有的I/O都以这个“”类为基础的,包括我们要认识的文件I/O. stream这个类有两个重要的运算符: 1、插入器(<<) 向输出数据。比如说系统有一个默认的标准输出(cout),...
  • 请问这是为什么啊? ![图片](https://img-ask.csdn.net/upload/201704/27/1493253164_307171.png)![图片](https://img-ask.csdn.net/upload/201704/27/1493253172_802945.png)
  • 使用C++文件流库fstream,以字符串形式读取十六进制文本文件的内容,将这些十六进制数据转换为int型数据,并分类存储
  • C++文件流操作

    2011-11-05 07:53:13
    C++文件流操作整合,希望对大家有帮助!!!
  • C++string常用函数,c++文件流操作,C++中的日期和时间
  • 通过在VS2022中创建一个项目,展示通过标准C++文件流对象读写二进制数据文件。 在VS2022中创建C++空项目, 点击“创建”,完成空项目的创建。 在解决方案资源管理器视图中,右键单击项目名、添加、新建项,...
  • 本文实例为大家分享了C++中输入输出流及文件流操作笔记,供大家参考,具体内容如下 1、流的控制  iomanip 在使用格式化I/O时应包含此头文件。  stdiostream 用于混合使用C和C + +的I/O机制时,例如想将C程序...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 235,738
精华内容 94,295
关键字:

c++文件流

c++ 订阅
友情链接: Verilog.rar