ในการเขียนโปรแกรมคอมพิวเตอร์สตรีมมาตรฐานคือช่องทางการสื่อสาร อินพุตและเอาต์พุตที่เชื่อมต่อไว้ล่วงหน้า ^{[ 1 ]}ระหว่างโปรแกรมคอมพิวเตอร์กับสภาพแวดล้อมเมื่อเริ่มการทำงาน การเชื่อมต่อ อินพุต/เอาต์พุต (I/O) ทั้งสามเรียกว่าอินพุตมาตรฐาน ( stdin ) เอาต์พุตมาตรฐาน ( stdout ) และข้อผิดพลาดมาตรฐาน ( stderr ) เดิมที I/O เกิดขึ้นผ่านคอนโซลระบบที่ เชื่อมต่อทางกายภาพ (อินพุตผ่านแป้นพิมพ์ เอาต์พุตผ่านจอภาพ) แต่สตรีมมาตรฐานได้แยกส่วนนี้ออกไป เมื่อคำสั่งถูกดำเนินการผ่านเชลล์ แบบโต้ตอบ สตรีมมักจะเชื่อมต่อกับเทอร์มินัลข้อความที่เชลล์กำลังทำงานอยู่ แต่สามารถเปลี่ยนแปลงได้ด้วยการเปลี่ยนเส้นทางหรือไปป์ไลน์โดยทั่วไปแล้วกระบวนการลูกจะสืบทอดสตรีมมาตรฐานจากกระบวนการ แม่

โดยทั่วไปผู้ใช้จะรู้จักสตรีมมาตรฐานว่าเป็นช่องทางรับและส่งข้อมูลที่จัดการข้อมูลที่มาจากอุปกรณ์รับข้อมูล หรือที่เขียนข้อมูลจากแอปพลิเคชัน ข้อมูลอาจเป็นข้อความที่มีการเข้ารหัสใดๆ หรือข้อมูลไบนารีเมื่อโปรแกรมทำงานในโหมดดีมอนสตรีมข้อผิดพลาดมาตรฐานของโปรแกรมจะถูกส่งไปยังไฟล์บันทึก ซึ่งโดยทั่วไปแล้วใช้เพื่อวัตถุประสงค์ในการวิเคราะห์ข้อผิดพลาด

สตรีมสามารถใช้เพื่อเชื่อมโยงแอปพลิเคชันต่างๆ เข้าด้วยกัน ซึ่งหมายความว่าสตรีมเอาต์พุตของโปรแกรมหนึ่งสามารถเปลี่ยนเส้นทางไปเป็นสตรีมอินพุตของอีกแอปพลิเคชันหนึ่งได้ ในระบบปฏิบัติการหลายๆ ระบบ จะแสดงวิธีการนี้โดยการแสดงรายชื่อแอปพลิเคชันคั่นด้วยเครื่องหมายขีดแนวตั้ง ซึ่งมักเรียกว่า อักขระ ไปป์ไลน์ตัวอย่างที่รู้จักกันดีคือการใช้ แอป พลิเคชันการแบ่งหน้าเช่น แอป พลิเคชัน " เพิ่มเติม"ซึ่งช่วยให้ผู้ใช้ควบคุมการแสดงผลสตรีมเอาต์พุตบนหน้าจอได้

ในระบบปฏิบัติการส่วนใหญ่ก่อนยุคUnixโปรแกรมต้องเชื่อมต่อกับอุปกรณ์อินพุตและเอาต์พุตที่เหมาะสมอย่างชัดเจน ความซับซ้อนเฉพาะของระบบปฏิบัติการทำให้การเขียนโปรแกรมในส่วนนี้เป็นเรื่องที่ยุ่งยาก ในหลายระบบ จำเป็นต้องควบคุมการตั้งค่าสภาพแวดล้อม เข้าถึงตารางไฟล์ในเครื่อง กำหนดชุดข้อมูลที่ต้องการ และจัดการฮาร์ดแวร์อย่างถูกต้องในกรณีของเครื่องอ่านบัตรเจาะรูไดรฟ์เทปแม่เหล็ก ไดรฟ์ดิสก์เครื่องพิมพ์แบบบรรทัด เครื่องเจาะบัตร หรือเทอร์มินัลแบบโต้ตอบ

