STANDARD STREAMS

(Redirected from Standard input)
The standard streams for input, output, and error

The 'standard streams' are preconnected input or output channels between a computer program and its environment (typically a text terminal) when it begins execution. These standard connections are provided in Unix and Unix-like operating systems, C and C++ runtime environments, and their successors. The three I/O connections are called 'standard input', 'standard output' and 'standard error'.

Contents
Background
Standard input (stdin)
Standard output (stdout)
Standard error (stderr)
Timeline
1950s: Fortran
1960: ALGOL 60
1968: ALGOL 68
1970s: C and Unix
1980s: C++
GUIs
See also
References
External Links

Background


In most operating systems predating Unix, programs had to explicitly connect to the appropriate input and output data. On many of those systems, this could be an intimidating programming challenge created by OS-specific intricacies such as obtaining control environment settings, accessing a local file table, determining the intended data set, and handling the correct case of a card reader, magnetic tape drive, disk drive, or interactive terminal.
Unix provided several groundbreaking advances, one of which was to provide ''abstract devices'': it removed the need for a program to know or care what kind of device it was communicating with. Older operating systems forced upon the programmer a record structure and, frequently non-orthogonal data semantics and device control. Unix eliminated this complexity with the concept of a data stream: an ordered sequence of data bytes which can be read until the end of file. A program may also write bytes as desired and need not (and can't easily) declare how many there will be, or how they will be grouped.
Another Unix breakthrough was to automatically associate input and output by default—the program (and programmer) did absolutely nothing to establish input and output for a typical input-process-output program (unless the program chose a different paradigm). In contrast, previous operating systems usually required some—often complex—job control language to establish connections, or the equivalent burden had to be orchestrated by the program.
Since Unix provided standard streams, the Unix C runtime environment was obligated to support it as well. As a result, most C runtime environments (and C's descendants), regardless of the operating system, provide equivalent functionality.

Standard input (stdin)


Standard input is data (often text) going into a program. The program requests data transfers by use of the ''read'' operation. Not all programs require input. For example, the ''dir'' or ''ls'' program (which displays file names contained in a directory) performs its operation without any stream data input.
Unless ''redirected'', input is expected from the text terminal which started the program.
The file descriptor for standard input is 0 (zero); the corresponding '''' variable is FILE
★ stdin
; similarly, the '''' variable is std::cin.

Standard output (stdout)


Standard output is the stream where a program writes its output data. The program requests data transfer with the ''write'' operation. Not all programs generate output. For example the ''file rename'' command (variously called ''mv'', ''move'', ''ren'') is silent on success.
Unless ''redirected'', standard output is the text terminal which initiated the program.
The file descriptor for standard output is 1 (one); the corresponding '''' variable is FILE
★ stdout
; similarly, the '''' variable is std::cout.

Standard error (stderr)


Standard error is another output stream typically used by programs to output error messages or diagnostics. It is a stream independent of standard output and can be redirected separately. The usual destination is the text terminal which started the program to provide the best chance of being seen even if ''standard output'' is redirected (so not readily observed). For example, output of a program in a pipeline is redirected to input of the next program, but errors from each program still go directly to the text terminal.
It is acceptable—and normal—for ''standard output'' and ''standard error'' to be directed to the same destination, such as the text terminal. Messages appear in the same order as the program writes them, unless buffering is involved. (For example, a common situation is when the standard error stream is unbuffered but the standard output stream is line-buffered; in this case, text written to standard error later may appear on the terminal earlier, if the standard output stream's buffer is not yet full.)
The file descriptor for standard error is 2; the corresponding '''' variable is FILE
★ stderr
. The C++ '''' standard header provides two variables associated with this stream: std::cerr and std::clog, the former being unbuffered and the latter using the same buffering mechanism as all other C++ streams.

Timeline


1950s: Fortran

Fortran had the equivalent of Unix file descriptors, UNIT=5 for stdin, and UNIT=6 for stdout.
PROGRAM MAIN
READ(UNIT=5,
★ )NUMBER
WRITE(UNIT=6,'(F5.3)')' NUMBER IS: ',NUMBER
END
1960: ALGOL 60

ALGOL 60 was criticized for having no standard file access.
1968: ALGOL 68

ALGOL 68's Input and output facilities were collectively referred to as the transput. Koster coordinated the definition of the ''transput'' standard. This standard included: stand in, stand out, stand error and stand back.
Example:

main:(
REAL number;
getf(stand in,($g$,number));
printf(($"Number is: "g(6,4)"OR "$,number)); # OR #
putf(stand out,($" Number is: "g(6,4)"!"$,number));
newline(stand out)
)

Input:Output:
3.14159
Number is: +3.142 OR Number is: +3.142!

1970s: C and Unix

In the 'C programming language' stdin, stdout and stderr streams were attached to the existing unix file descriptors 0, 1 and 2 respectively.
1980s: C++

In C++, the standard streams can be accessed with the ''cin'', ''cout'' and ''cerr'' objects (see iostream).
GUIs

Graphical user interfaces (GUIs) rarely make use of the standard streams. Consequently, redirecting GUI programs or constructing a GUI pipeline is neither practical nor useful. The nearest analog is probably ''cutting'' (or ''copying'') from one application and ''pasting'' into another. Since manual user operations are required, moving large numbers of ''pastes'' is not especially efficient.

See also



Redirection (Unix)

Pipeline (Unix)

Stream (computer)

Input/output

C file input/output

References



★ ''KRONOS 2.1 Reference Manual'', Control Data Corporation, Part Number 60407000, 1974

★ ''NOS Version 1 Applications Programmer's Instant'', Control Data Corporation, Part Number 60436000, 1978

Level 68 Introduction to Programming on MULTICS, Honeywell Corporation, 1981

Evolution of the MVS Operating System, IBM Corporation, 1981

★ ''Lions' Commentary on UNIX® Sixth Edition'', John Lions, ISBN 1-57398-013-7, 1977

External Links



Comparison of Standout Output in different languages

Standard Output Definition - by The Linux Information Project (LINFO)

This article provided by Wikipedia. To edit the contents of this article, click here for original source.

psst.. try this: add to faves