inux shell数据重定向(输入重定向与输出重定向)详细分析

在了解重定向之前，我们先来看看linux 的文件描述符。

linux文件描述符：可以理解为linux跟踪打开文件，而分配的一个数字，这个数字有点类似c语言操作文件时候的句柄，通过句柄就可以实现文件的读写操作。用户可以自定义文件描述符范围是：3-num,这个最大数字，跟用户的：ulimit –n 定义数字有关系，不能超过最大值。

linux启动后，会默认打开3个文件描述符，分别是：标准输入standard input 0,正确输出standard output 1,错误输出：error output 2

以后打开文件后。新增文件绑定描述符可以依次增加。一条shell命令执行，都会继承父进程的文件描述符。因此，所有运行的shell命令，都会有默认3个文件描述符。

对于任何一条linux 命令执行，它会是这样一个过程：

一个命令执行了：

先有一个输入：输入可以从键盘，也可以从文件得到

命令执行完成：成功了，会把成功结果输出到屏幕：standard output默认是屏幕

命令执行有错误：会把错误也输出到屏幕上面：standard error默认也是指的屏幕

文件输入输出由追踪为一个给定的进程所有打开文件的整数句柄来完成。这些数字值就是文件描述符。最为人们所知的文件米描述符

是 stdin, stdout 和 stderr，文件描述符的数字分别是0，1和2。这些数字和各自的设备是保留的。一个命令执行前，先会准备好所有输入输出，默认分别绑定（stdin,stdout,stderr)，如果这个时候出现错误，命令将终止，不会执行。命令解析过程，可以参考：Linux Shell 通配符、元字符、转义符使用实例介绍

这些默认的输出，输入都是linux系统内定的，我们在使用过程中，有时候并不希望执行结果输出到屏幕。我想输出到文件或其它设备。这个时候我们就需要进行输出重定向了。

linux shell下常用输入输出操作符是：

1. 标准输入(stdin) ：代码为0 ，使用< 或<< ；/dev/stdin -> /proc/self/fd/0 0代表：/dev/stdin

2. 标准输出(stdout)：代码为1 ，使用> 或>> ；/dev/stdout -> /proc/self/fd/1 1代表：/dev/stdout

3. 标准错误输出(stderr)：代码为2 ，使用2> 或2>> ；/dev/stderr -> /proc/self/fd/2 2代表：/dev/stderr

输出重定向：

格式：

command-line1 [1-n] > file或文件操作符或设备

上面命令意思是：将一条命令执行结果（标准输出，或者错误输出，

本来都要打印到屏幕上面的）重定向其它输出设备（文件，打开

文件操作符，或打印机等等）1,2分别是标准输出，错误输出。

实例：

注意：

1、shell遇到”>”操作符，会判断右边文件是否存在，如果存在就先删除，并且创建新文件。不存在直接创建。无论左边命令执行是否成功。右边文件都会变为空。

2、“>>”操作符，判断右边文件，如果不存在，先创建。以添加方式打开文件，会分配一个文件描述符[不特别指定，默认为1,2]然后，与左边的标准输出（1）或错误输出（2）绑定。

3、当命令：执行完，绑定文件的描述符也自动失效。0,1,2又会空闲。

4、一条命令启动，命令的输入，正确输出，错误输出，默认分别绑定0,1,2文件描述符。

5、一条命令在执行前，先会检查输出是否正确，如果输出设备错误，将不会进

行命令执行

输入重定向

格式：

command-line [n]

将然有，命令默认从键盘获得的输入，改成从文件，或者其它打开文件以及设备输入。执行这个命令，将标准输入0，与文件或设备绑定。将由它进行输入。

实例：

管道与重定向

管道命令操作符是：”|”,它仅能处理经由前面一个指令传出的正确输出信息，也就是standard output 的信息，对于stdandard error 信息没有直接处理能力。然后，传递给下一个命令，作为标准的输入standard input. 先看下下面图： command1正确输出，作为command2的输入然后comand2的输出作为，comand3的输入，comand3输出就会直接显示在屏幕上面了。 通过管道之后：comand1,comand2的正确输出不显示在屏幕上面 注意： 1、管道命令只处理前一个命令正确输出，不处理错误输出 2、管道命令右边命令，必须能够接收标准输入流命令才行。 实例： [chengmo@centos5 shell]$ cat test.sh | grep -n 'echo' 5: echo "very good!"; 7: echo "good!"; 9: echo "pass!"; 11: echo "no pass!"; #读出test.sh文件内容，通过管道转发给grep 作为输入内容 [chengmo@centos5 shell]$ cat test.sh test1.sh | grep -n 'echo' cat: test1.sh: 没有那个文件或目录 5: echo "very good!"; 7: echo "good!"; 9: echo "pass!"; 11: echo "no pass!"; #cat test1.sh不存在，错误输出打印到屏幕，正确输出通过管道发送给grep [chengmo@centos5 shell]$ cat test.sh test1.sh 2>/dev/null | grep -n 'echo' 5: echo "very good!"; 7: echo "good!"; 9: echo "pass!"; 11: echo "no pass!"; #将test1.sh 没有找到错误输出重定向输出给/dev/null 文件，正确输出通过管道发送给grep [chengmo@centos5 shell]$ cat test.sh | ls catfile httprequest.txt secure test testfdread.sh testpipe.sh testsh.sh testwhile2.sh envcron.txt python sh testcase.sh testfor2.sh testselect.sh test.txt text.txt env.txt release sms testcronenv.sh testfor.sh test.sh testwhile1.sh #读取test.sh内容，通过管道发送给ls命令，由于ls 不支持标准输入，因此数据被丢弃 这里实例就是对上面2点注意的验证。作用接收标准输入的命令才可以用作管道右边。否则传递过程中数据会抛弃。常用来作为接收数据管道命令有：sed,awk,cut,head,top,less,more,wc,join,sort,split 等等，都是些文本处理命令。 管道命令与重定向区别 区别是： 1、左边的命令应该有标准输出| 右边的命令应该接受标准输入 左边的命令应该有标准输出> 右边只能是文件 左边的命令应该需要标准输入< 右边只能是文件