หนึ่งในความก้าวหน้าครั้งสำคัญหลายประการของ Unix คืออุปกรณ์นามธรรม (abstract devices ) ซึ่งช่วยขจัดความจำเป็นที่โปรแกรมจะต้องรู้หรือใส่ใจว่ากำลังสื่อสารกับอุปกรณ์ประเภทใด ระบบปฏิบัติการรุ่นเก่าบังคับให้โปรแกรมเมอร์ใช้โครงสร้างเรคอร์ด และความหมายของข้อมูลที่ไม่เป็นไปตามแบบแผน ( non-orthogonal data semantics) และการควบคุมอุปกรณ์ Unix ขจัดความซับซ้อนนี้ด้วยแนวคิดของสตรีมข้อมูล (data stream): ลำดับของไบต์ข้อมูลที่เรียงลำดับซึ่งสามารถอ่านได้จนกว่าจะถึงจุดสิ้นสุดของไฟล์โปรแกรมยังสามารถเขียนไบต์ได้ตามต้องการและไม่จำเป็นต้องทำเช่นนั้น และไม่สามารถประกาศจำนวนหรือการจัดกลุ่มของไบต์ได้อย่างง่ายดาย

อีกหนึ่งความก้าวหน้าของ Unix คือการเชื่อมโยงอินพุตและเอาต์พุตเข้ากับแป้นพิมพ์เทอร์มินัลและจอแสดงผลเทอร์มินัลโดยอัตโนมัติเป็นค่าเริ่มต้น — โปรแกรม (และโปรแกรมเมอร์) ไม่ต้องทำอะไรเลยเพื่อกำหนดอินพุตและเอาต์พุตสำหรับโปรแกรมแบบอินพุต-ประมวลผล-เอาต์พุตทั่วไป (เว้นแต่จะเลือกแบบแผนอื่น) ในทางตรงกันข้าม ระบบปฏิบัติการก่อนหน้านี้มักต้องการภาษาควบคุมงาน ที่ซับซ้อน เพื่อสร้างการเชื่อมต่อ หรือโปรแกรมต้องเป็นผู้จัดการภาระที่เทียบเท่ากันเอง

เนื่องจาก Unix มีมาตรฐานสตรีม ดังนั้นสภาพแวดล้อมการทำงานของ Cบน Unix จึงต้องรองรับมาตรฐานนี้ด้วยเช่นกัน ส่งผลให้สภาพแวดล้อมการทำงานของ C ส่วนใหญ่ (และภาษาที่พัฒนาต่อยอดจาก C ) ไม่ว่าจะใช้ระบบปฏิบัติการใดก็ตาม ก็มีฟังก์ชันการทำงานที่เทียบเท่ากัน

อินพุตมาตรฐานคือสตรีมที่โปรแกรมอ่านข้อมูลเข้ามา โปรแกรมร้องขอการถ่ายโอนข้อมูลโดยใช้ การดำเนินการ อ่านไม่ใช่ทุกโปรแกรมที่ต้องการอินพุตแบบสตรีม ตัวอย่างเช่น โปรแกรม dirและls (ซึ่งแสดงชื่อไฟล์ที่อยู่ในไดเร็กทอรี) อาจรับอาร์กิวเมนต์จากบรรทัดคำสั่งแต่ดำเนินการโดยไม่ต้องมีอินพุตข้อมูลแบบสตรีมใดๆ

