精华内容
下载资源
问答
  • 文件类和文件对象输入输出是以系统指定的标准设备(输入设备为键盘,输出设备为显示器)为对象的。在实际应用中,常以磁盘文件作为对象。即从磁盘文件读取数据,将数据输出到磁盘文件。和文件有关系的输入输出类...

    文件流类和文件流对象

    输入输出是以系统指定的标准设备(输入设备为键盘,输出设备为显示器)为对象的。在实际应用中,常以磁盘文件作为对象。即从磁盘文件读取数据,将数据输出到磁盘文件。

    和文件有关系的输入输出类主要在fstream.h这个头文件中被定义,在这个头文件中主要被定义了三个类,由这三个类控制对文件的各种输入输出操 作,他们分别是ifstream、ofstream、fstream,其中fstream类是由iostream类派生而来,他们之间的继承关系见下图所示。

    8b020c2fecc0330fe61610c3005f934e.png

    由于文件设备并不像显示器屏幕与键盘那样是标准默认设备,所以它在fstream.h头文件中是没有像cout那样预先定义的全局对象,所以我们必须自己定义一个该类的对象。

    ifstream类,它是从istream类派生的,用来支持从磁盘文件的输入。

    ofstream类,它是从ostream类派生的,用来支持向磁盘文件的输出。

    fstream类,它是从iostream类派生的,用来支持对磁盘文件的输入输出。

    打开文件

    所谓打开(open)文件是一种形象的说法,如同打开房门就可以进入房间活动一样。 打开文件是指在文件读写之前做必要的准备工作,包括:

    1)为文件流对象和指定的磁盘文件建立关联,以便使文件流流向指定的磁盘文件。

    2)指定文件的工作方式,如,该文件是作为输入文件还是输出文件,是ASCII文件还是二进制文件等。

    以上工作可以通过两种不同的方法实现。

    1) 调用文件流的成员函数open。如

    ofstream outfile; //定义ofstream类(输出文件流类)对象outfile

    outfile.open("f1.dat",ios::out); //使文件流与f1.dat文件建立关联

    第2行是调用输出文件流的成员函数open打开磁盘文件f1.dat,并指定它为输出文件, 文件流对象outfile将向磁盘文件f1.dat输出数据。ios::out是I/O模式的一种,表示以输出方式打开一个文件。或者简单地说,此时f1.dat是一个输出文件,接收从内存输出的数据。

    调用成员函数open的一般形式为:

    文件流对象.open(磁盘文件名, 输入输出方式);

    磁盘文件名可以包括路径,如"c:newf1.dat",如缺省路径,则默认为当前目录下的文件。

    2) 在定义文件流对象时指定参数

    在声明文件流类时定义了带参数的构造函数,其中包含了打开磁盘文件的功能。因此,可以在定义文件流对象时指定参数,调用文件流类的构造函数来实现打开文件的功能。如

    ostream outfile("f1.dat",ios::out); 一般多用此形式,比较方便。作用与open函数相同。

    输入输出方式是在ios类中定义的,它们是枚举常量,有多种选择,见表13.6。

    18c2f630b8f194b34d64429d409433d3.png

    几点说明:

    1) 新版本的I/O类库中不提供ios::nocreate和ios::noreplace。

    2) 每一个打开的文件都有一个文件指针,该指针的初始位置由I/O方式指定,每次读写都从文件指针的当前位置开始。每读入一个字节,指针就后移一个字节。当文 件指针移到最后,就会遇到文件结束EOF(文件结束符也占一个字节,其值为-1),此时流对象的成员函数eof的值为非0值(一般设为1),表示文件结束 了。

    3) 可以用“位或”运算符“|”对输入输出方式进行组合,如表13.6中最后3行所示那样。还可以举出下面一些例子:

    ios::in | ios:: noreplace //打开一个输入文件,若文件不存在则返回打开失败的信息

    ios::app | ios::nocreate //打开一个输出文件,在文件尾接着写数据,若文件不存在,则返回打开失败的信息

    ios::out l ios::noreplace //打开一个新文件作为输出文件,如果文件已存在则返回打开失败的信息

    ios::in l ios::out I ios::binary //打开一个二进制文件,可读可写

    但不能组合互相排斥的方式,如 ios::nocreate l ios::noreplace。

    4) 如果打开操作失败,open函数的返回值为0(假),如果是用调用构造函数的方式打开文件的,则流对象的值为0。可以据此测试打开是否成功。

    如 if(outfile.open("f1.bat", ios::app) ==0)

    cout <<"open error";

    或 if( !outfile.open("f1.bat", ios::app) )

    cout <<"open error";

    关闭文件

    在对已打开的磁盘文件的读写操作完成后,应关闭该文件。关闭文件用成员函数close。

    如 outfile.close( ); //将输出文件流所关联的磁盘文件关闭

    所谓关闭,实际上是解除该磁盘文件与文件流的关联,原来设置的工作方式也失效,这样就不能再通过文件流对该文件进行输入或输出。此时可以将文件流与其他磁盘文件建立关联,通过文件流对新的文件进行输入或输出。如

    outfile.open("f2.dat",ios::app|ios::nocreate);

    此时文件流outfile与f2.dat建立关联,并指定了f2.dat的工作方式。

     #include<fstream>  //文件读写
                     //文本文件读写(即ascII文件)
     void test01() {
     
         const char* fileName = "D:桌面source.txt";
         const char* TagetName = "D:桌面target.txt";
         ifstream ism(fileName, ios::in); //只读方式打开文件
         ofstream osm(TagetName, ios::out | ios::app);
         //ifstream ism;
         //ism.open(fileName,ios::in);
     
         if (!ism) {
             cout << "打开文件失败!" << endl;
             return;
         }
     
         //读文件
         char ch;
         while (ism.get(ch)) {
             cout << ch;
             osm.put(ch);
         }
     
         //关闭文件
         ism.close();
         osm.close();
     }
    

    C++对二进制文件的读写操作

    二进制文件不是以ASCII代码存放数据的,它将内存中数据存储形式不加转换地传送到磁盘文件,因此它又称为内存数据的映像文件。因为文件中的信息不是字符数据,而是字节中的二进制形式的信息,因此它又称为字节文件。

    对二进制文件的操作也需要先打开文件,用完后要关闭文件。在打开时要用ios::binary指定为以二进制形式传送和存储。二进制文件除了可以作为输入文件或输出文件外,还可以是既能输入又能输出的文件。这是和ASCII文件不同的地方。

    用成员函数read和write读写二进制文件

    对二进制文件的读写主要用istream类的成员函数read和write来实现。这两个成员函数的原型为

        istream& read(char *buffer,int len);
        ostream& write(const char * buffer,int len);

    字符指针buffer指向内存中一段存储空间。len是读写的字节数。调用的方式为:

     a.write(p1,50);
     b.read(p2,30);

    上面第一行中的a是输出文件流对象,write函数将字符指针p1所给出的地址开始的50个字节的内容不加转换地写到磁盘文件中。在第二行中,b是输入文件流对象,read 函数从b所关联的磁盘文件中,读入30个字节(或遇EOF结束),存放在字符指针p2所指的一段空间内。

     //二进制文件操作  对象序列化
     class Person{
     public:
         Person(){}
         Person(int age,int id):age(age),id(id){}
         void Show(){
             cout << "Age:" << age << " Id:" << id << endl;
         }
     public:
         int age;
         int id;
     };
     
     void test02(){
         Person p1(10, 20), p2(30, 40); //二进制
         const char* TagetName = "D:桌面target.txt";
         //把p1 p2写进文件里   
         ofstream osm(TagetName, ios::out | ios::binary);
         osm.write((char*)&p1, sizeof(Person)); //二进制方式写文件
         osm.write((char*)&p2, sizeof(Person));
         osm.close();
     
         ifstream ism(TagetName,ios::in | ios::binary);
         ism.read((char*)&p1, sizeof(Person)); //从文件读取数据
         ism.read((char*)&p2, sizeof(Person)); //从文件读取数据
     
         p1.Show();
         p2.Show();
     }
    
    展开全文
  • 字节输入流:InputStream,字节输出流:OutputStream 字符输入流:Reader,字符输出流:Writer 关闭流顺序原则: 一般情况下:先打开的后关闭,后打开的先关闭 另一种情况:看依赖关系,如果流a依赖流b,应该先...

    JDK为每种类型的流提供了一些抽象类以供继承,分别是哪些类
    字节输入流:InputStream,字节输出流:OutputStream

    字符输入流:Reader,字符输出流:Writer

    关闭流顺序原则:

    一般情况下是:先打开的后关闭,后打开的先关闭

    另一种情况:看依赖关系,如果流a依赖流b,应该先关闭流a,再关闭流b

    例如处理流a依赖节点流b,应该先关闭处理流a,再关闭节点流b

    当然完全可以只关闭处理流,不用关闭节点流。处理流关闭的时候,会调用其处理的节点流的关闭方法

    如果将节点流关闭以后再关闭处理流,会抛出IO异常

    对于 IO 流涉及的装饰者设计模式例子如下:

    //把InputStreamReader装饰成BufferedReader来成为具备缓冲能力的Reader。BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

    对于 IO 流涉及的适配器设计模式例子如下:

    //把FileInputStream文件字节流适配成InputStreamReader字符流来操作文件字符串。

    FileInputStream fileInput = new FileInputStream(file);

    InputStreamReader inputStreamReader = new InputStreamReader(fileInput);

    而对于上面涉及的两种设计模式通俗总结如下。装饰者模式就是给一个对象增加一些新的功能,而且是动态的,要求装饰对象和被装饰对象实现同一个接口,装饰对象持有被装饰对象的实例(各种字符流间装饰,各种字节流间装饰)。适配器模式就是将某个类的接口转换成我们期望的另一个接口表示,目的是消除由于接口不匹配所造成的类的兼容性问题(字符流与字节流间互相适配)。

    IO与NIO(New IO)的区别

    1、面向流与面向缓冲

    2、阻塞与非阻塞IO

    3、选择器(Selectors)。NIO: 单线程管理多个连接,IO: 一个连接通过一个线程处理. 

    展开全文
  • 补充题: 1.Java中流的分类有哪些? 流动方向:分为输入流和输出流 输入流:如System.in一个InputStream类型输入流 输出流:如System.out 一个...节点流:直接操作目标设备对应的流 如文件流,标准输入输出流

    补充题:

    1.Java中流的分类有哪些?

    流动方向:分为输入流和输出流

    • 输入流:如System.in是一个InputStream类型输入流
    • 输出流:如System.out 是一个PrintStream类型输出流

    读取类型:分为字节流和字符流

    • 字节流:如System.in是一个InputStream类型字节流
    • 字符流:如new InputStreamReader(System.in)是一个字符流对象

    发生的源头:分为节点流和过滤流类

    • 节点流:直接操作目标设备对应的流 如文件流,标准输入输出流
    • 过滤流:继承带有关键字Filter的流 用于包装操作节点流,方便读写各种类型的数据

    2.字节流InputStream和OutputStream的子类分别有哪些?请举例说明其使用场景。与其对应的字符流分别有哪些?

    FileInputStream和FileOutputStream在文件和流之间搭建桥梁。

    FileInputStream构造方法:
    FileInputStream(String name) :以文件路径名字构造一个文件输入流,打开一个与实际文件的连接,用于从该流中读取文件字节流

    FileOutputStream构造方法:
    FileOutputStream(String name) :以文件路径名字构造一个文件输出流,打开一个与实际文件的连接,用于文件的写字节流操作

    例:OutputStream中的write(byte b[], int off, int len)方法:将数组b中从off指定的位置开始,长度为len的数据输出到流中。

    在这里插入图片描述

    3.字节流与字符流的转化是怎样的?Java对此提供了哪些支持?

    • 输入字节流转为字符流需要用到inputstreamReader的构造方法:
      InputStreamReader(InputStream in)
      例如:
    InputStreamReader ins = new InputStreamReader(System.in);
    InputStreamReader ins = new InputStreamReader(new FileInputStream(“test.txt”));
    
    • 输出字符流转为字节流用到OutputStreamWriter或PrintWriter的构造方法:

    OutputStreamWriter(OutputStream out)

    PrintWriter(OutputStream out)
    例如:

    OutputStreamWriter outs = new OutputStreamWriter(new    
                                 FileOutputStream(“test.txt”));
    

    4.Java中的过滤流(流的装配)有什么作用?请举例说明常用的过滤流。

    过滤流: BufferedInputStream和BufferedOutputStream, 缓存作用,用于装配文件磁盘、网络设备、终端等读写开销大的节点流,提高读写性能

    过滤流BufferedReader的使用:用于缓存字符流,可以一行一行的读

    import java.io.*;
    public class inDataSortMaxMinIn { 
        public static void main(String args[]) {
         try{
            BufferedReader keyin = new BufferedReader(new 
                                         InputStreamReader(System.in)); 
            String c1;
            int i=0;
            int[] e = new int[10];   
            while(i<10){
               try{
                   c1 = keyin.readLine();
                   e[i] = Integer.parseInt(c1);
                   i++;
                }  
                catch(NumberFormatException ee){
                       System.out.println("请输入正确的数字!");
                }
           }
        }
        catch(Exception e){
            System.out.println("系统有错误");
     }}}
    

    PrintWriter的使用:可以向该字符流中写入Java基本数据类型,用于包装输出字符流类对象

    import java.io.*;
    public class PrintWrit {
      public static void main(String[] args)throws Exception{
        PrintWriter out = new PrintWriter(new BufferedWriter(new 
                                        FileWriter("foo.txt")));
        out.println(“hello”); //写入字符串
        out.println(3); //写入整型
        out.close(); //关闭流,系统自动将缓冲区内容flush
      }  
    }
    

    5.什么是对象的序列化和反序列化?Java对此提供了哪些支持?

    串行化(Serialization):又称序列化,将实现了Seriallizable接口的对象转换成一个字节序列,并能够在以后将这个字节序列完全恢复为原来的对象,后者又称反序列化

    串行化的目的:便于介质存储和网络传输

    使用ObjectInputStream类和ObjectOutputStream类

    import java.io.*;
     public class Student implements Serializable { //序列化
        int number=1;
        String name;
        Student(int number,String n1) {
            this.number = number;
            this.name = n1;
        }
     public static void main(String arg[]) {
            String fname = "Student.obj"; //文件名
            Student s1 = new Student(1,"Wang");
            s1.save(fname);
            s1.display(fname);
    }
    void save(String fname) {
        try{
                FileOutputStream fout = new FileOutputStream(fname);
                ObjectOutputStream out = new ObjectOutputStream(fout);
                out.writeObject(this);               //对象序列化
                out.close();
        }
        catch (FileNotFoundException fe){}
        catch (IOException ioe){}
    }
    
    void display(String fname) {
         try{
                FileInputStream fin = new FileInputStream(fname);
                ObjectInputStream in = new ObjectInputStream(fin);
                Student u1 = (Student)in.readObject();  //对象反序列化
                System.out.println(u1.getClass().getName()+"  "+
                                     u1.getClass().getInterfaces()[0]);
                System.out.println("  "+u1.number+"  "+u1.name);
                in.close();
         }
         catch (FileNotFoundException fe){}
         catch (IOException ioe){}
         catch (ClassNotFoundException ioe) {}
    }
    

    6.Java的File类表示什么?有什么作用?

    在这里插入图片描述
    在这里插入图片描述

    7.Java对文件的读写分别提供了哪些支持?

    package chap14_2;
    import java.io.*;
    public class OpenFile {
        public static void main(String args[]) throws IOException{
            try{                                        //创建文件输入流对象
                FileInputStream  rf = new FileInputStream("OpenFile.java");
                int n=512,c=0;
                byte buffer[] = new byte[n];
                while ((c=rf.read(buffer,0,n))!=-1 ){   //读取输入流
                    System.out.print(new String(buffer,0,c));
                }            
                rf.close();                            //关闭输入流
            }
            catch (FileNotFoundException ffe){
                System.out.println(ffe);}
            catch (IOException ioe){
                System.out.println(ioe);
            }
       
    }
    
    
    import java.io.*;
    public class Write1 {
        public static void main(String args[]){
            try{
                System.out.print("Input: ");
                int count,n=512;
                byte buffer[] = new byte[n];
                count = System.in.read(buffer);        //读取标准输入流
                FileOutputStream  wf = new FileOutputStream("Write1.txt");
                                                       //创建文件输出流对象
                wf.write(buffer,0,count);              //写入输出流
                wf.close();                            //关闭输出流
                System.out.println("Save to Write1.txt!");
            }
            catch (FileNotFoundException ffe){
                System.out.println(ffe);}
            catch (IOException ioe){
                System.out.println(ioe);} }
    }
    
    
    展开全文
  • java I/O输入输出 作业

    2020-12-11 10:26:38
    节点流:直接操作目标设备对应的流,如文件流,标准输入输出流。 过滤流:继承带有关键字Filter的流,用于包装操作节点流,方便读写各种类型的数据。 2、字节流InputStream和OutputStream的子类分别有哪些?请举例...

    1、Java中流的分类有哪些?

    1. 从流动方向上看:一般分为输入流和输出流
    2. 从读取类型上分:一般分为字节流和字符流
    3. 从发生的源头:分为节点流和过滤流类
    • 节点流:直接操作目标设备对应的流,如文件流,标准输入输出流。
    • 过滤流:继承带有关键字Filter的流,用于包装操作节点流,方便读写各种类型的数据。

    在这里插入图片描述

    2、字节流InputStream和OutputStream的子类分别有哪些?请举例说明其使用场景。与其对应的字符流分别有哪些?

    字节流
    InputStream和OutputStream是两个抽象类,代表输入和输出,其子类包括:

    • 文件流FileinputStreamFileOutputStream,作用在于作通过指定文件路径构造一个文件流,从而可以使用流的方式对文件进行读写的操作。

    • 字节数组流 ByteArrayInputStreamByteArrayOutputStream,起到在字节数组和流之间搭建桥梁的作用。

    • 管道流PipedInputStreamPipedOutputStream,通常用于将一个程序的输出连接到另一个程序的输入。输出流作为管道的发送端,输入流作为管道的接收端。使用前需要调用connect方法将输出流和输入流连接起来。

    • 对象流ObjectOutputStreamObjectInputStream,起到对象序列化和反序列化的作用,可以输入或输出对象。

    • 过滤流FilterInputStreamFilterOutputStream,是两个抽象类,对连接到的其他输人/输出节点流进行特殊处理。

    在这里插入图片描述

    字符流
    Reader和Writer是两个抽象类,代表输入和输出,其子类包括:

    • 文件流FileReaderFileWriter
    • 字符数组流 CharArrayReaderCharArrayWriter
    • 管道流PipedReaderPipedWriter
    • 过滤流FilterReaderFilterWriter
    • PrintWriter
    • 字节流与字符流的转化InputStreamReaderOutputStreamWriter
      在这里插入图片描述

    3、字节流与字符流的转化是怎样的?Java对此提供了哪些支持?

    输入字节流转为字符流需要用到inputstreamReader的构造方法

    InputStreamReader ins = new InputStreamReader(System.in);
    

    输出字符流转为字节流用到OutputStreamWriter或PrintWriter的构造方法

    PrintWriter os=new PrintWriter(socket.getOutputStream());
    OutputStreamWriter outs = new OutputStreamWriter(new FileOutputStream(“test.txt”));
    

    4、Java中的过滤流(流的装配)有什么作用?请举例说明常用的过滤流。

    过滤流:继承带有关键字Filter的流,用于包装操作节点流,方便读写各种类型的数据
    在这里插入图片描述

    FileInputStream inputStream = new FileInputStream( "f1.txt" );
    BufferedInputStream bufferedInputStream = new BufferedInputStream( inputStream );
    FileOutputStream outputStream = new FileOutputStream( "f2.txt" ) ;
    BufferedOutputStream bufferedOutputStream = new BufferedOutputStream( outputStream ) ;
    byte[] b=new byte[1024]; //代表一次最多读取1KB的内容
    int length = 0 ; //代表实际读取的字节数
    while( (length = bufferedInputStream.read( b ) )!= -1 ){
    	//length 代表实际读取的字节数
    	bufferedOutputStream.write(b, 0, length );}
    //缓冲区的内容写入到文件
    bufferedOutputStream.flush();
    
    DataInputStream di = new DataInputStream(new BufferedInputStream(new FileInputStream(f))) 
    System.out.println(di.readInt()); //读取整型,输出3
    System.out.println(di.readDouble()); //读取浮点型,输出3.14
    System.out.println(di.readUTF()); //读取字符串,输出hello
    
    DataOutputStream do = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(f))) 
    do.writeInt(3);//写入整型
    do.writeDouble(3.14);//写入浮点型
    do.writeUTF(“hello”);//写入字符串
    do.close();
    
    PrintStream out = new PrintStream("other.txt");
    // 将字符串“hello PrintStream”+回车符,写入到输出流中
    out.println("hello PrintStream");
    // 将0x41写入到输出流中,也就是写入字符'A'
    out.write(0x41);
    out.append('B');
    

    5、什么是对象的序列化和反序列化?Java对此提供了哪些支持?

    串行化(Serialization):又称序列化,将实现了Seriallizable接口的对象转换成一个字节序列,并能够在以后将这个字节序列完全恢复为原来的对象,后者又称反序列化.。
    串行化的目的:便于介质存储和网络传输

    Java提供了ObjectInputStream类和ObjectOutputStream

    out.writeObject(this);//对象序列化
    in.readObject();//对象反序列化
    

    6、Java的File类表示什么?有什么作用?

    File类提供了文件(或目录)路径名字的抽象表示,该类主要用于文件和目录的创建、文件的查找和文件的删除等。

    构造方法

    File(File parent, String child);//通过给定的父抽象路径名和子路径名字符串创建一个新的File实例
    File(String pathname) //通过将给定路径名字符串转换成抽象路径名来创建一个新 File 实例
    File(String parent, String child) //根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
    

    常用方法
    public String getName()
    返回由此抽象路径名表示的文件或目录的名称。

    public String getPath()
    将此抽象路径名转换为一个路径名字符串。

    public boolean exists()
    测试此抽象路径名表示的文件或目录是否存在。

    public boolean isDirectory()
    测试此抽象路径名表示的文件是否是一个目录。

    public boolean delete()
    删除此抽象路径名表示的文件或目录。

    public String[] list()
    返回由此抽象路径名所表示的目录中的文件和目录的名称所组成字符串数组。

    public String[] list(FilenameFilter filter)
    返回由包含在目录中的文件和目录的名称所组成的字符串数组,这一目录是通过满足指定过滤器的抽象路径名来表示的。

    public boolean mkdir()
    创建此抽象路径名指定的目录。

    7、Java对文件的读写分别提供了哪些支持?

    读文件:FileInputStream / FileReader
    写文件:FileOutputStream / FileWriter / PrintStream / PrintWriter
    提供对文件的随机访问支持:RandomAccessFile,文件指针可以随意定位,可以向前访问

    展开全文
  • 1. Java中流的分类有哪些? 流从流动方向上看:一般分为输入流和输出流 输入流:如System.in一个InputStream类型输入流 输出流:如System.out 一个PrintStream类型输出流 ...如文件流,标准输入输出
  • Java中流的分类有哪些

    2020-12-14 20:03:14
    1.流从流动方向上看:一般分为输入流和输出流 输入流:如System.in一个InputStream类型输入流 输出流:如System.out 一个PrintStream类型输出流 ...如文件流,标准输入输出流 过滤流:继承带有关键
  • 14章

    2020-12-16 15:25:34
    1 Java中流的分类有哪些? 流从流动方向上看:一般分为输入流和输出流 输入流:如System.in一个InputStream类型输入流 输出流:如System.out 一个PrintStream类型输出流 ...如文件流,标准输入输出流
  • JAVA作业9

    2020-12-08 19:09:47
    1.Java中流的分类有哪些? 流动方向:分为输入流和输出流 输入流:如System.in一个InputStream类型输入流 ...节点流:直接操作目标设备对应的流 如文件流,标准输入输出流 过滤流:继承带有关键字Fi
  • Java作业10

    2020-12-06 00:53:39
    1.Java中的流的分类有哪些? 流动方向上:一般分为输入流和输出流。如System.in一个InputStream类型输入流;...节点流:直接操作目标设备对应的流,如文件流,标准输入输出流;过滤流:继承带有关键字Filter的流,用
  • 编写C语言step1:进入工作目录step2 :编译、执行3.MakeFile编写四、标准输入流、输出流及错误流标准输出流标准输入流标准错误流五、GDB工具六、总结 前言 C语言贝尔实验室在B语言的基础上开发出来的,C 语言之...
  • 就连竞选村长都以Word Final的标准进行的.这里的算法风气之浓厚,就连当地的动物们都受到了极大的影响.旺财村长--TCL(相当于世界冠军的水平)的爱犬,从小就受到村长一家的熏陶,当别的小动物都还在算A+B的的时候,...
  • 单靠查看输出的文本本身,我们没有办法区别哪些是正常的,哪些是错误的.不过可以通过文件描述符来解决这个问题. 文件描述符是与某个打开的文件或者数据相关联的整数.文件描述符0,1,2是系统预留的. 0-----stdin(标准...
  • ————————————————Linux文件压缩指令———————————————— 压缩指令也可以打包,但是先...-c:将压缩的数据输出到屏幕上(其实一个标准输入输出流)直接使用gzip filename 会将源文
  • 协议默认模式一个标准的 ARQ,需要通过配置打开各项加速开关: 工作模式: int ikcp_nodelay(ikcpcb *kcp, int nodelay, int interval, int resend, int nc) nodelay :是否启用 nodelay模式,0不启用;1启用。...
  • 本文介绍了运用readline逐行读取的两种实现,分享给大家,具体如下:什么ReadlineReadlineNode.js里实现标准输入输出的封装好的模块,通过这个模块我们可以以逐行的方式读取数据。使用require(“readline”)...
  • 通过我们已经学过的知识,你可以编写一个最简单的程序输出一个也许程序世界中最有名的词语: echo "Hello World!"; ?> First PHP page // Single line C++ style comment /* printing the message */ ...
  • Perl 语言入门 第六版

    2014-02-12 00:46:55
    读取标准输入 来自钻石操作符的输入 调用参数 输出到标准输出 JNprintf格式化输出 数组和printf 文件句柄 打开文件句柄 以二进制方式读写文件句柄 有问题的文件句柄 关闭文件句柄 用die处理致命错误 用...
  • CT6301/CT6302B三合一的移动电源IC,集成充电+升压+MCU管理.5V/1A输入5V/1A输出,采用涓预充+恒流恒压充电模式,带短路保护,过压,过保护,过温保护.可做边充边放,5段电量显示,LED手电,空载自动识别关机等功能特点....
  • 面试题69 什么是标准输入输出流 面试题70 如何重载输入输出 6.2 文件输入/输出 面试题71 如何读取一个文件 面试题72 文件输入输出有哪几种方式 6.3 异常与错误 面试题73 什么是异常 面试题74 如何抛出和捕捉异常 第...
  • 7.1 标准输入输出 7.2 格式输出—printf函数 7.3 变长变元表 7.4 格式输入—scanf函数 7.5 文件访问 7.6 错误处理—stderr和exit函数 7.7 行输入输出 7.8 其他函数 7.8.1 字符串处理函数 7.8.2 字符类测试...
  • 读者将要学习如何使用类方法来确定输入输出流的状态, 了解输入类型是否不匹配或是否检测到了文件尾。C++使用继承来派生用于管理文件输入和输出的类。 读者将学习如何打开文件,以进行输入和输出,如何在文件中...
  • 读者将要学习如何使用类方法来确定输入输出流的状态, 了解输入类型是否不匹配或是否检测到了文件尾。C++使用继承来派生用于管理文件输入和输出的类。 读者将学习如何打开文件,以进行输入和输出,如何在文件中...
  • 读者将要学习如何使用类方法来确定输入输出流的状态, 了解输入类型是否不匹配或是否检测到了文件尾。C++使用继承来派生用于管理文件输入和输出的类。 读者将学习如何打开文件,以进行输入和输出,如何在文件中...
  • 读者将要学习如何使用类方法来确定输入输出流的状态, 了解输入类型是否不匹配或是否检测到了文件尾。C++使用继承来派生用于管理文件输入和输出的类。 读者将学习如何打开文件,以进行输入和输出,如何在文件中...
  • JSP快速入门教程

    2013-08-22 20:32:26
     JSTL,标准标签库,用于输出和控制  EL,通常与JSTL一起使用,主要用于输出  Servlet,几乎所有介绍JSP的书和课程都包含Servlet,因为JSP实际上指的Java Web开发。用Servlet主要控制器。  JDBC,对数据库的...
  • 行 变换,【密钥】、它也是输入,但它独立前二者,【密文】、它是输出,【解密算法】,最后 一个可认为一种可逆运算。 11. 任意的整数a 能且仅能写成一种如下积的形式,那么数 9000 可唯一地分解为【23*32*53】 12...
  • C++程序员面试宝典

    热门讨论 2013-04-01 13:36:19
    面试题69 什么是标准输入输出流 73 面试题70 如何重载输入输出 74 6.2 文件输入/输出 75 面试题71 如何读取一个文件 75 面试题72 文件输入输出有哪几种方式 76 6.3 异常与错误 77 面试题73 什么是异常 77 面试题74 ...
  • 1.3.4 如果让你来设计一个支持数据库、NOSQL 和大数据之间数据实时流动的数据及处理的系统,你会考虑哪些问题?如何设计? 1.3.5 给定一个整数数组和一个整数,返回两个数组的索引,这两个索引指向的数字的加和...
  • 10.1 输入输出流 369 10.2 标准流 370 10.3 键盘输入 371 10.3.1 格式化键盘输入 371 10.3.2 输入格式控制字符串 372 10.3.3 输入格式字符串中的字符 377 10.3.4 输入浮点数的各种变化 378 10.3.5 读取...
  • 10.1 输入输出流 369 10.2 标准流 370 10.3 键盘输入 371 10.3.1 格式化键盘输入 371 10.3.2 输入格式控制字符串 372 10.3.3 输入格式字符串中的字符 377 10.3.4 输入浮点数的各种变化 378 10.3.5 读取...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 123
精华内容 49
关键字:

哪些是标准输入输出流