Windows进程内标准输出重定向

Windows进程内标准输出重定向及其在程序调试上的应用 一、如何实现 打印调试信息的方法有很多，最常用的是使用标准输出设备（如printf、cout等），也可以用OutPutDebugString输出、用DebugView工具查看，还可以写入日志文件。如果程序运行需要记录日志（log），往往需要打开个文件，或许是写入系统事件、用系统的事件查看器查看。 应用程序打印调试信息、日志的方法往往是确定的，但如果是要编写一个模块或者说组件，那样的输出信息应该写入哪里呢？或者说程序本身对此也没有明确需求的话，那该怎么办呢？ 可喜的是一个进程的标准输出是可以重定向的，所以我建议把调试信息直接打到标准输出上，这样代码中可以统一使用cout或者printf，然后根据需要将标准输出重定向。 Linux中重定向标准输出就容易了，因为有强大的dup2函数。而对于Windows的重定向，貌似往往是用于子进程的，在用CreateProcess创建子进程时设置子进程的标准输出句柄。而我们想要的是重定向自己这个进程的标准输出，那个用不上。我在MSDN中也没找到类似dup2的Win32 API函数，只有一个DuplicateHandle函数，这相当于linux中的dup，也用不上。 这里顺便提下，SetStdHandle是不能实现重定向的。这个函数的功能是将某句柄指向标准设备，并不能将标准设备句柄重定向到另外的句柄。 于是我就想到，Windows不是支持一部分POSIX标准的吗。于是我找到了一个CRT的函数，叫_dup2，看起来是不是特眼熟，对了，这就是Windows中dup2的兼容版本。 值得注意的是，_dup2以及与此相关的一系列CRT中的IO函数（如_read,_write）均以下划线开头，其余与linux大致相同，其参数中所谓的文件描述符与Win32中的句柄不一样，文件描述符实际上是句柄数组的索引，也就是说文件描述符不能与句柄混用。比如0,1,2分别是标准输入、标准输出、标准错误的文件描述符，但句柄值不是这样确定的。文件描述符不是Win32的概念，是POSIX中的概念。 _dup2用法与dup2大致相同，不多解释，不了解的可以查阅dup2相关资料。下面讲点应用。 二、如何应用于调试 写一个模块时，我们可以直接用cout/printf来作调试。但是如果这个模块用于图形界面或许是系统服务呢？这时标准输出看不到了，我们可以用OutPutDebugString函数和DebugView 这样的调试工具。这样就带来一种选择，而选择往往是增加软件复杂度的因素。所以我的想法是代码中只用cout/printf，如果需要将其重定向到调试工具中去。 如何实现呢，用匿名管道和线程。 用一个pipe，标准输出重定向到其write端，然后创建一个线程，线程要做的就是从pipe的

Java输入、输出流