เว้นแต่จะมีการเปลี่ยนเส้นทางการป้อนข้อมูลมาตรฐานจะถูกสืบทอดมาจากกระบวนการแม่ ในกรณีของเชลล์แบบโต้ตอบ โดยปกติแล้วจะเชื่อมโยงกับอุปกรณ์ป้อนข้อมูลของเทอร์มินัล (หรือเทอร์มินัลเสมือน ) ซึ่งท้ายที่สุดแล้วจะเชื่อมโยงกับ แป้นพิมพ์ของผู้ใช้

บนระบบPOSIX ตัวระบุไฟล์สำหรับอินพุตมาตรฐานคือ 0 (ศูนย์) คำจำกัดความของPOSIX<unistd.h>คือSTDIN_FILENO; ^{[ 2 ]}นามธรรม C ที่สอดคล้องกัน<stdio.h>มีให้ผ่าน ตัวแปรส่วนกลาง stdin(ประเภทFILE*) ในทำนองเดียวกันในC++อ็อบเจ็กต์ส่วนกลางstd::cin(ประเภทstd::istream) ที่ให้ไว้ใน<iostream>จะให้นามธรรมผ่านสตรีม C++ นามธรรมที่คล้ายกันมีอยู่ในไลบรารี I/O มาตรฐานของ ภาษาโปรแกรมแทบทุกภาษา

เอาต์พุตมาตรฐานคือสตรีมที่โปรแกรมเขียนข้อมูลเอาต์พุตลงไป โปรแกรมจะร้องขอการถ่ายโอนข้อมูลด้วย การดำเนินการ เขียนไม่ใช่ทุกโปรแกรมที่จะสร้างเอาต์พุต ตัวอย่างเช่น คำสั่ง เปลี่ยนชื่อไฟล์ (เรียกได้หลายแบบว่าmv , moveหรือren ) จะไม่แสดงข้อความใดๆ เมื่อดำเนินการสำเร็จ

หากไม่มีการเปลี่ยนเส้นทางเอาต์พุตมาตรฐานจะได้รับมาจากกระบวนการแม่ ในกรณีของเชลล์แบบโต้ตอบ โดยปกติแล้วจะเป็นเทอร์มินัลข้อความที่เริ่มต้นโปรแกรม

ตัวระบุไฟล์สำหรับเอาต์พุตมาตรฐานคือ 1 (หนึ่ง); คำจำกัดความ POSIX<unistd.h>คือSTDOUT_FILENO; ^{[ 2 ]} ตัวแปร C ที่สอดคล้องกัน<stdio.h>คือstdout(ประเภทFILE*); ในทำนองเดียวกันใน C++ อ็อบเจ็กต์ส่วนกลางstd::cout(ประเภทstd::ostream) ที่ให้ไว้ใน<iostream>จะแยกส่วนสตรีมเอาต์พุต

ข้อผิดพลาดมาตรฐาน (Standard error) เป็นสตรีมเอาต์พุตอีกรูปแบบหนึ่งที่โปรแกรมมักใช้เพื่อแสดงข้อความแสดงข้อผิดพลาดหรือข้อมูลการวินิจฉัย สตรีมนี้เป็นอิสระจากเอาต์พุตมาตรฐาน (Standard output) และสามารถกำหนดเส้นทางใหม่ได้โดยแยกต่างหาก

วิธีนี้ช่วยแก้ปัญหาเซมิเพรดิเคท (Semi-predicate problem ) ทำให้สามารถแยกแยะระหว่างผลลัพธ์และข้อผิดพลาดได้ และคล้ายคลึงกับฟังก์ชันที่ส่งคืนค่าสองค่า – ดูปัญหาเซมิเพรดิเคท § การส่งกลับแบบหลายค่า (Multivalued return ) ปลายทางปกติคือเทอร์มินัลข้อความที่เริ่มต้นโปรแกรมเพื่อให้มีโอกาสเห็นผลลัพธ์ได้ดีที่สุด แม้ว่าเอาต์พุตมาตรฐานจะถูกเปลี่ยนเส้นทาง (จึงไม่สามารถสังเกตได้ง่าย) ตัวอย่างเช่น เอาต์พุตของโปรแกรมในไปป์ไลน์จะถูกเปลี่ยนเส้นทางไปยังอินพุตของโปรแกรมถัดไปหรือไฟล์ข้อความ แต่ข้อความแจ้งเตือนผู้ใช้และข้อผิดพลาดจากแต่ละโปรแกรมยังคงส่งตรงไปยังเทอร์มินัลข้อความเพื่อให้ผู้ใช้สามารถตรวจสอบได้แบบเรียลไทม์

