#include <QCoreApplication>
#include <QFileInfo>
#include <QStringList>
#include <QDateTime>
#include <QDebug>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 以只写方式打开，如果文件不存在，那么会创建该文件
    QFile file("myfile.txt");
    if (!file.open(QIODevice::WriteOnly  | QIODevice::Text))
        qDebug() << file.errorString();
    file.write("helloQt!\nhahahahaha");
    file.close();

    // 获取文件信息
    QFileInfo info(file);
    qDebug() << QObject::tr("绝对路径：") << info.absoluteFilePath() << endl
             << QObject::tr("文件名：") << info.fileName() << endl
             << QObject::tr("基本名称：") << info.baseName() << endl
             << QObject::tr("后缀：") << info.suffix() << endl
             << QObject::tr("创建时间：") << info.created() << endl
             << QObject::tr("大小：") << info.size();
    // 以只读方式打开
    if (!file.open(QIODevice::ReadOnly  | QIODevice::Text))
        qDebug() << file.errorString();
    qDebug() << QObject::tr("文件内容：") << endl << file.readAll();
    qDebug() << QObject::tr("当前位置：") << file.pos();
    file.seek(0);
    QByteArray array;
    array = file.read(5);
    qDebug() << QObject::tr("前5个字符：") << array
             << QObject::tr("当前位置：") << file.pos();
    file.seek(15);
    array = file.read(5);
    qDebug() << QObject::tr("第16-20个字符：") << array;
    file.close();

    return a.exec();
}
 

IO原理
 
最近在研究 JAVA NIO 的相关知识，学习NIO，就不能提到IO的原理和事项，必经NIO是基于IO进化而来
 
IO涉及到的底层的概念大致如下：
 
缓冲区操作。2) 内核空间与用户空间。3) 虚拟内存。4) 分页技术
 
一，虚拟存储器
 虚拟存储器是硬件异常(缺页异常)、硬件地址翻译、主存、磁盘文件和内核软件的完美交互，它为每个进程提供了一个大的、一致的和私有的地址空间。
 
虚拟存储器的三大能力：
 
①将主存看成是一个存储在磁盘上的地址空间的高速缓存。
 ②为每个进程提供了一个一致的地址空间。
 ③保护每个进程的地址空间不被其他进程破坏。
 
虚拟内存的两大好处：
 ① 一个以上的虚拟地址可指向同一个物理内存地址。
 ② 虚拟内存空间可大于实际可用的硬件内存。
 
二，用户空间与内核空间
 设虚拟地址为32位，那么虚拟地址空间的范围为0~4G。操作系统将这4G分为二部分，将最高的1G字节(虚拟地址范围为：0xC0000000-0xFFFFFFFF)供内核使用，称为内核空间。而将较低的3G字节供各个进程使用，称为用户空间。
 每个进程可以通过系统调用进入内核，因为内核是由所有的进程共享的。对于每一个具体的进程，它看到的都是4G大小的虚拟地址空间，即相当于每个进程都拥有一个4G大小的虚拟地址空间。
 
三，IO操作
 
一般IO缓冲区操作：
 
用户进程使用read()系统调用，要求其用户空间的缓冲区被填满。
内核向磁盘控制器硬件发命令，要求从磁盘读入数据。
磁盘控制器以DMA方式(数据不经过CPU)把数据复制到内核缓冲区。
内核将数据从内核缓冲区复制到用户进程发起read()调用时指定的用户缓冲区。
 
 
从上图可以看出：磁盘中的数据是先读取到内核的缓冲区中。然后再从内核的缓冲区复制到用户的缓冲区。为什么会这样呢？
 
因为用户空间的进程是不能直接硬件的(操作磁盘控制器)。磁盘是基于块存储的硬件设备，它一次操作固定大小的块，而用户请求请求的可能是任意大小的数据块。因此，将数据从磁盘传递到用户空间，由内核负责数据的分解、再组合。
 
内存映射IO：就是复用一个以上的虚拟地址可以指向同一个物理内存地址。将内核空间的缓冲区地址(内核地址空间)映射到物理内存地址区域，将用户空间的缓冲区地址(用户地址空间)也映射到相同的物理内存地址区域。从而数据不需要从内核缓冲区映射的物理内存地址移动到用户缓冲区映射的物理内存地址了。从链路上看，这样的方式明显比上述的IO操作方式要短了，节省出来的路程，就是NIO操作的优势所在
 