第八章输入输出流 【课前思考】 1.字节流和字符流的基类各是什么？ 2.什么是对象的串行化？对象串行化的作用是什么？ 【学习目标】 本讲主要讲述了java语言中的输入/输出的处理，通过本讲的学习，同学们可以编写更为完善的java 程序。 【学习指南】 仔细阅读本章各知识点的内容, 深刻理解 java 语言中输入/输出流的处理方法,掌握处理问题的方法,多练习,多上机。 【难重点】 ●遇到实际问题时，要根据需要正确使用各种输入／输出流，特别是对中文使用适当的字符输入流。 ●正确使用对象串行化的方法。 ●处理字符流时，其构造方法的参数是一个字节流。 ●对象串行化的概念。 【知识点】 ●I/O 流概述 ●文件处理 ●过滤流 ●字符流的处理 ●对象的串行化 ●其它常用的流 【内容】 第一节数据流的基本概念 理解数据流 流一般分为输入流（Input Stream）和输出流（Output Stream）两类，但这种划分并不是绝对的。比如一个文件，当向其中写数据时，它就是一个输出流；当从其中读取数据时，它就是一个输入流。当然，键盘只是一个数人流，而屏幕则只是一个输出流。 Java的标准数据流 标准输入输出指在字符方式下（如DOS），程序与系统进行交互的方式，分为三种： 标准输入studin,对象是键盘。 标准输出stdout,对象是屏幕。 标准错误输出stderr,对象也是屏幕。 例 8.1 从键盘输入字符。 本例用System.in.read(buffer)从键盘输入一行字符，存储在缓冲区buffer中，count保存实际读入的字节个数，再以整数和字符两种方式输出buffer中的值。Read方法在java.io包中，而且要抛出IOException异常。程序如下： import java.io.*; public class Input1 { public static void main(String args[]) throws IOException { System.out.println("Input: ");

Linux输入输出重定向的原理和实现

Linux I/O重定向的原理和实现 在Unix系统中，每个进程都有STDIN、STDOUT和STDERR这3种标准I/O，它们是程序最通用的输入输出方式。几乎所有语言都有相应的标准I/O函数，比如，C语言可以通过scanf从终端输入字符，通过printf向终端输出字符。熟悉Shell的朋友都知道，我们可以方便地对Shell命令进行I/O重定向，比如find -name "*.java" >testfile.txt 把当前目录下的Java文件列表重定向到testfile.txt。多数情况下，我们只需要了解I/O重定向的使用就够了，但是如果要编程实现类似Shell的I/O重定向以及管道功能，那么就需要清楚它的原理和实现。 下面本文就以Linux系统为具体例子，介绍I/O重定向的原理和实现（文中实验环境为Ubuntu 12.04，内核版本3.2.0-59）。 文件描述符表 理解I/O重定向的原理需要从Linux内核为进程所维护的关键数据结构入手。对Linux 进程来讲，每个打开的文件都是通过文件描述符(File Descriptor)来标识的，内核为每个进程维护了一个文件描述符表，这个表以FD为索引，再进一步指向文件的详细信息。在进程创建时，内核为进程默认创建了0、1、2三个特殊的FD，这就是STDIN、STDOUT和STDERR，如下图所示意： 所谓的I/O重定向也就是让已创建的FD指向其他文件。比如，下面是对STDOUT重定向到testfile.txt前后内核文件描述符表变化的示意图 重定向前：

重定向后： 在I/O重定向的过程中，不变的是FD 0/1/2代表STDIN/STDOUT/STDERR，变化的是文件描述符表中FD 0/1/2对应的具体文件，应用程序只关心前者。本质上这和接口的原理是相通的，通过一个间接层把功能的使用者和提供者解耦。 下面我们通过strace命令跟踪一下echo命令的系统调用： dagang@ubuntu12:~$ strace echo hello 2>&1 >/dev/null | grep write write(1, "hello\n", 6) = 6 我们可以看到write(1, "hello\n", 6) 这样一个系统调用，它的第一个参数1就是代表的STDOUT的FD，这说明对于echo程序，它只管（通过标准I/O函数从STDOUT）向FD 1写入，而不关心它们FD 1到底对应的是哪个文件。 Shell正是通过I/O重定向和管道这种特殊的文件把多个程序的STDIN和STDOUT串联在一起组成更复杂功能的，下面是Shell中通过管道的示意图： 下面我们用一个实际的例子来体验一下： dagang@ubuntu12:~$ sleep 30 | sleep 40 & [1] 5584 dagang@ubuntu12:~$ pgrep -l sleep 5583 sleep 5584 sleep dagang@ubuntu12:~$ ll /proc/5583/fd total 0 lrwx------ 1 dagang dagang 64 Feb 27 13:41 0 -> /dev/pts/3 l-wx------ 1 dagang dagang 64 Feb 27 13:41 1 -> pipe:[246469] lrwx------ 1 dagang dagang 64 Feb 27 13:41 2 -> /dev/pts/3 dagang@ubuntu12:~$ ll /proc/5584/fd

Java基础输入输出

Java基础输入输出 io包支持Java的基本I/O（输入/输出）系统，包括文件的输入/输出。对输入/输出的支持是来源于Java的内核API 库，而不是语言关键字。 一、输入/输出基础 很多实际的Java应用程序不是基于文本的控制台程序。尽管基于文本的程序作为教学实例是很出色的，它们无法胜任JA V A在实际中的重要应用。Java对外设输入/输出的支持也是有限的，并且用起来有些笨拙——甚至是在简单的例子程序中。基于文本的控制台输入/输出对于Java程序并不是十分重要。 Java 提供了与文件和网络相关的强大的和灵活的输入/输出支持，Java的输入/输出系统是紧密相连并且是具有一致性的。 1.1 流的概念 Java程序通过流来完成输入/输出。流是生产或消费信息的抽象。流通过Java的输入/输出系统与物理设备链接。尽管与它们链接的物理设备不尽相同，所有流的行为具有同样的方式。这样，相同的输入/输出类和方法适用于所有类型的外部设备。这意味着一个输入流能够抽象多种不同类型的输入：从磁盘文件，从键盘或从网络套接字。同样，一个输出流可

以输出到控制台，磁盘文件或相连的网络。流是处理输入/输出的一个洁净的方法，例如它不需要代码理解键盘和网络的不同。Java中流的实现是在java.io包定义的类层次结构内部的。 1.2 字节流和字符流 要使用流类，必须导入Java.io包。Java 2 定义了两种类型的流：字节类和字符类。字节流（byte stream）为处理字节的输入和输出提供了方便的方法。例如使用字节流读取或书写二进制数据。字符流（character stream）为字符的输入和输出处理提供了方便。它们采用了统一的编码标准，因而可以国际化。在某些场合，字符流比字节流更有效。在最底层，所有的输入/输出都是字节形式的。基于字符的流只为处理字符提供方便有效的方法。下面是对字节流和字符流的概述。 1.2.1 字节流类 字节流由两个类层次结构定义。在顶层有两个抽象类：InputStream 和OutputStream。每个抽象类都有多个具体的子类，这些子类对不同的外设进行处理，例如磁盘文件，网络连接，甚至是内存缓冲区。字节流类显示于表1-1中。 表1-1 字节流类 流类含义 BufferedInputStream缓冲输入流 BufferedOutputStream缓冲输出流

Java 输入输出(含部分答案)

Java输入输出 知识点： 1、文件和流的操作，理解字节流和字符流的概念 2、异常处理的概念，自定义异常类 一、选择题 1、如果一个程序段中有多个catch，则程序会按如下哪种情况执行( ) A)找到合适的例外类型后继续执行后面的catch B)找到每个符合条件的catch都执行一次 C)找到合适的例外类型后就不再执行后面的catch D)对每个catch都执行一次 2、程序员将可能发生异常的代码放在（）块中，后面紧跟着一个或多个（）块。 A) catch、try B) try、catch C) try、exception D) exception、try 3、在Java语言中，在程序运行时会自动检查数组的下标是否越界，如果越界，会抛掷下面的异常( ) A) SQLException B) IOException C) ArrayIndexOutOfBoundsExcetion D) SecurityManager 4、在Java中，关于捕获异常的语法try-catch-finally的下列描述哪些正确( ) A) try-catch必须配对使用B) try可以单独使用 C) try-finally必须配对使用D) 在try-catch后如果定义了finally,则finally肯定会执行 5、给定下面的代码片断： public class Animal{ public void Cat(){ try{ Method(); } catch(ArrayIndexOutBoundsException e) {"Exception1");} catch(Exception e) {"Exception2");} finally {"Hello World!!");} } public void Method() { } public static void main(String[] args) { =new Animal (); Ani. Cat (); } } 如果函数method正常运行并返回，会显示下面的哪些信息( ) A) Hello World B) Exception1 C) Exception2 D) Hello World!!