เป็นเรื่องปกติและยอมรับได้ที่จะส่งข้อความเอาต์พุตมาตรฐานและข้อความข้อผิดพลาดมาตรฐานไปยังปลายทางเดียวกัน เช่น เทอร์มินัลข้อความ ข้อความจะปรากฏตามลำดับที่โปรแกรมเขียน เว้นแต่จะ มี การบัฟเฟอร์เข้ามาเกี่ยวข้อง ตัวอย่างเช่น ในสถานการณ์ทั่วไป สตรีมข้อผิดพลาดมาตรฐานจะไม่มีการบัฟเฟอร์ แต่สตรีมเอาต์พุตมาตรฐานจะมีการบัฟเฟอร์แบบบรรทัดต่อบรรทัด ในกรณีนี้ ข้อความที่เขียนไปยังข้อผิดพลาดมาตรฐานในภายหลังอาจปรากฏบนเทอร์มินัลก่อน หากบัฟเฟอร์ของสตรีมเอาต์พุตมาตรฐานยังไม่เต็ม

ตัวระบุไฟล์สำหรับข้อผิดพลาดมาตรฐานถูกกำหนดโดยPOSIXเป็น 2 (สอง); ไฟล์ส่วนหัว <unistd.h>ให้สัญลักษณ์STDERR_FILENO; ^{[ 2 ]} ตัวแปร C ที่สอดคล้องกัน<stdio.h>คือstderr(ประเภทFILE*) ในทำนองเดียวกัน C++ ให้วัตถุส่วนกลางสองรายการที่เกี่ยวข้องกับสตรีมนี้: std::cerrและstd::clog(แต่ละรายการเป็นประเภทstd::ostream) ใน<iostream>โดยรายการแรกไม่มีบัฟเฟอร์และรายการหลังใช้กลไกบัฟเฟอร์แบบเดียวกับสตรีม C++ อื่นๆ ทั้งหมด

เชลล์แบบBourne อนุญาตให้เปลี่ยนเส้นทาง ข้อผิดพลาดมาตรฐานไปยังปลายทางเดียวกับที่ส่งเอาต์พุตมาตรฐานไป

2>&1 

เชลล์แบบcsh อนุญาตให้ส่ง ข้อผิดพลาดมาตรฐานไปยังปลายทางเดียวกับที่ส่งเอาต์พุตมาตรฐานไป

>& 

ข้อผิดพลาดมาตรฐานถูกเพิ่มเข้าไปใน Unix ในช่วงทศวรรษ 1970 หลังจากการพิมพ์ภาพถ่ายที่สูญเปล่าหลายครั้งจบลงด้วยข้อความแสดงข้อผิดพลาดที่พิมพ์แทนที่จะแสดงบนเทอร์มินัลของผู้ใช้^{[ 3 ]}

Fortranมีสิ่งที่เทียบเท่ากับตัวอธิบายไฟล์ของ Unix: ตามธรรมเนียมแล้ว การใช้งาน Fortran หลายๆ แบบจะใช้หมายเลขหน่วยUNIT=5สำหรับ stdin, UNIT=6stdout และUNIT=0stderr ^{[ 4 ]}ใน Fortran 2003 ISO_FORTRAN_ENVโมดูล intrinsic ได้รับการกำหนดมาตรฐานให้รวมค่าคงที่ที่มีชื่อINPUT_UNIT, OUTPUT_UNIT, และERROR_UNITเพื่อระบุหมายเลขหน่วยได้อย่างพกพา^{[ 5 ]}

