Standaard kanalen

In de informatica vertegenwoordigen de standaardkanalen (of standaardstromen ), in alle moderne besturingssystemen , de logische invoer- en uitvoerapparaten die een programma verbinden met de besturingsomgeving waarin het wordt uitgevoerd (meestal een tekstterminal ) en die automatisch worden verbonden wanneer het wordt gestart .

Deze vooraf gedefinieerde kanalen zijn beschikbaar in Unix- en Unix-achtige besturingssystemen , C- en C++- taaluitvoeringsomgevingen en hun afgeleiden.

De drie standaard input/output kanalen worden standaard input , standaard output en standaard error genoemd (soms afgekort tot respectievelijk stdin , stdout en stderr ).

Geschiedenis

In de meeste pre-Unix-besturingssystemen moesten programma's expliciet koppelingen maken naar invoer- en uitvoergegevens. Voor veel van deze systemen kan dit een echte uitdaging voor programmeervaardigheden zijn , vanwege de complexiteit van de technische details die nodig zijn om bijvoorbeeld de configuratie van de uitvoeringsomgeving te verkrijgen, of om toegang te krijgen tot een tabel met lokale bestanden , of om de set te bepalen van gegevens voor het bedienen en afzonderlijk beheren van specifieke koffers voor kaarten en ponsbanden, magneetbanden, schijven, printers en interactieve terminals.

Unix was de bron van radicale innovaties, waaronder de abstractie van input/output-randapparatuur: dit bevrijdde programma's van de last om het type randapparatuur waarmee ze communiceerden te moeten kennen of beheren. Bij eerdere besturingssystemen moest de programmeur lees- en schrijfbewerkingen uitvoeren in gegevensblokken, vaak met semantiek voor gegevens en randapparatuur die niet orthogonaal waren. Unix elimineerde deze complexiteit door het concept van gegevensstroom te introduceren , dat wil zeggen geordende reeksen bytes die konden worden gelezen totdat ze waren uitgeput. Een programma had ook de mogelijkheid om willekeurige hoeveelheden data te schrijven, zonder vooraf de totale grootte en hoe ze te groeperen hoefden te vermelden.

Een andere Unix-innovatie was die van het automatisch beschikbaar stellen van vooraf gedefinieerde invoer- en uitvoerkanalen: in het typische geval van een programma dat invoergegevens verwerft en verwerkt om vervolgens de uitvoerresultaten te produceren, hoeft het programma (en de programmeur) niets te doen om bereid de invoer- en uitvoerkanalen voor; de voorlopers van de besturingssystemen van Unix daarentegen vereisten meestal de voorbereiding van instructies - vaak complexe - uitgedrukt in Job Control Language , of belastten het programma in ieder geval met een gelijkwaardige last.

Aangezien Unix de standaardkanalen leverde, moesten de C- taaluitvoeringsomgevingen hiervoor ondersteuning bieden, met als resultaat dat de meeste van hen (en afstammelingen van de C-taal) tegenwoordig gelijkwaardige functionaliteit bieden, ongeacht het besturingssysteem.

Beschrijving

Standaard invoer (stdin)

De standaardinvoer is een kanaal van waaruit een stroom gegevens (vaak tekstueel) een programma binnenkomt. Het programma draagt ze over door leesbewerkingen uit te voeren . Niet alle programma's hebben invoergegevens nodig: de ls o -opdrachten dir(die de inhoud van mappen tonen ) voeren bijvoorbeeld hun taak uit zonder dat invoergegevens hoeven te worden gelezen.

De invoerstroom, behalve in gevallen van omleiding , komt van de terminal (bijv. door de gebruiker via toetsenbord ) van waaruit het programma is gestart.

De bestandsdescriptor die bij standaardinvoer hoort, is die met index 0; de corresponderende C-taalvariabele, gedefinieerd in <stdio.h> , is FILE* stdin; op dezelfde manier is de C ++ -taalvariabele gedefinieerd in <iostream>std::cin .

Standaard output (stdout)

Standaarduitvoer is het kanaal waarop een programma zijn uitvoergegevens schrijft . Het programma draagt gegevens over door schrijfbewerkingen uit te voeren . Niet alle programma's produceren uitvoer: bijvoorbeeld het mv -commando (dat de naam van een bestand of map wijzigt) produceert normaal gesproken geen uitvoergegevens.