Linux重定向和管道(精)

6.3 Linux重定向和管道 实验目的 通过重定向和管道操作： 1) 熟悉输入/输出(I/O) 重定向； 2) 把标准输出重定向创建一个文件； 3) 防止使用重定向的时候覆盖文件； 4) 把输出追加到一个现有的文件中； 5) 把一个命令的输出导入到另一个命令中。 实验内容与步骤 在本实验中将会用到下列命令： pwd：显示当前的工作路径。 cd：改变目录路径。 ls：显示指定目录的内容。 more：分页显示文件的内容。这是用于显示文本文件的首选方法。 head：截取显示文件的开头部分(默认为开头10行) 。 tail：截取显示文件的结尾部分(默认为最后10行) 。 cal：有关日历的命令。 set：当前shell下定义的一系列变量及其值。 echo：显示变量的值。 ps：显示当前进程的信息。 data：显示或设置系统日期和时间。 grep：查找文件中指定的关键字的行并输出。 步骤1：开机，登录进入GNOME。 在GNOME登录框中填写指导老师分配的用户名和口令并登录。 步骤2：访问命令行。 单击红帽子，在“GNOME帮助”菜单中单击“系统工具”-“终端”命令，打开终端窗口。 1. 使用重定向标准输出符号 步骤3：重定向标准输出，创建一个文件。 右尖括号或称大于符号(>) 把命令的输出发送到一个文件中：使用单个右尖括号，当指定文件名不存在的时候，将创建一个新文件；如果文件名存在，它将