! ตัวอย่างโปรแกรม FORTRAN 77 PROGRAM MAIN INTEGER NUMBER READ ( UNIT = 5 , * ) NUMBER WRITE ( UNIT = 6 , '(A,I3)' ) ' NUMBER IS: ' , NUMBER END

! โปรแกรมตัวอย่าง Fortran 2003 main use iso_fortran_env implicit none integer :: number read ( unit = INPUT_UNIT , * ) number write ( unit = OUTPUT_UNIT , '(a,i3)' ) 'Number is: ' , number end program

ALGOL 60ถูกวิพากษ์วิจารณ์ว่าไม่มีมาตรฐานการเข้าถึงไฟล์

สิ่งอำนวยความสะดวกในการป้อนข้อมูลและการส่งออกของ ALGOL 68เรียกรวมกันว่าทรานพัต^{[ 6 ]} Koster ประสานงานการกำหนด มาตรฐาน ทรานพัตโมเดลประกอบด้วยช่องมาตรฐานสามช่อง ได้แก่stand in, stand out, stand backและ

# ตัวอย่าง ALGOL 68 # หลัก:( ตัวเลขจริง; getf(stand in,($g$,number)); printf(($"Number is: "g(6,4)"OR "$,number)); # OR # putf(stand out,($" Number is: "g(6,4)"!"$,number)); ขึ้นบรรทัดใหม่ (เน้นข้อความ) ) 

3.14159

หมายเลขคือ: +3.142 หรือ หมายเลขคือ: +3.142!

อีกตัวอย่างหนึ่งคือภาษา OOP ^{[ 7 ]}

คลาสBASICIO ( LINELENGTH ) ; จำนวนเต็มLINELENGTH ; begin ref ( infile ) SYSIN ; ref ( infile ) procedure sysin ; sysin :- SYSIN ; ref ( printfile ) SYSOUT ; ref ( printfile ) procedure sysout ; sysout :- SYSOUT ;คลาสFILE ....................; คลาสFILE infile ............; คลาสFILE outfile ...........; คลาสFILE directfile ........; คลาสFILE printfile .......;SYSIN :- new infile ( " SYSIN " ) ; SYSOUT :- new printfle ( " SYSOUT " ) ; SYSIN . open ( blanks ( 80 )) ; SYSOUT . open ( blanks ( LINELENGTH )) ; inner ; SYSIN . close ; SYSOUT . close ; end BASICIO ;

ในภาษาการเขียนโปรแกรม Cสตรีมอินพุต เอาต์พุต และข้อผิดพลาดมาตรฐานจะแนบกับตัวอธิบายไฟล์ Unix ที่มีอยู่ 0, 1 และ 2 ตามลำดับ^{[ 8 ]}ในสภาพแวดล้อมPOSIX ควรใช้ คำจำกัดความ< unistd.h > STDIN_FILENO , STDOUT_FILENOหรือSTDERR_FILENOแทนหมายเลขวิเศษตัวชี้ไฟล์stdin , stdoutและstderrก็มีให้เช่นกัน

Ken Thompson (นักออกแบบและผู้พัฒนาระบบปฏิบัติการ Unix ดั้งเดิม) ได้แก้ไขการเรียงลำดับในUnix เวอร์ชัน 5ให้ยอมรับ "-" เป็นอินพุตมาตรฐาน ซึ่งแพร่กระจายไปยังยูทิลิตี้อื่นๆ และกลายเป็นส่วนหนึ่งของระบบปฏิบัติการในรูปแบบไฟล์พิเศษในเวอร์ชัน 8การวินิจฉัยเป็นส่วนหนึ่งของเอาต์พุตมาตรฐานจนถึงเวอร์ชัน 6หลังจากนั้นDennis M. Ritchieได้สร้างแนวคิดของข้อผิดพลาดมาตรฐาน^{[ 9 ]}