De uitvoerstroom, behalve in gevallen van omleiding , wordt naar de terminal geleid van waaruit het programma is gestart (bijvoorbeeld om te monitoren of te consolen in het voordeel van de gebruiker).

De bestandsdescriptor die is gekoppeld aan standaarduitvoer is die met index 1; de corresponderende C-taalvariabele, gedefinieerd in <stdio.h> , is FILE* stdout; op dezelfde manier is de C ++ -taalvariabele, gedefinieerd in <iostream> , std::cout.

Standaardfout (stderr)

Standaardfout is een ander uitgangskanaal dat doorgaans door programma's wordt gebruikt voor fout- of diagnostische berichten . Het is een onafhankelijk kanaal van de standaarduitvoer en kan afzonderlijk van de andere worden omgeleid . De bestemming is meestal de terminal van waaruit het programma is gestart, om de kans om gezien te worden zo groot mogelijk te maken, zelfs wanneer de standaarduitvoer ergens anders is gericht: bijvoorbeeld in het geval van een softwarepijplijn , de uitvoer van een programma dat het wordt geleverd als invoer voor het volgende programma, maar de foutmeldingen worden nog steeds weergegeven op de terminal.

Het is acceptabel en normaal dat standaarduitvoer en standaardfout dezelfde bestemming hebben, zoals in het geval van de tekstterminal: berichten verschijnen in dezelfde volgorde waarin het programma ze schrijft, behalve wanneer buffers in gebruik zijn (bijvoorbeeld wanneer de standaardfout heeft geen buffer en de standaarduitvoer heeft een lijnbuffer : in dit geval kunnen de gegevens die op een later tijdstip naar de standaardfout zijn geschreven , verschijnen voordat de gegevens die eerst naar de standaarduitvoer zijn geschreven , omdat de standaarduitvoerbuffer dat misschien nog niet heeft gevuld).

De bestandsdescriptor die bij de standaardfout hoort, is die met index 2; de corresponderende C-taalvariabele, gedefinieerd in <stdio.h> , is FILE* stderr; in C++-taal definieert <iostream> twee variabelen die bij dit kanaal horen: std::cerren std::clog, waarvan de eerste geen buffer heeft terwijl de tweede buffers gebruikt die vergelijkbaar zijn met de andere C++-kanalen.

Met de meeste tekstshells kun je standaarduitvoer en standaardfout omleiden naar hetzelfde bestand met de syntaxis

> & bestandsnaam

equivalent van:

&> bestandsnaam

Met de Bourne-shell en zijn afgeleiden kunt u de standaardfout naar dezelfde bestemming sturen als de standaarduitvoer met de syntaxis

2> & 1

Geschiedenis

1950s : Fortran

Fortran leverde het equivalent van Unix -bestandsdescriptors , voor standaardinvoer en voor standaarduitvoer . UNIT=5UNIT=6

! FORTRAN 77 voorbeeld 
      PROGRAMMA HOOFDLEES 
      ( EENHEID = 5 , * ) NUMMER SCHRIJVEN ( EENHEID = 6 , '(F5.3)' ) ' NUMMER IS:' , NUMMER EINDE

1960 : ALGOL 60

ALGOL 60 werd bekritiseerd omdat het geen standaard mechanisme voor bestandstoegang bood .

1968 : ALGOL 68

De term transput verwijst in het algemeen naar de input- en outputfuncties van de ALGOL 68 . Koster coördineerde de definitie van de transputstandaard . Deze standaard omvatte : stand in,, stand outen stand error.stand back

Voorbeeld:

# ALGOL 68 voorbeeld #
hoofd :(
  Echt nummer;
  getf (binnenkomen, ($ g $, aantal));
  printf (($ "Nummer is:" g (6,4) "OF" $, nummer)); # OF #
  putf (opvallen, ($ "Nummer is:" g (6,4) "!" $, aantal));
  nieuwe regel (opvallen)
)

Invoer:	Uitgang:
3.14159	Nummer is: +3.142 OF Nummer is: +3.142!

Jaren 70 : C en Unix

In de C-taal werden kanalen stdinen stdoutrespectievelijk stderrgeassocieerd met Unix -bestandsdescriptors 0, 1 en 2.

1980s : C ++

In C++ werden standaardkanalen geassocieerd met respectievelijk objecten cinen . coutcerr

