精华内容
下载资源
问答
  • 2020-07-01 08:37:33

    C语言文件读写-判断文件是否结束

    在读文件的时候,很重要的一个条件是:文件是否结束,因为文件已经结束了,就不用继续读文件了。

    判断文件结束,有许多方式,比如读取文本文件和二进制文件就可以使用不同的方式,下面分别进行详细介绍和举例。

    使用EOF判断文件是否结束

    EOF的值为-1,所以往往使用EOF也可以判断文件是否结束,一般用在非格式化文本文件读取中,如果在格式化文本读取时使用EOF来判断,在某些情况下是会出错的。

    函数fgetc返回的值为一个字符,当文件结束时,返回EOF,因为文本文件中可打印字符没有字符的值是-1,所以,可以用EOF来判断文件是否结束了。

    这也是唯一的一个可以使用EOF来判断文件是否结束,而且永远正确的函数,前提是必须是读文本文件(格式化或者非格式化都可以支持)。

    我们来看一下使用fgetc和EOF来检测文件是否结束的例子,代码如下:

    void EOF_test_getc(const char* file_name)
    {
    	int ch = 0;
    	int count = 0;
    	FILE *file = fopen(file_name,"r");
    	if(!file)
    		return;
    	while(1)
    	{
    		ch = fgetc(file);
    		if(ch == EOF)
    		{
    			printf("reach the end of file,the char number is %d\n",count);
    			break;
    		}
    		else
    		{
    			count++;
    			putchar(ch);
    		}
    	}
    	fclose
    更多相关内容
  • 在htaccess写法详解一文中已经过了htaccess文件一基本写法和语句原则,同时本文也不再阐述htaccess文件的作用之强大,今天只来讨论一下很多人都容易误解的一个地方,那就是.htaccess文件的作用范围
  • java使用nio读写文件

    万次阅读 多人点赞 2019-11-16 15:49:45
    IO原理 最近在研究 JAVA NIO 的相关知识,学习NIO...虚拟存储器是硬件异常(缺页异常)、硬件地址翻译、主存、磁盘文件和内核软件的完美交互,它为每个进程提供了一个大的、一致的和私有的地址空间。 虚拟存储器的三大...

    IO原理

    最近在研究 JAVA NIO 的相关知识,学习NIO,就不能提到IO的原理和事项,必经NIO是基于IO进化而来

    IO涉及到的底层的概念大致如下:

    1. 缓冲区操作。2) 内核空间与用户空间。3) 虚拟内存。4) 分页技术

    一,虚拟存储器
    虚拟存储器是硬件异常(缺页异常)、硬件地址翻译、主存、磁盘文件和内核软件的完美交互,它为每个进程提供了一个大的、一致的和私有的地址空间。

    虚拟存储器的三大能力:

    ①将主存看成是一个存储在磁盘上的地址空间的高速缓存。
    ②为每个进程提供了一个一致的地址空间。
    ③保护每个进程的地址空间不被其他进程破坏。

    虚拟内存的两大好处:
    ① 一个以上的虚拟地址可指向同一个物理内存地址。
    ② 虚拟内存空间可大于实际可用的硬件内存。

    二,用户空间与内核空间
    设虚拟地址为32位,那么虚拟地址空间的范围为0~4G。操作系统将这4G分为二部分,将最高的1G字节(虚拟地址范围为:0xC0000000-0xFFFFFFFF)供内核使用,称为内核空间。而将较低的3G字节供各个进程使用,称为用户空间。
    每个进程可以通过系统调用进入内核,因为内核是由所有的进程共享的。对于每一个具体的进程,它看到的都是4G大小的虚拟地址空间,即相当于每个进程都拥有一个4G大小的虚拟地址空间。

    三,IO操作

    一般IO缓冲区操作:

    1. 用户进程使用read()系统调用,要求其用户空间的缓冲区被填满。
    2. 内核向磁盘控制器硬件发命令,要求从磁盘读入数据。
    3. 磁盘控制器以DMA方式(数据不经过CPU)把数据复制到内核缓冲区。
    4. 内核将数据从内核缓冲区复制到用户进程发起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的实质,本篇到这里就结束了,最后感谢观看!

    展开全文
  • Linux下的文件读写

    千次阅读 2019-04-01 10:07:40
    应用程序(打开文件)-》各种库(标准库fopen)-》系统调用(open)-》内核(驱动)-》硬件(磁盘)。 系统调用:内核提供给外界访问的接口函数,调用这些函数将使进程进入内核态。 1、UNIX、Linux大部的系统...

    一、系统调用
    应用程序(打开文件)-》各种库(标准库fopen)-》系统调用(open)-》内核(驱动)-》硬件(磁盘)。
    系统调用:内核提供给外界访问的接口函数,调用这些函数将使进程进入内核态。
    1、UNIX、Linux大部的系统功能都是功能是通过系统调用的方式提供的。
    2、这些系统调用被封装成了C函数的形式,但它们并不是C语言的一部分,也不是函数(它是通过向内核发"信号"的方式告诉内核,我要进行系统调用,然后内核执行相应的功能,然后再把执行后的结果告诉进程)。

    time cmd 测试程序的运算时间
    size cmd 测试程序的代码段、全局段、静态数据库的大小。
    

    二、一切皆文件
    1、UNIX、Linux环境中,文件操作具有特殊意义,因为操作系统把它的服务和设备,统一封装成了一种简单的接口(文件读写),在UNIX、Linux系统中一切皆是文件。
    2、这样的好处就是程序可以像操作文件一样来操作磁盘、打印机、网络等设备。
    3、大多数情况下只要使用(open/close/read/write/ioctl),就可以实现对设备的输入、输出、设置等操作。
    4、UNIX、Linux中常见文件类型:
    -普通文件
    d目录文件
    c字符设备文件
    b块设备文件
    l链接文件

    三、文件操作相关的系统调用
    open 打开/创建文件
    close 关闭文件
    read 读文件
    write 写文件
    lseek 设置读写位置
    fcntl 修改文件属性
    unlink 删除硬链接
    creat 创建文件
    rmdir 删除空目录
    remove 删除硬链接/空目录

    四、文件描述符
    1、是一个非负整数,表示一个打开的文件。
    2、由open函数返回,被内核空间引用(只能传递系统调用才有用)。
    3、内核默认打开了三个文件
    0 STDIN_FILENO stdin 标准输入
    1 STDOUT_FILENO stdout 标准输出
    2 STDERR_FILENO stderr 标准错误
    4、文件描述符介于0~OPEN_MAX之间,超出这个范围就表示出错了。

    五、open/creat/close
    int open(const char *pathname, int flags);
    功能:打开文件
    pathname:文件的路径
    flags:打开的方式
    O_RDONLY 只读
    O_WRONLY 只写
    O_RDWR 读写
    O_CREAT 当文件不存在时创建
    O_EXCL 当文件存在时则创建失败
    O_TRUNC 当文件存在时清空
    O_APPEND 打开文件时文件位置指针设置到末尾
    返回值:文件描述符

    int open(const char *pathname, int flags, mode_t mode);
    功能:打开或创建文件
    pathname:文件的路径
    flags:文件打开的方式
    mode:创建文件时的权限
    	S_IRWXU  00700  user (file owner) has read,
                       write and execute permission
        S_IRUSR  00400 user has read permission
        S_IWUSR  00200 user has write permission
        S_IXUSR  00100 user has execute permission
    
        S_IRWXG  00070 group has  read,  write  and
                     execute permission        
        S_IRGRP  00040 group has read permission
        S_IWGRP  00020 group has write permission
        S_IXGRP  00010 group has execute permission
    
        S_IRWXO  00007  others have read, write and
                       execute permission
        S_IROTH  00004 others have read permission
    	S_IWOTH  00002 others have write permission
        S_IXOTH  00001 others have execute  permis‐sion
        注意:只有第一次文件创建时权限设置才有效。
    返回值:文件描述符 
    
    int creat(const char *pathname, mode_t mode);
    功能:创建文件
    pathname:文件的路径
    mode:文件的权限
    返回值:文件描述符
    
    int close(int fd);
    功能:关闭文件
    fd:要关闭的文件描述符
    返回值:成功返回0,失败返回-1	
    

    六、write/read
    ssize_t write(int fd, const void *buf, size_t count);
    功能:写入数据
    fd:文件描述符
    buf:要写入的数据
    count:写入的字节数
    返回值:成功写入的字节数

    ssize_t read(int fd, void *buf, size_t count);
    功能:读取数据
    fd:文件描述符
    buf:数据存储位置
    count:要读取的字节数
    返回值:成功读取到的字节数
    

    七、标准I/O与系统I/O
    使用标准I/O(fopen/fwrite/fclose)和系统I/O(open/write/close)分别向文件中写10万个整数,使用time命令检查它们的运算时间,比较一下哪个整数快,思考为什么?
    结论:标准I/O会比系统I/O读写速度更快。
    原因:标准I/O使用的缓冲机制,并不会立即把数据交给系统I/O然后写入文件中,而暂时存在在缓冲区中,当缓冲区满时,再把数据通过系统I/O一次性写入到文件中。
    当进行系统调用时,需要从用户态切换到内核态,频繁的切换会浪费大量的时间。

    展开全文
  • VBA 读写文本文件

    万次阅读 2019-05-11 16:34:13
    直接采用Open函数+Line input命令 Private Sub txt_read() Dim txt As String Open "D:\dzh.txt" For ... '对文件做任何 I/O 操作之前都必须先打开文件。Open 语句分配一个缓冲区供文件进行 I/O 之用, ...

    直接采用Open函数+Line input命令

      Private Sub txt_read()
               Dim txt As String
                Open "D:\dzh.txt" For Input As #1 '
                '对文件做任何 I/O 操作之前都必须先打开文件。Open 语句分配一个缓冲区供文件进行 I/O 之用,
                '并决定缓冲区所使用的访问方式。
                '打开文件作为数据输入用,文件号为#1
                Do While Not EOF(1)
                    Line Input #1, txt  '从已打开的顺序文件中读出一行并将它分配给 String 变量
                    'Line Input # 语句一次只从文件中读出一个字符,直到遇到回车符 (Chr(13))
                    '或回车–换行符 (Chr(13) + Chr(10)) 为止。回车–换行符将被跳过,而不会被附加到字符串上
                    MsgBox txt
                Loop
                Close #1
        End Sub
        -----------------------------------------------------------------------------------------------
    1、Open 语句 
    打开方式有 
    Input:以读取方式打开。
    Output:以写入方式打开。
    Append:以追加方式,即添加内容到文件末尾打开。
    Binary:以二进制方式打开。
    Random:以随机方式打开,如果未指定方式,则以 Random 方式打开文件。
     Open pathname For mode As [#]filenumber
     Open "c:\a.txt" For Output As #1
    filenumber  是一个有效的文件号,范围在 1 到 511 之间。
    如果 pathname 指定的文件不存在,那么,在用 Append、Binary、Output、或 Random 方式打开文件时,可以建立这一文件。 
    2、Close 语句 
    语法:Close [filenumberlist]
         filenumberlist 参数为一个或多个文件号,若省略 filenumberlist,则将关闭 Open 语句打开的所有活动文件。 
    说明:打开文件后,必须在使用完后关闭文件。
     
    3、EOF 函数 
    语法:EOF(filenumber) 
    功能:返回一个 Integer,它包含 Boolean 值 True,表明已经到达为 Random 或顺序 Input 打开的文件的结尾。
    Open "c:\a.txt"  For Input As #1 ‘以读入方式打开c:\a.txt
    Do While Not EOF(1)  '未到达结尾
              Line Input #1, s1     '读入一行,放入s1变量中
            Loop
            Close #1 
    
    展开全文
  • C++ mmap 多进程文件读写

    千次阅读 2020-05-04 21:13:02
    mmap 采用内存映射的方式,直接将磁盘上的文件映射到内存(准确的说是虚拟内存)中,不需要其他额外空间,对内存映射区的修改可以与磁盘文件保持同步,故 mmap 的读写速度非常快 使用 mmap 需注意以下两点:仅支持 ...
  • java 多个线程同时同一个文件

    千次阅读 2019-10-11 17:00:17
    } } //随机写文件的时候从哪个位置开始写 raFile.seek(startIndex); int len = 0; byte[] arr = new byte[1024]; //获取文件片段长度 int segLength = endIndex - startIndex + 1; while ((len = in.read(arr)) != ...
  • 安卓中文件读写-流操作

    千次阅读 2019-06-27 16:12:35
    字节流在操作文件时,即使不关闭资源(close方法),文件也能输出,但是如果字符流不使用close方法的话,则不会输出任何内容,说明字符流用的是缓冲区,并且可以使用flush方法强制进行刷新缓冲区,这时才能在不...
  • 问题: 在用VS2017头文件时,出现的这个错误 解决:
  • matlab对文件的读写

    万次阅读 2019-05-23 18:37:10
    matlab读取文件函数总结 1. load读取方式 a.基本说明: 只能读取数值数据,不能读取含文本的数据;日期按数值读取。 b.调用方式: a=load(filename); c. 有无分隔符限制: 无需输入分隔符,可...
  • Qt5--文件操作(2)读写二进制文件

    万次阅读 2019-02-17 11:17:32
    如果在支持的版本范围内(100 ),则当是小于等于 110 的时候,按照Qt_4_0的格式读取,否则按照Qt_5_9的格式读取。当设置完这些参数之后,开始读取数据。  至此,我们介绍了有关QDataStream的相关内容。那么,...
  • ModBus用户自定义文件读写功能

    千次阅读 2018-06-24 18:30:04
    ModBus用户自定义文件读写功能 功能分类 公共功能码 是较好地被定义的功能码, 保证是唯一的, MODBUS 组织可改变的, 公开证明的, 具有可用的一致性测试, MB IETF RFC 中证明的, 包含已被定义的公共指配...
  • 获取shp文件四至范围的方法总结

    千次阅读 2020-08-06 18:44:43
    本文为获取shp矢量文件的四至范围列出两种不同的方法,有更好的方法请交流学习。 一、使用QGIS 1、 新建字段,不再赘述。 2、 表达式。 如下图为计算y_min的表达式。这些自带函数均在geometry里。y_max,x_min,x_...
  • 接上篇博客,下面来说第一个问题,VFS是如果打开和读写文件的。 用户读写文件的流程 file->dentry->inode->iops->address_space->disk 的流程: 通过struct找到磁盘inode...
  • GRD格式的DEM有很多种,文本格式的与Matlab自带的不兼容,本程序适用的文件头结构为:DSAA,行,列,经,纬度范围,高程范围
  • 使用C++文件流库fstream,以字符串形式读取十六进制文本文件的内容,将这些十六进制数据转换为int型数据,并分类存储
  • C++ 移动和获取文件读写指针

    千次阅读 多人点赞 2020-03-18 08:54:17
    在读写文件时,有时希望直接跳到文件中... ofstream 类和 fstream 类有 seekp 成员函数,可以设置文件写指针的位置。 所谓“位置”,就是指距离文件开头有多少个字节。文件开头的位置是 0。 这两个函数的原型如下:...
  • 『GDAL』读写TIFF文件

    千次阅读 2020-08-18 09:47:35
    读写TIFF文件的一种方法
  • 如何一个仿真文件——testbench

    千次阅读 多人点赞 2020-04-29 17:25:08
    testbench就是对的FPGA文件进行测试的文件。任何设计都是有输入输出的,testbench的作用就是给这个设计输入,然后观察输出是否符合我们的预期,这就是testbench的功能。运行环境一般是ise或者vivado自带的仿真工具...
  • LocalDateTime时间范围xml中判断方式: 1、 AND t1.last_modified_date >=#{p.lastModifiedDateStart} AND t1.last_modified_date <=#{p.lastModifiedDateEnd} 2、 AND t1.last_modified_date <![CDATA[>...
  • 例如查找`2013-08-08`到`2013-09-01`号之间的文件,使用如下命令即可: find /log/ -name 'production.log-2013*' -newermt '2013-08-08' ! -newermt '2013-09-0 2011/09/08 12:00 时间开始找一天內的,会列出 ...
  • 我们在使用git的时候,如果需要忽略某个文件夹,可以在仓库根目录下创建一个.gitignore文件,在.gitignore添加需要忽略的文件和文件夹,那么git就会忽略相应的文件和文件夹,就不会提交和上传这些文件 语法 ....
  • C++中头文件(.h)和源文件(.cpp)都应该些什么

    千次阅读 多人点赞 2019-02-18 17:45:56
     类的声明(包括类里面的成员和方法的声明)、函数原型、#define常数等,但一般来说不出具体的实现。  在头文件时需要注意,在开头和结尾处必须按照如下样式加上预编译语句(如下):   #ifndef CIRCLE...
  • 请领导批复文件怎么

    千次阅读 2020-12-31 03:42:57
    展开全部要领导顺利批文有二种说法:1、如这62616964757a686964616fe78988e69...2、是你岗位工作范围文件审批又不的,这是你上一级领导的文件审批,XX领导您好:我XX时间按排的XX文件已经完成,请领导查批,并且...
  • C++读取txt文件并统计数字范围个数

    千次阅读 2018-07-13 10:53:47
    txt文件内容:有一万多个整型数字,每个字一行,如图代码如下:// temp_project.cpp: 定义控制台应用程序的入口点。 // /* #include "stdafx.h" int main() { printf("------------------"); ...
  • 第9.2节 Python的文件打开函数open详解

    千次阅读 2021-02-03 14:57:05
    一、引言在操作一个文件前,大部分情况需要先打开文件,才能进行,在Python中使用内置函数open来打开一个文件。open函数是Python的一个内置函数,io模块 定义的函数open是该内置函数的同义词(这是Python官网中关于io...
  • 我们下载的是印度区域的shapefile,截取数据并绘图后,如下所示: shapefile写入 与读入shp相比,输出shp文件相比麻烦一些,需要自己建立一个struct,然后利用shapewrite函数将struct写入shp文件中。 india = ...
  • Linux 文件内容大小转换

    千次阅读 2021-07-17 11:28:47
    一、文件 ... vim中大小转化的命令是:gu或者gU,形象一点的解释就是小u意味着转为小写,大U意味着转为大写。接下来说明对这两个命令的限定(限定操作的行,字母,单词)等等。 1.整篇文章大写转化为小
  • 具体来说,我们将以分析历史股价为例,介绍怎样文件中载入数据,以及怎样使用NumPy的基本数学和统计分析函数。这里还将学习读写文件的方法,并尝试函数式编程和NumPy线性代数运算。 第三章 常用函数 3.1 文件读写 ...
  • python实现简单的声音文件读写

    千次阅读 2019-07-17 15:23:35
    一、 声音的读与 以下将用到python自带的wave模块进行操作。 声音文件的读取 以下以wav文件为例。 使用wave模块进行声音的读取操作是:wave.open(r"wav文件路径",“rb") ‘rb‘表示命令为只读模式。 wav.open命令...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 889,478
精华内容 355,791
关键字:

怎样写文件范围