要求：①用户缓冲区与内核缓冲区必须使用相同的页大小对齐。
 ②缓冲区的大小必须是磁盘控制器块大小(512字节磁盘扇区)的倍数—因为磁盘是基于块存储的硬件设备，一次只能操作固定大小的数据块。
 
用户缓冲区按页对齐，会提高IO的效率—这也是为什么在JAVA中new 一个字节数组时，指定的大小为2的倍数(4096)的原因吧。
 
 
四，JAVA中的IO，本质上是把数据移进或者移出缓冲区。
 
read()和write()系统调用完成的作用是：把内核缓冲区映射的物理内存空间中的数据 拷贝到 用户缓冲区映射的物理内存空间中。
 
因此，当使用内存映射IO时，可视为：用户进程直接把文件数据当作内存，也就不需要使用read()或write()系统调用了。
 
当发起一个read()系统调用时，根据待读取的数据的位置生成一个虚拟地址(用户进程使用的是虚拟地址)，由MMU转换成物理地址，若内核中没有相应的数据，产生一个缺页请求，内核负责页面调入从而将数据从磁盘读取到内核缓冲区映射的物理内存中。对用户程序而言，这一切都是在不知不觉中进行。
 
总之，从根本上讲数据从磁盘装入内存是以页为单位通过分页技术装入内存的。
 
五，JAVA NIO中的直接缓存和非直接缓存
 
直接缓存：不是分配于堆上的存储，位于JVM之外，它不受JAVA的GC管理，相当于内核缓冲区。非直接缓存：建立在JAVA堆上的缓存，受JVM管理，相当于用户缓冲区。
 
根据上面第三点，将直接缓存中的数据写入通道的速度要快于非直接缓存。因为，连接到通道的另一端是文件(磁盘，FileChannel)或者网络(Socket通道)，这些都是某种形式上的硬件。那么，对于非直接缓存而言，数据从缓冲区传递到硬件，要经过内核缓冲区中转。而对于直接缓存而言，就不需要了，因为直接缓存已经直接映射到内核缓冲区了。
 
了解了上述的基本概念后，下面我们分别使用传统的IO方式和NIO方式实现一个文件拷贝的功能，简单对比一下
 
IO方式实现文件拷贝：
 
	//IO方法实现文件k拷贝
    private static void traditionalCopy(String sourcePath, String destPath) throws Exception {
        File source = new File(sourcePath);
        File dest = new File(destPath);
        if (!dest.exists()) {
            dest.createNewFile();
        }
        FileInputStream fis = new FileInputStream(source);
        FileOutputStream fos = new FileOutputStream(dest);
        byte[] buf = new byte[1024];
        int len = 0;
        while ((len = fis.read(buf)) != -1) {
            fos.write(buf, 0, len);
        }
        fis.close();
        fos.close();
    }
 
然后我们来测试一下一个比较大的文件拷贝，看看性能如何
 
public static void main(String[] args) throws Exception{
        long start = System.currentTimeMillis();
        traditionalCopy("D:\\常用软件\\JDK1.8\\jdk-8u181-linux-x64.tar.gz", "D:\\常用软件\\JDK1.8\\IO.tar.gz");
        long end = System.currentTimeMillis();
        System.out.println("用时为：" + (end-start));
    }
 
 
 
180M的文件，这个速度也还不算太差，下面我们再尝试使用NIO的方式试一下，提供两种方式的拷贝，
 
public void nioCpoy(String source, String target, int allocate) throws IOException{
        ByteBuffer byteBuffer = ByteBuffer.allocate(allocate);
        FileInputStream inputStream = new FileInputStream(source);
        FileChannel inChannel = inputStream.getChannel();

        FileOutputStream outputStream = new FileOutputStream(target);
        FileChannel outChannel = outputStream.getChannel();

        int length = inChannel.read(byteBuffer);
        while(length != -1){
            byteBuffer.flip();//读取模式转换写入模式
            outChannel.write(byteBuffer);
            byteBuffer.clear(); //清空缓存，等待下次写入
            // 再次读取文本内容
            length = inChannel.read(byteBuffer);
        }
        outputStream.close();
        outChannel.close();
        inputStream.close();
        inChannel.close();
    }
 
