Est-ce que System.out, stdout et cout sont exactement la même chose?

Question

System.out, stdout et cout sont-ils exactement la même chose en Java, C et C++ respectivement? Pourquoi avoir trois noms différents pour la même chose (surtout quand C, C++ et Java ont beaucoup en commun)?

En outre, je sais à quoi ils servent, mais que signifient-ils exactement sous le capot?

Answer 1

cout est essentiellement le même que stdout mais la différence est que cout est de type ostream (ce qui signifie essentiellement que vous pouvez entrer des données formatées en utilisant << ou des données non formatées à la

méthode write.

stdout est fixée à un descripteur de fichier (stdout est un FILE*). descripteur de fichier stdout est 1. Parce qu'il renvoie une référence à un descripteur de fichier, il peut être utilisé dans fputs et fprintf.

Java System.out est essentiellement comme stdout (il utilise java.io.FileDescriptor avec handle 1) et passé en FileOutputStream et finalement enveloppé à l'intérieur BufferedOutputStream.

Voici comment java.lang.System est initialisés:

/** 
    * Initialize the system class. Called after thread initialization. 
    */ 
    private static void initializeSystemClass() { 
    props = new Properties(); 
    initProperties(props); 
    sun.misc.Version.init(); 

     // Workaround until DownloadManager initialization is revisited. 
     // Make JavaLangAccess available early enough for internal 
     // Shutdown hooks to be registered 
     setJavaLangAccess(); 

     // Gets and removes system properties that configure the Integer 
     // cache used to support the object identity semantics of autoboxing. 
     // At this time, the size of the cache may be controlled by the 
     // vm option -XX:AutoBoxCacheMax=<size>. 
     Integer.getAndRemoveCacheProperties(); 

    // Load the zip library now in order to keep java.util.zip.ZipFile 
    // from trying to use itself to load this library later. 
    loadLibrary("zip"); 

    FileInputStream fdIn = new FileInputStream(FileDescriptor.in); 
    FileOutputStream fdOut = new FileOutputStream(FileDescriptor.out); 
    FileOutputStream fdErr = new FileOutputStream(FileDescriptor.err); 
    setIn0(new BufferedInputStream(fdIn)); 
    setOut0(new PrintStream(new BufferedOutputStream(fdOut, 128), true)); 
    setErr0(new PrintStream(new BufferedOutputStream(fdErr, 128), true)); 

    // Setup Java signal handlers for HUP, TERM, and INT (where available). 
     Terminator.setup(); 

     // Initialize any miscellenous operating system settings that need to be 
     // set for the class libraries. Currently this is no-op everywhere except 
     // for Windows where the process-wide error mode is set before the java.io 
     // classes are used. 
     sun.misc.VM.initializeOSEnvironment(); 

    // Set the maximum amount of direct memory. This value is controlled 
    // by the vm option -XX:MaxDirectMemorySize=<size>. This method acts 
    // as an initializer only if it is called before sun.misc.VM.booted(). 
    sun.misc.VM.maxDirectMemory(); 

    // Set a boolean to determine whether ClassLoader.loadClass accepts 
    // array syntax. This value is controlled by the system property 
    // "sun.lang.ClassLoader.allowArraySyntax". This method acts as 
    // an initializer only if it is called before sun.misc.VM.booted(). 
    sun.misc.VM.allowArraySyntax(); 

    // Subsystems that are invoked during initialization can invoke 
    // sun.misc.VM.isBooted() in order to avoid doing things that should 
    // wait until the application class loader has been set up. 
    sun.misc.VM.booted(); 

     // The main thread is not added to its thread group in the same 
     // way as other threads; we must do it ourselves here. 
     Thread current = Thread.currentThread(); 
     current.getThreadGroup().add(current); 
    } 

FileDescriptor.out est:

/** 
* A handle to the standard output stream. Usually, this file 
* descriptor is not used directly, but rather via the output stream 
* known as <code>System.out</code>. 
* @see  java.lang.System#out 
*/ 
public static final FileDescriptor out = standardStream(1); 

Source:

• cout
• stdout
• Wikipedia sur System.out, cout et stdout

Answer 2

Ce sont la même chose, mais ils n'ont pas le même type. Par exemple, stdout est un FILE* et cout est un std::ostream. Puisque C++ supporte les deux, différents noms sont nécessaires. Sous le capot, toutes ces variables font référence à la sortie standard du processus appelant. C'est l'un des trois descripteurs de fichier (stdin, stdout, stderr) qui sont toujours ouverts par le système d'exploitation lorsqu'il génère un nouveau processus. Tout ce qui est écrit dans ce descripteur de fichier se retrouve à l'écran ou à l'endroit où stdout a été redirigé (en utilisant les opérateurs shell > ou >>).

Answer 3

En théorie, ils sont la même chose, tous envoyés à la sortie standard. Mais en C et C++, cout se construit au-dessus de stdout pour ajouter certaines fonctionnalités que System.out fournit comme formatage. Puisque java n'a pas de concept de pointeurs, System, out a été repensé pour utiliser PrintStream pour faire le même type de tâche que cout.PritnStream fournit des fonctionnalités supplémentaires, par exemple, PrintStream ne lance pas d'exception IOException mais définit à la place un indicateur d'erreur interne auquel il est possible d'accéder en utilisant checkError. Je pense que les conventions de nommage ont été suivies parce que les concepteurs de chaque langue étaient différents. C, C++ est étroitement associé à Unix et donc ils ont utilisé des termes comme la sortie standard et la console, etc. Java a été conçu pour être plus orienté objet, et donc le créateur de Java a décidé de le nommer un peu différent.

Answer 4

Ce sont des méthodes spécifiques à chaque langue pour écrire dans le fichier "sortie standard" du programme, un concept qui provient de C/UNIX. Ils diffèrent par les fonctions/méthodes exactes qu'ils fournissent pour effectuer la sortie.

Il est également intéressant de mentionner que les deux cout et stdout sont disponibles en C++, car il essaie à mi-chemin d'être un surensemble du langage C, mais le mélange de l'utilisation des deux peut être une mauvaise idée, sauf si vous désactivez le tampon entièrement à la fois . Je ne suis au courant d'aucune exigence pour les deux de partager un tampon, il est donc possible que la sortie sortira mal ordonnée si vous les mélangez.