被覆盖。(注意：命令、重定向符号和文件名之间的空格是可选的) 。 重定向标准输出命令的格式是： command > file 1) 为核实当前所在目录位置，使用什么命令？ ___pwd________________________________________________________ 如果当前位置不在主目录中，使用什么命令可以改变到主目录中？ ___cd /__________________________________________________________ 2) 如果希望把文件和目录列表截获，存储为主目录中的一个文件，这样可以追踪主目录中有什么文件。使用什么命令，把长文件列表的输出重定向，创建一个叫做homedir.list的文件。 ____ls >homedir.list________________________________________________ 3) 新文件homedir.list被放在哪里？ __根目录_________________________________________________________ 使用ls命令核实新文件存在。 4) 使用什么命令，以一次一屏的方式，来查看刚才创建的文件内容？ __ls –l|more homedir.list____________________________________________ 5) 使用head命令截获homedir.list文件的前10行，通过重定向，创建一个叫做dhomedir.list-top-10的新文件。应该使用什么命令？ ___head –10 homedir.list >dhomedir.list-tail-10_________________________ 使用more命令查看文件的内容。 6) 使用tail命令，截获homedir.list文件的最后10行，通过重定向，创建一个叫做dhomedir.list-top-10的新文件。使用什么命令？ ___tail –10 homedir.list >dhomedir.list-top-10___________________________ 使用more命令查看文件的内容。 7) 截获cal -y命令的输出，把它存到名为calendar的文件中。查看文件的内容。截获了什么？ ___cal –y>calendar |more calendar 截获了2008年12个月份的日历 8) 截获cal 2010命令的输出，把它存到名为calendar的文件中。查看文件的内容。其中有什么内容？ _ cal -y 2010 > calendar |more calendar 2010年12月份的日历 日历有什么变化？ ____不是2008年，变成2010年了_____________________________________ 步骤4：防止使用重定向的时候覆盖文件。 在bash shell中，一个叫做noclobber的选项可以用来设定防止在重定向的过程中覆盖文件。可以在命令行中使用$set -o noclobber命令来完成。o代表选项。 为了重新激活clobber特性，使用$set -o noclobber；撤消则用set +o noclobber。 如果你使用的是csh shell，为了激活/撤消C shell中的clobber特性，使用set noclobber和unset noclobber。 1) 输入命令，打开shell中的noclobber选项。输入什么命令？ ___set –o noclobber__________________________________________ _____ 2) 输入命令ls -l > homedir.list，结果是什么？ ___bash:homedir.list:cannot overwrite existing file.因为clobber选项防止了重定向过程覆盖文件___________________________________ _ _

Java的输入与输出流(实验报告)