1990s : Java

In Java en in de talen die bij dit platform horen, verwijzen de standaardkanalen naar: System.in(voor stdin), System.out(voor stdout) en System.err(voor stderr). Als voorbeeld kunt u het BufferedReader-object van de klasse gebruiken BufferedReader :

public  static  void  main ( Stream  args [] )  { 
    probeer  { 
        BufferedReader  br  =  
          nieuwe  BufferedReader ( nieuwe  InputStreamReader ( System . in )); 
        Tekenreeks  s  =  br . leesregel (); 
        dubbel  nummer  =  dubbel . ontledenDouble ( s ); 
        Systeem . uit . println ( "Nummer is:"  +  nummer ); 
    }  catch  ( Uitzondering  e )  { 
        Systeem . fout . println ( "Fout:"  +  bijv . getMessage ()); 
    } 
}

Of u kunt de class gebruiken Scannerdie bij het pakket java.util hoort

    public  static  void  main ( String []  args )  { 
        Scanner  sc  =  nieuwe  scanner ( Systeem . in ); 
        while ( sc . hasNextLine ())  { 
            String  line  =  sc . volgende regel (); 
            dubbel  nummer  =  dubbel . parseDouble ( regel ); 
            Systeem . uit . println ( "Nummer is:"  +  nummer ); 
        } 
    }

2000s : .NET

In C sharp en andere talen van het .NET Framework werden standaardkanalen toegankelijk via System.Console(voor standaardinvoer en standaarduitvoer ) en System.Console.Error(voor standaardfout )

// C # voorbeeld 
public  static  int  Main () 
{ 
    double  number ; 
    tekenreeks  s ;

    probeer 
    { 
        s  =  Systeem . console . Leesregel (); 
        getal  =  dubbel . Ontleden ( s ); 
        Systeem . console . WriteLine ( "Nummer is: {0: F3}" ,  getal ); 
        retourneer  0 ; 
    } 
    catch  ( Systeem . FormatException  e ) 
    { 
        // if Parse() gooide een uitzondering 
        System . console . Fout . WriteLine ( "Er is geen nummer ingevoerd!" ); 
        retour  1 ; 
    } 
}

'Visual Basic .NET voorbeeld'

Publieke  functie  Main ()  As  Integer 
    Dim -  nummer  As  Double 
    Dim  s  As  String

    Probeer 
        s  =  Systeem . console . ReadLine () 
        nummer  =  CDbl ( ' s ) 
        Systeem . console . WriteLine ( "Nummer is: {0: F3}" ,  getal ) 
        Return  0 
    Catch  en  As  System . InvalidCastException 
        'if Parse () gooide een uitzondering 
        System . console . Fout . WriteLine ( "Er is geen nummer ingevoerd!" ) 
        Return  1 
    End  Try 
End  Functie

GUI

Grafische interfaces maken zelden gebruik van standaardkanalen, en bijgevolg zijn omleiding en softwarepijplijnen noch praktisch noch nuttig. De acties van knippen , kopiëren en plakken tussen verschillende toepassingen zijn waarschijnlijk wat het concept van standaardkanalen het beste benadert, maar aangezien ze handmatig moeten worden gedaan, is het niet bijzonder efficiënt om een groot aantal ervan uit te voeren. Een uitzondering op het bovenstaande kan de Dynamic window manager zijn, die statusberichten leest die moeten worden weergegeven vanuit de standaard invoer .

Sommige GUI-programma's, meestal op Unix- en Unix-achtige systemen , gebruiken nog steeds de standaardfout om hun diagnostische berichten te schrijven.

Bibliografie

KRONOS 2.1 Referentiehandleiding , Control Data Corporation, onderdeelnummer 60407000, 1974
NOS Versie 1 Toepassingen Programmer's Instant , Control Data Corporation, Onderdeelnummer 60436000, 1978
Niveau 68 Inleiding tot programmeren op MULTICS , Honeywell Corporation, 1981
Evolutie van het MVS-besturingssysteem , IBM Corporation, 1981
Lions' commentaar op UNIX Sixth Edition , John Lions, ISBN 1-57398-013-7 , 1977
Consoleklasse, .NET Framework-klassebibliotheek , Microsoft Corporation, 2008

Gerelateerde items

Externe links

( EN ) Standaard uitvoerdefinitie - door The Linux Information Project (LINFO)