ในC++การเขียนไปยังสตรีมมาตรฐานเดิมทีทำโดยใช้<iostream>ส่วนหัวและสตรีมของมัน จนกระทั่งมีการเผยแพร่<print>ซึ่งทำให้การรับ/ส่งข้อมูลง่ายขึ้นโดยใช้ฟังก์ชันการพิมพ์^{[ 10 ]} C++ สืบทอดสิ่งอำนวยความสะดวก CI/Oแต่ถือว่าการใช้สิ่งอำนวยความสะดวก C++ รุ่นใหม่กว่านั้นเป็นไปตามแบบฉบับมากกว่า^{[ 11 ]}

#include <iostream> #include <string>using std :: cerr ; using std :: cin ; using std :: cout ; using std :: endl ; using std :: string ;int main () { string input ; cout << " เขียนประโยค: " << endl ; cin >> input ; int inputLength = input.length (); cout << "ประโยค: " << input << ", ความยาว: " << inputLength << endl ; cerr << "เขียนประโยค ไปยัง stderr: " << input << endl ; }

ในJavaสตรีมมาตรฐานจะถูกอ้างอิงโดยSystem.in(สำหรับ stdin), System.out(สำหรับ stdout) และ System.err(สำหรับ stderr) ^{[ 12 ]}นอกจากนี้ยังสามารถอ่านจากสตรีมอินพุตใดๆ โดยใช้Scanner.

