Tamponné et non de flux

Votre livre ne semble pas très utile.

1) Les flux de sortie de leur envoyer des octets à un std::streambuf, ce qui peut
contenir un tampon; la std::filebuf (dérivé de streambuf) utilisé par
et std::ofstream seront généralement mis en mémoire tampon. Cela signifie que lorsque l'
la sortie d'un personnage, il n'est pas nécessairement la sortie immédiatement; il
être écrites dans une mémoire tampon, et la sortie pour le système d'exploitation uniquement lorsque la mémoire tampon est
complet, ou vous demande explicite d'une certaine façon, généralement par l'appelant
flush() sur le flux (directement, ou indirectement, par l'utilisation de std::endl).
Cela peut varier, cependant, la sortie de std::cout est synchronisé avec
stdout, et la plupart des implémentations plus ou moins à suivre les règles de
stdout pour std::cout, la modification de la stratégie de mise en mémoire tampon si la sortie
va un dispositif interactif.

En tout cas, si vous n'êtes pas sûr, et vous voulez être sûr que la sortie
vraiment laisser votre programme, il suffit d'ajouter un appel à la chasse.

2) Votre livre est mauvais ici.

L'une des stratégies de mise en mémoire tampon est unitbuf; c'est un indicateur dans l'
std::ostream que vous pouvez définir ou réinitialiser (std::ios_base::set() et
std::ios_base::unset()—std::ios_base est une classe de base de
std::ostream, de sorte que vous pouvez appeler ces fonctions sur un std::ostream
de l'objet). Lorsque unitbuf est définie, std::ostream ajoute un appel à flush()
à la fin de chaque sortie de la fonction, de sorte que lorsque vous écrivez:

std::cerr << "hello, world";

le flux sera rincé après tous des caractères de la chaîne
sont de sortie, à condition unitbuf est réglé. Sur les start-up, unitbuf est réglé
pour std::cerr; par défaut, il n'est pas fixé sur n'importe quel autre fichier. Mais vous
sont libres de définir ou désactiver comme vous le souhaitez. Je déconseille
décharger sur std::cerr, mais si std::cout est sortie à un
dispositif interactif, il fait beaucoup de sens pour définir s'il en existe.

Noter que tout ce qui est en question ici est la mémoire tampon dans le streambuf.
Généralement, le système d'exploitation également des tampons. Tous rinçage de la mémoire tampon n'est
transférer les caractères de l'OS, ce qui signifie que vous ne pouvez pas utiliser
ofstream directement lors de l'intégrité transactionnelle est nécessaire.

3) Lors de la saisie d'une chaîne de caractères ou un tampon de caractères à l'aide de >>, l'
std::istream premier saute menant espace blanc, puis les entrées jusqu'à
mais pas y compris le prochain espace blanc. Dans les termes formels de la
la norme, c' "extraits" les caractères à partir du flux, de sorte qu'ils
ne sera pas vu de nouveau (à moins que vous chercher, si le flux de données prend en charge).
La prochaine entrée de ramassage à l'endroit où le précédent arrêté. Si
les caractères suivants sont dans une mémoire tampon, ou encore sur le disque, c'est vraiment
hors de propos.

Noter que la mise en mémoire tampon d'entrée est un peu complexe, en ce qu'il se produit
à différents niveaux, et au niveau de l'OS, il prend différentes
les formes en fonction de l'appareil. Généralement, le système d'exploitation de la mémoire tampon d'un fichier par
secteurs, souvent la lecture de plusieurs secteurs à l'avance. L'OS sera toujours
retour autant de caractères comme l'ont exigé, à moins qu'il rencontre à la fin de
fichier. La plupart des OSs sera un tampon clavier en ligne: pas de retour d'un
demande de lecture jusqu'à ce qu'une ligne complète a été saisi, et de ne jamais revenir
les caractères au-delà de la fin de la ligne courante dans une demande de lecture.

De la même manière que std::ostream utilise un streambuf pour la sortie,
std::istream utilise un seul caractère. Dans le cas
de std::cin, normalement, c'est une filebuf; lorsque le istream
les demandes d'un personnage, le filebuf le retour de sa mémoire tampon si
il en a un; s'il ne le fait pas, il va tenter de remplir la mémoire tampon,
en demandant par exemple 512 (ou quelle que soit sa taille de la mémoire tampon est), les personnages de la
OS. Qui réagira en fonction de sa mise en mémoire tampon de la politique de la
de l'appareil, comme décrit ci-dessus.

En tout cas, si std::cin est connecté au clavier, et vous avez
tapé "hello world", tous les caractères que vous avez saisis seront lus
par le flux de la finalement. (Mais si vous êtes en utilisant >>, il y aura beaucoup
des espaces qui vous de ne pas voir.)

OriginalL'auteur James Kanze

Vous pouvez vérifier les différences de vous-même avec un petit app.

#include <iostream>
int main() {
    std::cout<<"Start";
    //std::cout<<"Start"<<std::endl; //line buffered, endl will flush.
    double j = 2;
    for(int i = 0; i < 100000000; i++){
        j = i / (i+1);
    }
    std::cout<<j;
    return 0;
}

Essayer la différence entre les deux "Démarrer" relevés, puis changer pour la eree. La différence est due à la mise en mémoire tampon.

L'instruction prend environ 2 secondes sur ma plate-forme, vous pourriez avoir besoin de modifier l'i < condition sur le vôtre.

OriginalL'auteur Captain Giraffe

1. Chaque appel d'écriture vers le terminal est lent, de sorte à éviter de faire ralentir les choses, souvent, les données sont stockées dans la mémoire jusqu'à ce qu'une certaine quantité de données a été saisi ou le tampon est vidé manuellement avec fflush ou std::endl. Le résultat de ceci est parfois que le texte ne pourrait pas être écrit dans le terminal au moment où vous l'attendez.

2. Depuis le moment de messages d'erreur est plus importante que la normale de sortie, le gain de performance est ignoré et les données ne sont pas mises en mémoire tampon. Cependant, depuis une chaîne est passée en un seul morceau de données, il est écrit dans un appel (à l'intérieur d'une boucle quelque part).

3. Il monde serait toujours dans la mémoire tampon, mais il est assez facile de le prouver par vous-même en train de l'essayer dans un 3 ligne de programme. Cependant, votre exemple échoue puisque vous êtes une tentative d'écriture dans la mémoire non allouée. Vous devriez être en prenant d'entrée dans un std::string à la place.

OriginalL'auteur Catskul