public static void fileChannelCopy(String sfPath, String tfPath) {

        File sf = new File(sfPath);
        File tf = new File(tfPath);
        FileInputStream fi = null;
        FileOutputStream fo = null;
        FileChannel in = null;
        FileChannel out = null;
        try{
            fi = new FileInputStream(sf);
            fo = new FileOutputStream(tf);
            in = fi.getChannel();//得到对应的文件通道
            out = fo.getChannel();//得到对应的文件通道
            in.transferTo(0, in.size(), out);//连接两个通道，并且从in通道读取，然后写入out通道
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                fi.close();
                in.close();
                fo.close();
                out.close();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
 
测试一下性能如何，运行一下下面的代码，
 
public static void main(String[] args) {
        long start = System.currentTimeMillis();
        String sPath = "D:\\常用软件\\JDK1.8\\jdk-8u181-linux-x64.tar.gz";
        String tPath = "D:\\常用软件\\JDK1.8\\NIO.tar.gz";
        fileChannelCopy(sPath,tPath);
        long end = System.currentTimeMillis();
        System.out.println("用时为：" + (end-start));
    }
 

 
 
这个效率通过简单的对比可以说明问题了，NIO在操作大文件读写时，性能优势就体现出来了，下面附上通过NIO操作文件读写的几个方法，后面做参考使用
 
/**
 * NIO读写文件工具类
 */
public class NIOFileUtil {

    private String file;

    public String getFile() {
        return file;
    }

    public void setFile(String file) {
        this.file = file;
    }

    public NIOFileUtil(String file) throws IOException {
        super();
        this.file = file;
    }

    /**
     * NIO读取文件
     * @param allocate
     * @throws IOException
     */
    public void read(int allocate) throws IOException {

        RandomAccessFile access = new RandomAccessFile(this.file, "r");

        //FileInputStream inputStream = new FileInputStream(this.file);
        FileChannel channel = access.getChannel();
        ByteBuffer byteBuffer = ByteBuffer.allocate(allocate);

        CharBuffer charBuffer = CharBuffer.allocate(allocate);
        Charset charset = Charset.forName("GBK");
        CharsetDecoder decoder = charset.newDecoder();
        int length = channel.read(byteBuffer);
        while (length != -1) {
            byteBuffer.flip();
            decoder.decode(byteBuffer, charBuffer, true);
            charBuffer.flip();
            System.out.println(charBuffer.toString());
            // 清空缓存
            byteBuffer.clear();
            charBuffer.clear();
            // 再次读取文本内容
            length = channel.read(byteBuffer);
        }
        channel.close();
        if (access != null) {
            access.close();
        }
    }

    /**
     * NIO写文件
     * @param context
     * @param allocate
     * @param chartName
     * @throws IOException
     */
    public void write(String context, int allocate, String chartName) throws IOException{
        // FileOutputStream outputStream = new FileOutputStream(this.file); //文件内容覆盖模式 --不推荐
        FileOutputStream outputStream = new FileOutputStream(this.file, true); //文件内容追加模式--推荐
        FileChannel channel = outputStream.getChannel();
        ByteBuffer byteBuffer = ByteBuffer.allocate(allocate);
        byteBuffer.put(context.getBytes(chartName));
        byteBuffer.flip();//读取模式转换为写入模式
        channel.write(byteBuffer);
        channel.close();
        if(outputStream != null){
            outputStream.close();
        }
    }

    /**
     * nio事实现文件拷贝
     * @param source
     * @param target
     * @param allocate
     * @throws IOException
     */
    public static void nioCpoy(String source, String target, int allocate) throws IOException{
        ByteBuffer byteBuffer = ByteBuffer.allocate(allocate);
        FileInputStream inputStream = new FileInputStream(source);
        FileChannel inChannel = inputStream.getChannel();

        FileOutputStream outputStream = new FileOutputStream(target);
        FileChannel outChannel = outputStream.getChannel();

        int length = inChannel.read(byteBuffer);
        while(length != -1){
            byteBuffer.flip();//读取模式转换写入模式
            outChannel.write(byteBuffer);
            byteBuffer.clear(); //清空缓存，等待下次写入
            // 再次读取文本内容
            length = inChannel.read(byteBuffer);
        }
        outputStream.close();
        outChannel.close();
        inputStream.close();
        inChannel.close();
    }

    //IO方法实现文件k拷贝
    private static void traditionalCopy(String sourcePath, String destPath) throws Exception {
        File source = new File(sourcePath);
        File dest = new File(destPath);
        if (!dest.exists()) {
            dest.createNewFile();
        }
        FileInputStream fis = new FileInputStream(source);
        FileOutputStream fos = new FileOutputStream(dest);
        byte[] buf = new byte[1024];
        int len = 0;
        while ((len = fis.read(buf)) != -1) {
            fos.write(buf, 0, len);
        }
        fis.close();
        fos.close();
    }

    public static void main(String[] args) throws Exception{
        /*long start = System.currentTimeMillis();
        traditionalCopy("D:\\常用软件\\JDK1.8\\jdk-8u181-linux-x64.tar.gz", "D:\\常用软件\\JDK1.8\\IO.tar.gz");
        long end = System.currentTimeMillis();
        System.out.println("用时为：" + (end-start));*/

        long start = System.currentTimeMillis();
        nioCpoy("D:\\常用软件\\JDK1.8\\jdk-8u181-linux-x64.tar.gz", "D:\\常用软件\\JDK1.8\\NIO.tar.gz",1024);
        long end = System.currentTimeMillis();
        System.out.println("用时为：" + (end-start));
    }

}
 
NIO在读写文件上体现出来的性能优势得益于其自身的结构设计，最重要的还是本文开头所讲的关于操作链路上的结构优化设计，掌握这一点原理基本就理解了NIO的实质，本篇到这里就结束了，最后感谢观看！

 
c语言读写文件程序：
 
#include "stdio.h"
 
#include 
 
main()
 
{
 
FILE *fp1;//定义文件流指针，用于打开读取的文件
 
FILE *fp2;//定义文件流指针，用于打开写操作的文件
 
char text[1024];//定义一个字符串数组，用于存储读取的字符
 
fp1 = fopen("d:\\a.txt","r");//只读方式打开文件a.txt
 
fp2 = fopen("d:\\b.txt","w");//写方式打开文件a.txt
 
while(fgets(text,1024,fp1)!=NULL)//逐行读取fp1所指向文件中的内容到text中
 
{
 
puts(text);//输出到屏幕
 
fputs(text,fp2);//将内容写到fp2所指向文件中
 
}
 
fclose(fp1);//关闭文件a.txt，有打开就要有关闭
 
fclose(fp2);//关闭文件b.txt
 
}
 
扩展资料：
 
C语言文件读写操作总结
 
一.非标准文件的读写 不带缓冲的
 
1.文件的打开和关闭
 
open()函数的作用是打开文件,其调用格式为: int open(char *filename, int access); 该函数表示按access的要求打开名为filename的文件,返回值为文件描述字,其中access有两部分内容: 基本模式和修饰符, 两者用" "("或")方式连接，修饰符可以有多个, 但基本模式只能有一个。
 
access的规定
 
O_RDONLY 只读
 
O_APPEND 文件指针指向末尾
 
O_WRONLY 只写
 
O_CREAT 文件不存在时创建文件, 属性按基本模式属性
 
O_RDWR 读写
 
O_BINARY 打开一个二进制文件
 
O_TEXT 打开一个文字文件
 
open()函数打开成功, 返回值就是文件描述字的值(非负值), 否则返回-1。 close()函数的作用是关闭由open()函数打开的文件, 其调用格式为: int close(int handle); 该函数关闭文件描述字handle相连的文件。
 
2.读写函数
 
int read(int handle, void *buf, int count);
 
read()函数从handle(文件描述字)相连的文件中, 读取count个字节放到buf所指的缓冲区中, 返回值为实际所读字节数, 返回-1表示出错。返回0 表示文件结束。
 
write()函数的调用格式为: int write(int handle, void *buf, int count); write()函数把count个字节从buf指向的缓冲区写入与handle相连的文件中, 返回值为实际写入的字节数。
 
3.随机定位函数
 
lseek()函数的调用格式为: int lseek(int handle, long offset, int fromwhere);
 
该函数对与handle相连的文件位置指针进行定位,功能和用法与fseek()函数相同。 tell()函数的调用格式为: long tell(int handle); 该函数返回与handle相连的文件现生位置指针, 功能和用法与ftell()相同
 
二、标准文件的读写
 
1.文件的打开函数fopen()
 
文件的打开操作表示将给用户指定的文件在内存分配一个FILE结构区，并将该结构的指针返回给用户程序，以后用户程序就可用此FILE指针来实现对指定文件的存取操作了。
 
当使用打开函数时，必须给出文件名、文件操作方式(读、写或读写),如果该文件名不存在，就意味着建立(只对写文件而言，对读文件则出错)，并将文件指针指向文件开头。若已有一个同名文件存在，则删除该文件，若无同名文件，则建立该文件，并将文件指针指向文件开头。
 
fopen(char *filename,char *type);
 
其中*filename是要打开文件的文件名指针，一般用双引号括起来的文件名表示，也可使用双反斜杠隔开的路径名。
 
而*type参数表示了对打开文件的操作方式。其可采用的操作方式如下：
 
"r" 打开，只读； "w" 打开，文件指针指到头，只写； "a" 打开，指向文件尾，在已存在文件中追加； "rb" 打开一个二进制文件，只读； "wb" 打开一个二进制文件，只写； "ab" 打开一个二进制文件，进行追加 ；
 
"r+" 以读/写方式打开一个已存在的文件； "w+" 以读/写方式建立一个新的文本文件 ；"a+" 以读/写方式打开一个文件文件进行追加 ；"rb+" 以读/写方式打开一个二进制文件； "wb+" 以读/写方式建立一个新的二进制文件 ；
 
"ab+" 以读/写方式打开一个二进制文件进行追加 ；当用fopen()成功的打开一个文件时，该函数将返回一个FILE指针，如果文件打开失败，将返回一个NULL指针。

打开文件的函数原型
 
FILE *fopen( const char * filename, const char * mode );
 
 读、写文件的几种模式
 
模式
描述
r(read)
具有文件的读权限。
w(write)
具有文件的写权限。
a(append)
在文件的末端添加数据。
b(binary)
文件的类型为二进制文件。
 
t(text)
 
文件的类型为文本文件。
+
具有文件的读写权限。
r:以只读的方式打开文件，如果文件不存在，则返回NULL。
r+:以读写的方式打开文件，如果文件不存在，则返回NULL。
a:追加文件并进行写操作，如果文件不存在，就创建文件，否则新增的内容被添加到文件的末端。
rt:以读方式打开一个文本文件。
wt:以写方式打开打开一个文本文件，如果文件不存在，则新建该文件。
rt+:以读写方式打开一个文本文件
wt+:以读写方式打开一个文本文件，如果文件不存在，则新建该文件。
如果处理的是二进制文件，则需使用下面的访问模式来取代上面的访问模式：
 
"rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b"
 

 例子：以只读的方式读取文本文件，并且过滤其中没有内容的行。 
 
#include <stdio.h>
#include <string.h>

#define BufferLen 256

// 读写文件
int main()
{
	FILE* fp = NULL;

	// 只允许读文件// 打开文件
	fopen_s(&fp,"work.txt", "r");

	char buffer[BufferLen];

	// 判断文件是否结束
	while (!feof(fp))
	{
		// 每次读取之前将buffer置为空
		memset(buffer,'\0', BufferLen * sizeof(char));

		// 读取出来的buffer会默认在最后一位加'\0'
		fgets(buffer, BufferLen, fp);

		// 所以读取的文件如果其中一行为空，则默认其长度为1
		// 过滤其中没有内容的行
		size_t len = strlen(buffer);
		if (len == 1)continue;

		printf("work contexts: %s", buffer);
	}

	// 关闭文件
	fclose(fp);
	
	return 0;
}