成都大学实验报告 实验项目名称Java的输入与输出流 一、实验目的： 1. 理解I/O流的概念，掌握其分类 2. 掌握文本文件读写、二进制文件读写 二、实验内容（包括源程序及相关说明）： 1. 分别使用FileWriter 和 BufferedWriter 往文件中写入10万个随机数，比较用时。源代码如下： （1） import .*; public class Ex1_1 { public static void main(String[] args) throws IOException{ long t=(); FileWriter fw =new FileWriter("d:\\"); for(int i=1;i<=100000;i++) { ((int)()*10000)+" \n"); } (); t=()-t; "The elapsed: "+t); } } （2） import .*; public class Ex1_1 { public static void main(String[] args) throws IOException{ long t=(); BufferedWriter fw=new BufferedWriter(new FileWriter("d:\\")); for(int i=1;i<=100000;i++){

((int)()*10000)+"\n"); } (); t=()-t; "The elapsed: "+t); } } 2. 生成一个 html文件，使其能显示2的幂次(0~9)的表格如下： 代码如下： import .*; public class Ex1_1 { public static void main(String[] args) throws IOException{ BufferedWriter bw=new BufferedWriter(new FileWriter("d:\\")); ("

"); (); (""); for(int i=0;i<=9;i++){ (""); } ("

Power of 2	Value
"+i+"	"+(i, 2)+"

"); (); (); } } 3. 在文本文件中包含有很长篇幅的英语短文，编写程序要求统计文件的所有短文中包含英文字母“A”的个数，并显示统计的时间。 第一种实现方法 代码如下： import class EXP1_1 { public static void main(String[] args) throws IOException{ long t =(); String filename="D:\\"; FileInputStream fis=new FileInputStream(filename); int count=0;

linux管道学习笔记

声明：本文档所有内容均为网上整理所得,不保证所有内容正确性.版权属作者本人所有。不用做任何商业用途，仅供广大网友学习交流之用，如有侵权，请联系本人删除,若发现文档中内容有错误或者有个人见解,欢迎指教与相互讨论.Email:.weiming999@https://www.sodocs.net/doc/f19975056.html,。 管道 无名管道 管道包括无名管道和有名管道两种,前者在父子进程中流行,后者由于可以独立成为磁盘文件而存在,因为能够被无血缘关系的进程共享. 无名管道通常直接称为管道,它占用两个文件描述符,不能被非血缘关系的进程共享,一般应用于父子进程. UNIX中一切皆为文件,管道也是一种文件,称为管道文件.当系统中创建一个管道时,它返回两个文件描述符:一个文件以只写打开,作为管道的输入端;另一个文件以只读打开,作为管道的输出端. #include int pipe(int fildes[2]); 函数pipe在内核中创建一个管道,并分配两个文件描述符标识管道的两端,这两个文件描述符存储与fildes[0]和fildes[1]中.一般约定fildes[0]描述管道和输出端,进程向此文件描述符中读取数据,fildes[1]描述管道的输入端,进程向此文件描述符写入数据. fildes[0]:只读文件描述符. fildes[1]:只写文件描述符. Pipe调用成功返回0,否则返回-1. 单向管道流模型 管道的两端(输入端和输出端)被一个进程控制没有太大的意义,如果管道的两端分别控制在不同的进程中,这两个进程之间就能够进行通信.拥有管道输入端的进程,可以向管道发送数据,拥有管道输出端的进程,可以从管道中接受前一个进程发送来的消息. 1)从父进程流向子进程的管道 在父进程创建无名管道并产生子进程后,父子进程均拥有管道两端的访问权.此时关闭父进程的管道输出端,关闭子进程的管道输入端,就形成一个从父进程到子进程的管道流,数据由父进程写入,从子进程读出. 2)从子进程流向父进程的管道 在父进程中创建无名管道并产生子进程后,父子进程均拥有两端的访问权.此时关闭父进程的管道输入端,关闭子进程的管道输出端,就形成了一个从子进程到父进程的管道流.数据由子进程写入,从父进程读出. #i n c l u d e

Linux管道、重定向及多命令

管道和重定向 多命令协作就是通过管道和重定向机制完成的 1.命令行shell的数据流定义 2.重定向 >将STDOUT重定向到文件（覆盖） andy@Fred:~/fred$ echo "abcd" > dddd andy@Fred:~/fred$ ls a abc b b cc c dddd andy@Fred:~/fred$ cat dddd abcd andy@Fred:~/fred$ ls -l 总用量12 -rw-r--r-- 1 andy andy 0 1月 3 21:43 a drwxr-xr-x 2 andy andy 4096 1月 5 10:47 abc -rw-r--r-- 1 andy andy 0 1月 3 21:43 bb -rw-r--r-- 1 andy andy 24 1月 3 21:43 ccc -rw-r--r-- 1 andy andy 5 1月7 21:33 dddd andy@Fred:~/fred$ ls -l > ddd andy@Fred:~/fred$ cat ddd 总用量12 -rw-r--r-- 1 andy andy 0 1月 3 21:43 a drwxr-xr-x 2 andy andy 4096 1月 5 10:47 abc -rw-r--r-- 1 andy andy 0 1月 3 21:43 bb -rw-r--r-- 1 andy andy 24 1月 3 21:43 ccc -rw-r--r-- 1 andy andy 0 1月7 21:35 ddd -rw-r--r-- 1 andy andy 5 1月7 21:33 dddd >>将STDOUT重定向到文件（追加到最后，另起一行） 错误信息是不能添加进入的 2>是将错误信息进行添加，但是正确是信息是不会写入。

管道的一些实例代码

/*管道 可以把管道想象为两个实体之间的单向连接器。注意，管道是半双工的， 如果需要全双工通讯，应该转而考虑套接字。 匿名管道又称管道，提供了一个进程与它的兄弟进程通讯的方法，只存在于父进程中；命名管道，可以存在与文件系统中，任意进程都可找到它，使得不同先祖的进程也可以通讯。 #include int pipe( int dfs[ 2 ] );创建匿名管道 int dup(int oldfd );创建一个文件描述符的副本 int dup2(int oldfd, int targetfd); dup/dup2提供了复制文件描述符的功能。他们常用于stdin(0)、stdout(1)、stderr(2)的重定向； #include #include int mkfifo(const char* pathname,mode_t mode );创建一个命名管道 记住：管道只不过是一对文件描述符因此所有能够操作文件描述符的函数都可用于管道。这些函数 包括但不限于select,read,write,fcntl,freopen。 */ /**********1、简单匿名管道应用************/ #include #include #include #define MAX_LINE 80 #define PIPE_STDIN 0 #define PIPE_STDOUT 1 /* myPipe[ 1 ]向管道写入数据；myPipe[ 0 ]从管道读取数据。 */ int main( ) { const char* string={"A simple message."}; int ret,myPipe[ 2 ]; char buffer[ MAX_LINE+1 ]; //create the pipe ret=pipe( myPipe ); //pipe( )创建一个匿名管道 if( ret==0 ) { //write the message into the pipe write( myPipe[ PIPE_STDOUT ],string,strlen( string ) ); //read the message from the pipe ret=read( myPipe[ PIPE_STDIN ],buffer,MAX_LINE ); //NULL terminate the string buffer[ ret ]=0;

java数据的输入和输出

JA V A数据的输入和输出 一、数据的输出 1、使用System.out.println(输出项)方法 System.out.println(输出项)； 输出结果后换行。输出项可以是变量名、常量、表达式。 例： public class ex1 { public static main(String args[]) { System.out.println("欢迎学习JA V A"); //输出: 欢迎学习JA V A System.out.println(10*2+4); //输出: 24 System.out.println("a="+20); //输出: a=20 } } 2、使用System.out.print()方法 System.out.print(输出项)； 在当前位置输出结果。 如： public class ex2 { public static void main(String args[]) { System.out.print("欢迎学习JA V A"); //输出: 欢迎学习JA V A System.out.print(10*2+4); //输出: 24 System.out.println("a="+20); //输出: a=20 System.out.println("b="+30); } }

3、使用javax.swing.JOptionPane包的showMessageDialog()方法 import javax.swing.JOptionPane; public class ex3 { public static void main(String[] args) { JOptionPane.showMessageDialog(null,"我学习JA V A,我快乐"); System.exit(0); } } 程序解释 （1）语句import javax.swing.JOptionPane;是导入语句，为编译器找到程序中要使用的类。（2）main()方法中的语句： JOptionPane.showMessageDialog(null,"我学习JA V A,我快乐"); 从类库加载的JOptionPane类中调用showMessageDialog()方法，这是一个显示对话框的方法。该方法有两个参数，第1个参数为null，第2参数是要显示的字符串，参数间用逗号分开。（3）System.exit(0)语句使用System类的exit()方法结束程序的运行。 二、数据的输入 1、使用命令行参数 main(String args[])方法的参数数组args接收命令行的参数，args[0]存放第一个参数字符串，args[1]存放第二个参数字符串，依此类推。 各个参数数组元素args[i]的值都是字符串，必须在main()方法中用相关的转换方法把字符串转换为对应的数据类型。（P142表10-1） 【例】从键盘上输入圆的半径，求圆的周长和面积。

父子进程通过管道通信(MFC重定向)

今天领导心血来潮说服务器的运行界面是一个黑乎乎的控制台，太低端了，看我们能不能把它图形化，至少做成一个窗口有按钮点启动、停止。好吧，领导拍脑袋就叫人干活的事不少，也没有产品规划，也就是让他看的舒服，只能去做了。 其中有一个关键性问题，就是原先是往控制台输出的信息，使用mfc图形化之后该往哪输出，工程维护人员肯定还是希望能在图形界面上能够看到这些信息的，因此就涉及到了如何获取到输出控制台的消息（都是cout、printf这种标准输出），然后再将这些消息重写到view上。这时候想到了标准输出重定向，因此整理了下思路： 1.将标准输出重定向到管道 2.创建一个线程从管道里取出数据 3.在view的OnPaint中将数据显示出来 二、实现 1.创建管道 [cpp]view plaincopyprint? 1.BOOL bRet = CreatePipe(&hRead, &hWrite, NULL, 0); // 创建匿名管道 2.if (bRet != TRUE) 3. printf("创建匿名管道失败,错误代码:%d\n", GetLastError()); 2.将标准输出重定向到管道的写句柄中 [cpp]view plaincopyprint? 1.int nOpenHandle = _open_osfhandle((intptr_t)hWrite, _O_TEXT); 2.FILE* fp = _fdopen( nOpenHandle, "w"); 3.*stdout = *fp; 注意：这里不能使用SetStdHandle(STD_OUTPUT_HANDLE, hWrite)，在MFC中SetStdHandle是没有效果的。 3.创建线程从管道取数据 [cpp]view plaincopyprint? 1.boost::thread thr(boost::bind(&CKDSShellView::print_cb, this));

JAVA输入输出和基本算法技巧

在有多行数据输入的情况下，一般这样处理， plaincopy 1.static Scanner in=new Scanner(System.in); 2.while(in.hasNextInt()) 3.或者是 4.while(in.hasNext()) 5.有关System.nanoTime()函数的使用，该函数用来返回最准确的可用系统计时器的当前值，以毫微秒为单位。 plaincopy 1.long startTime=System.nanoTime(); 2.//...the code being measured... 3.long estimatedTime=System.nanoTime()-startTime; 二、Java之输入输出处理 由于ACM竞赛题目的输入数据和输出数据一般有多组（不定），并且格式多种多样，所以，如何处理题目的输入输出是对大家的一项最基本的要求。这也是困扰初学者的一大问题。1.输入： 格式1：Scanner sc=new Scanner(new BufferedInputStream(System.in)); 格式2：Scanner sc=new Scanner(System.in); 在读入数据量大的情况下，格式1的速度会快些。 读一个整数：int n=sc.nextInt();相当于scanf("%d",&n);或cin>>n; 读一个字符串：String s=sc.next();相当于scanf("%s",s);或cin>>s; 读一个浮点数：double t=sc.nextDouble();相当于scanf("%lf",&t);或cin>>t; 读一整行：String s=sc.nextLine();相当于gets(s);或cin.getline(...); 判断是否有下一个输入可以用sc.hasNext()或sc.hasNextInt()或sc.hasNextDouble()或 sc.hasNextLine()

Java 输入输出 的 基本原理及示例

来自： 亿淘城_减肥榜的个人笔记 xx你的支持(*^__^*)嘻嘻…… Java I/O原理 →基本概念： I/O（Input/Output） 数据源（Data Source） 数据xx(Data Sink) →Java中把不同的数据源与程序间的数据传输都抽象表述为“流”（Stream）,java.io包中定义了多种I/O流类型实现数据I/O功能。 →I/O流分类： 输入流（Input Stream）和输出流（Output Stream） 节点流(Node Stream)和处理流(Processing Stream) 字符流(Character Stream)和字节流(Byte Stream) ＃输入流（Input Stream）和输出流（Output Stream） 1.输入流只能从中读取数据，而不能向其写数据； 2.输出流则只能向其写出数据，而不能从中读取数据； 3.特例： java.io.RandomAccessFile类。 ＃节点流(Node Stream)和处理流(Processing Stream) 1.节点流直接连接到数据源

2.处理流是对一个已存在的流的连接和封装，通过所封装的刘的功能 调用实现增强的数据读写功能，处理流并不直接连到数据源＃字符流(Character Stream)和字节流(Byte Stream) 1.字节流以字节为单位进行数据传输，每次传送一个或多个字节。 2.字符流以字符为单位进行数据传输，每次传送一个或多个字符。 ※Java命名惯例： 凡是以InputStream 或OutputStream结尾的类型均为字节流，凡是以Reader或Writer 结尾的均为字符流。 InputStream 抽象类java.io.InputStream 是所有字节输入流类型的父类，该类中定义了以字节为单位读取数据的基本方法，并在其子类中进行了分化和实现。 ◆三个基本的read方法： Int read() Int read(byte[] buffer) Int read(byte[] buffer,int offset,int length) ◆其它方法： Void close() Int available() Skip(long n) Boolean markSupported() Void mark(int readlimit) Void reset()

Linux下管道命令及应用

利用输入/输出重定向 在Linux命令行模式中，如果命令所需的输出不是来自键盘，而是来自指定的文件，这就是输入重定向。同理，命令的输出也可以不显示在屏幕上，而是写入到指定文件中，这就是输出重定向。 接下来看看标准输入/输出重定向在构造一条Linux命令中的实际应用。 1.输入重定向和输出重定向 # wc home.txt 第一条命令将文件aa.txt作为wc命令的输入，统计出aa.txt的行数、单词数和字符数。第二条命令将ls命令的输出保存在一个名为home.txt的文件中。如果符号后边的文件已存在，那么这个文件将被重写。 2.同时使用输入和输出重定向 # iconv -f gb18030 -t utf-8 new-aa.txt 这条命令里同时用到了输入重定向（new-aa.txt）。aa.txt实际是一个gb18030编码的文件，而new-aa.txt则是将aa.txt的内容转换成utf-8格式的新文件。 利用管道 利用Linux所提供的管道符“|”将两个命令隔开，管道符左边命令的输出就会作为管道符右边命令的输入。连续使用管道意味着第一个命令的输出会作为第二个命令的输入，第二个命令的输出又会作为第三个命令的输入，依此类推。下面来看看管道是如何在构造一条Linux命令中得到应用的。 1.利用一个管道 # rpm -qa|grep licq 这条命令使用一个管道符“|”建立了一个管道。管道将rpm -qa命令的输出（包括系统中所有安装的RPM包）作为grep命令的输入，从而列出带有licq字符的RPM包来。 4.利用多个管道 # cat /etc/passwd | grep /bin/bash | wc -l 这条命令使用了两个管道，利用第一个管道将cat命令（显示passwd文件的内容）的输出送给grep命令，grep命令找出含有“/bin/bash”的所有行；第二个管道将grep的输入送给wc命令，wc命令统计出输入中的行数。这个命令的功能在于找出系统中有多少个用户使用bash。 利用命令替换 在Linux命令行模式下，当遇到一对“`”(上分割符)时，将首先执行“`”中间包含的命令，然后将其输出结果作为参数代入命令行中，这就是命令替换了。它类似于输入输出的重定向功能，但区别在于命令替换是将一个命令的输出作为另外一个命令的参数。下面来看它的实际应用。 1.使用命令替换 # touch `date +%Y%m%d%k%M%S`.txt 该命令使用了一次命令替换，date +%Y%m%d%k%M%S命令将首先执行，它将按指定格式输出当前的时间。然后，这个时间将被作为touch命令的参数，其结果是建立了一个以当前时间为文件名的文件。 2.使用命令替换 # kill `/sbin/pidof smbd` 该命令将杀掉sshd的所有进程。这里用pidof这个命令给出进程号，因为kill是针对进程号进行操作的。两者通过命令替换，实现了只用一条命令就杀掉sshd所有进程的功能。

相关主题

• 管道和重定向
• java基本输入输出