Redirecting the Standard Input and Output Streams - D Programming Language
Description: D Programming Language
Keywords: D programming language

Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Downloads
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Calendar
  - Discord (community-run)
  - Forums
  - IRC
  - Wiki
  - Issues
  - Contributing
  - Contributors
  - Foundation
  - Security Team
  - Donate
  - Sponsors
- Resources
  - Tour
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - run.dlang.io
  - Visual D
  - Acknowledgments
  - D Style
  - Glossary
  - Sitemap

Search
Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

# Redirecting the Standard Input and Output Streams

All of the programs that we have seen so far have interacted through `stdin` and `stdout`, the standard input and output streams. Input and output functions like `readf` and `writeln` operate on these streams by default.

While using these streams, we assumed that the standard input comes from the keyboard and that the standard output goes to the screen.

We will start writing programs that deal with files in later chapters. We will see that, just like the standard input and output streams, files are character streams as well; so they are used in almost the same way as `stdin` and `stdout`.

But before seeing how files are accessed from within programs, I would like to show how the standard inputs and outputs of programs can be redirected to files or piped to other programs. Existing programs can, without their source code being changed, be made to print to files instead of the screen, and read from files instead of the keyboard. Although these features are not directly related to programming languages, they are useful tools that are available in nearly all modern shells.

##### Redirecting the standard output to a file with operator `>`

When starting the program from the terminal, typing a `>` character and a file name at the end of the command line redirects the standard output of that program to the specified file. Everything that the program prints to its standard output will be written to that file instead.

Let's test this with a program that reads a floating point number from its input, multiplies that number by two, and prints the result to its standard output:

    import std.stdio;

    void main() {
        double number;
        readf(" %s", &number);

        writeln(number * 2);
    }

If the name of the program is `by_two`, its output will be written to a file named `by_two_result.txt` when the program is started on the command line as in the following line:

    ./by_two > by_two_result.txt

For example, if we enter `1.2` at the terminal, the result `2.4` will appear in `by_two_result.txt`. (Note: Although the program does not display a prompt like "Please enter a number", it still expects a number to be entered.)

##### Redirecting the standard input from a file with operator `<`

Similarly to redirecting the standard output by using the `>` operator, the standard input can be redirected from a file by using the `<` operator. In this case, the program reads from the specified file instead of from the keyboard.

To test this, let's use a program that calculates one tenth of a number:

    import std.stdio;

    void main() {
        double number;
        readf(" %s", &number);

        writeln(number / 10);
    }

Assuming that the file `by_two_result.txt` still exists and contains `2.4` from the previous output, and that the name of the new program is `one_tenth`, we can redirect the new program's standard input from that file as in the following line:

    ./one_tenth < by_two_result.txt

This time the program will read from `by_two_result.txt` and print the result to the terminal as `0.24`.

##### Redirecting both standard streams

The operators `>` and `<` can be used at the same time:

    ./one_tenth < by_two_result.txt > one_tenth_result.txt

This time the standard input will be read from `by_two_result.txt` and the standard output will be written to `one_tenth_result.txt`.

##### Piping programs with operator `|`

Note that `by_two_result.txt` is an intermediary between the two programs; `by_two` writes to it and `one_tenth` reads from it.

The `|` operator pipes the standard output of the program that is on its left-hand side to the standard input of the program that is on its right-hand side without the need for an intermediary file. For example, when the two programs above are piped together as in the following line, they collectively calculate one fifth of the input:

    ./by_two | ./one_tenth

First `by_two` reads a number from its input. (Remember that although it does not prompt for one, it still waits for a number.) Then `by_two` writes the result to its standard output. This result of `by_two` will appear on the standard input of `one_tenth`, which in turn will calculate and print one tenth of that result.

##### Problem

Pipe more than one program:

    ./one | ./two | ./three

... çözüm

Copyright © 1999-2026 by the D Language Foundation | Page generated by Ddoc on Wed Aug 5 11:24:17 2026