แพ็คเกจorg.wikipedia.examples ;import java.io.BufferedReader ; import java.io.IOException ; import java.io.InputStreamReader ;public class Example { public static void main ( String args [] ) { try { BufferedReader br = new BufferedReader ( new InputStreamReader ( System . in )); String s = br . readLine (); double number = Double . parseDouble ( s ); System . out . printf ( "Number is: %d%n" , number );// อ่านข้อมูลชื่อและอายุ: Scanner input = new Scanner ( System.in ) ; System.out.printf ( "%nป้อนชื่อ: " ) ; String name = input.nextLine ( ) ; System.out.printf ( " % n ป้อนอายุ: " ) ; int age = input.nextInt ( ) ; System.out.printf ( "สวัสดี, %s! คุณอายุ %d ปี." , name , age ) ; } catch ( IOException e ) { System.err.printf ( " เกิดข้อผิดพลาด ใน การ รับ/ ส่งข้อมูล: %s%n" , e.getMessage ( ) ) ; } catch ( Exception e ) { System.err.printf ( " เกิดข้อผิด พลาด: %s%n" , e.getMessage ( ) ) ; } } }

ในC#และ ภาษา .NET อื่นๆ สตรีมมาตรฐานจะถูกอ้างอิงโดยSystem.Console.In(สำหรับ stdin), System.Console.Out(สำหรับ stdout) และSystem.Console.Error(สำหรับ stderr) ^{[ 13 ]}ความสามารถในการอ่านและเขียนพื้นฐานสำหรับสตรีม stdin และ stdout สามารถเข้าถึงได้โดยตรงผ่านคลาสSystem.Console(เช่นSystem.Console.WriteLine()สามารถใช้แทนSystem.Console.Out.WriteLine())

System.Console.Inและเป็น อ็อบเจ็กต์ (stdin) และSystem.Console.Out( stdout, stderr) ตามลำดับ ซึ่งอนุญาตให้เข้าถึงสตรีมมาตรฐานพื้นฐานในรูปแบบข้อความเท่านั้น การเข้าถึงแบบไบนารีเต็มรูปแบบไปยังสตรีมมาตรฐานจะต้องดำเนินการผ่านอ็อบเจ็กต์ที่ส่งคืนโดยและตามลำดับ System.Console.ErrorSystem.IO.TextReaderSystem.IO.TextWriterSystem.IO.StreamSystem.Console.OpenStandardInput()System.Console.OpenStandardOutput()System.Console.OpenStandardError()

เนมสเปซวิกิพีเดีย. ตัวอย่าง ;โดยใช้ระบบ;public class Example { static int Main ( string [] args ) { try { string s = Console . In . ReadLine (); double number = Double . Parse ( s ); Console . Out . WriteLine ( "Number is: {0:F3}" , number ); } // If Parse() threw an exception catch ( ArgumentNullException e ) { Console . Error . WriteLine ( $"No number was entered: {e.Message}" ); return 1 ; } catch ( FormatException e ) { Console . Error . WriteLine ( $"The specified value is not a valid number: {e.Message}" ); return 2 ; } catch ( OverflowException e ) { Console . Error . WriteLine ( $"The specified number is too big: {e.Message}" ); return 3 ; } catch ( Exception ex ) { Console . Error . WriteLine ( $"เกิดข้อผิดพลาดที่ไม่ทราบสาเหตุ: {e.Message}" ); return - 1 ; } return 0 ; }

ตัวอย่าง Visual Basic .NETฟังก์ชันสาธารณะMain ( ) As Integer Try Dim s As String = System.Console . [ In ] .ReadLine ( ) Dim number As Double = Double.Parse ( s ) System.Console.Out.WriteLine ( " Number is : { 0 : F3 } " , number ) Return 0' หาก Parse( ) เกิดข้อผิดพลาดCatch ex เป็นSystem.ArgumentNullException System.Console . [ Error ] .WriteLine ( " ไม่ ได้ป้อนตัวเลข!" ) Catch ex2 เป็นSystem.FormatException System.Console . [ Error ] .WriteLine ( " ค่าที่ระบุไม่ใช่ตัวเลขที่ถูกต้อง!" ) Catch ex3 เป็นSystem.OverflowException System.Console . [ Error ] .WriteLine ( " ตัวเลขที่ระบุมีขนาดใหญ่เกินไป! " ) End Tryส่งกลับ- 1 สิ้นสุดฟังก์ชัน

เมื่อใช้งานSystem.Diagnostics.Processคลาสนี้ เราสามารถใช้คุณสมบัติStandardInput ของอินสแตนซ์ , StandardOutput, และStandardErrorของคลาสนั้นเพื่อเข้าถึงสตรีมมาตรฐานของกระบวนการได้

ตัวอย่างต่อไปนี้ ซึ่งเขียนด้วยภาษา Pythonแสดงวิธีการเปลี่ยนเส้นทางการรับข้อมูลมาตรฐานไปยังทั้งการส่งออกข้อมูลมาตรฐานและไปยังไฟล์ข้อความ

#!/usr/bin/env pythonนำเข้าซิสจากการพิมพ์นำเข้าTextIOถ้า__name__ == "__main__" :# บันทึกค่า stdout ปัจจุบันไว้ เพื่อที่เราจะสามารถคืนค่า sys.stdout กลับไปได้# หลังจากที่เราทำการเปลี่ยนเส้นทางเสร็จสิ้นแล้วstdin_fileno : TextIO = sys​ มาตรฐานstdout_fileno : TextIO = sys . stdout# เปลี่ยนเส้นทางเอาต์พุต sys.stdout ไปยังไฟล์sys.stdout : TextIO = open ( "myfile.txt" , " w " )ctr : int = 0สำหรับinps ในstdin_fileno :ctrs : str = str ( ctr )# พิมพ์ไปยัง stdout ที่ถูกเปลี่ยนเส้นทาง ()sys.stdout.write ( f " { ctrs } ) this is to the redirected --- > { inps } \ n " )# พิมพ์ไปยังตัวจัดการ stdout ที่บันทึกไว้จริงstdout_fileno.write ( f " { ctrs } ) this is to the actual ---> { inps } \ n " )ctr = ctr + 1# ปิดไฟล์sys.stdout.close ( )​​​# คืนค่า sys.stdout กลับไปยังตัวจัดการไฟล์ที่บันทึกไว้เดิมของเราsys.stdout = stdout_fileno​​

ในC++23อินเทอร์เฟซการพิมพ์ที่ได้รับการปรับปรุงถูกสร้างขึ้นเพื่อเขียนไปยังสตรีมเอาต์พุตโดยใช้std::printฟังก์ชัน^{[ 14 ]}

import std ;โดยใช้std :: string ;int main () { string s = "Hello, world!" ; std :: println ( stdout , "My string: {}" , s ); std :: println ( stderr , "String to error stream: {}" , s ); }

ส่วนต่อประสานผู้ใช้แบบกราฟิก (GUI) ไม่ได้ใช้สตรีมมาตรฐานเสมอไป แต่จะใช้เมื่อ GUI เป็นตัวห่อหุ้มสคริปต์พื้นฐานและ/หรือโปรแกรมคอนโซล ตัวอย่างเช่น GUI ตัวจัดการแพ็กเกจ Synapticซึ่งห่อหุ้มคำสั่ง apt ใน Debian และ/หรือ Ubuntu GUI ที่สร้างด้วยเครื่องมือสคริปต์เช่น Zenity และ KDialog โดยโครงการKDE ^{[ 15 ]}ใช้ stdin, stdout และ stderr และอิงตามสคริปต์ง่ายๆ แทนที่จะเป็น GUI ที่สมบูรณ์ซึ่งเขียนโปรแกรมและคอมไพล์ใน C/C++ โดยใช้Qt , GTKหรือเฟรมเวิร์กวิดเจ็ตที่เป็นกรรมสิทธิ์อื่นๆ ที่เทียบเท่ากัน

เมนูบริการ (Services menu ) ที่ใช้งานบนNeXTSTEPและMac OS X นั้น คล้ายคลึงกับสตรีมมาตรฐาน (standard streams) บนระบบปฏิบัติการเหล่านี้ แอปพลิเคชันแบบกราฟิกสามารถให้ฟังก์ชันการทำงานผ่านเมนูทั่วทั้งระบบ ซึ่งจะทำงานกับ ตัวเลือกปัจจุบันใน GUI ไม่ว่าจะเป็นแอปพลิเคชันใดก็ตาม

โปรแกรม GUI บางโปรแกรม โดยเฉพาะบนระบบ Unix ยังคงเขียนข้อมูลการดีบักไปยังช่องข้อผิดพลาดมาตรฐาน ส่วนโปรแกรมอื่นๆ (เช่น โปรแกรมเล่นสื่อบน Unix หลายโปรแกรม) อาจอ่านไฟล์จากช่องอินพุตมาตรฐาน โปรแกรม Windows ยอดนิยมที่เปิดหน้าต่างคอนโซลแยกต่างหากนอกเหนือจากหน้าต่าง GUI คือโปรแกรมจำลอง pSXและDOSBox

GTK-serverสามารถใช้ stdin เป็นอินเทอร์เฟซการสื่อสารกับโปรแกรมที่แปลความหมายเพื่อสร้าง GUI ได้

รูปแบบ การจัดการอินเทอร์เฟซของ Common Lispนั้น"นำเสนอ" องค์ประกอบ GUI ที่ส่งไปยังสตรีมเอาต์พุตแบบขยาย

• การเปลี่ยนเส้นทาง
• ลำธาร
• อินพุต/เอาต์พุต
• การรับ/ส่งข้อมูลไฟล์ C
• ไซซินและไซเอาท์
• สตรีมมาตรฐานในระบบไฟล์ Files-11

• คำจำกัดความของอินพุตมาตรฐาน - โดยโครงการข้อมูลลินุกซ์
• คำจำกัดความของเอาต์พุตมาตรฐาน - โดยโครงการข้อมูลลินุกซ์
• คำจำกัดความข้อผิดพลาดมาตรฐาน - โดยโครงการข้อมูลลินุกซ์