Discussion :

[dfshr8]

Bonjour,


Je ne comprends pas bien ce qu'est la "standard library".

1) Apperement on recommende de toujurs écrire std::cout, au lieux de mettre en début: include namespace.... Si j'ai bien compris cout est un objet de la librairie standard que l'on peut utiliser seuleement grçace au fichier d'entête iostream. Dans le cas où l'utilisateur défiit lui même une fonction/objet cout (donc un homonyme), on doit préciser si n utilise celui de iostream ou celui de l'utilisateur (d'où le besoin de préciser std (celui définit par la librairie standard). Ai je bien compris ?

2)Je ne comprens pas les chevrns << après cout. Il semble qu'il s'agisse d'"opérateurs" ( unpeu comme l' addition + qui est un "opérateur binaire" puisqu'il agit sur deux variables). std::cout << signifie t il que << est un opérateur unaire qui agit à droite de l'objet cout (qui est donc l'opérande)?

3) Si je retourne 1 au lieu de 0 dans le main est ce un soucis ? car c'est bin un entier donc ça semble logique aussi

4)Qu 'est ce que le "core language" ? d'aprèsle bouquin que je suis (accelerated c++, que je complète ave c++ for mathematicians et c++ par la pratique, j'espère que ce sont de bonnes réferences) il est mentionnée que le "core language est disponible sur tous les programme c++". Je ne comprends pas bien ce que ca signifie...

[dfshr8]

5) Apperement on distingue:
- les "expressions" comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

cout<<"g"<< endl

qui 'compute' quelquechose (un résultat et peuvent avoir un "side effect" à l' écran). Apperement c'est composé d'opérateurs (opérateurs mathématiques usuels, chevrons <<,...) [on pourrait les remplacer par des fonctions], et opérandes (variables x,donnée comme le chiffre 1, objet) .
Tous les opérandes ont un type: l'objet cout est de type ostream, 1 est de type int.... Un type

[ternel]

Bonnes questions.

C++ est un langage.

Comme tout langage il requiert un vocabulaire minimal (que j'appelle primitif), c'est l'ensemble des mots-clés, des types primitifs et des opérateurs agissant sur ceux-ci.
La norme (qui est aussi un traité ) définit la syntaxe et la grammaire de ce langage.
Le langage fournit ainsi plusieurs moyens pour étendre le vocabulaire.

La norme prévoit aussi un vocabulaire de base, qui est la bibliothèque standard. (et pas librairie)
Il s'agit d'un ensemble de choses définies au moyen du langage.
Par exemple, le code de std::string est intégralement disponible dans <string> (et ses inclusions).



Le namespace est un outil qui permet de regrouper diverses choses sous un certain préfixe.
Comme tu l'as assez bien décrit, std::cout est une variable (cout) déclarée dans le namespace std.

using permet d'importer des noms dans un namespace commun (au domaine d'origine du nom et le domaine courant).

1) ton analyse est la bonne, les espaces de noms permettent de limiter les cas d'interférence entre les bibliothèques.
Concernant la recommandation, la posture normale est:
Aucun using namespace dans un en-tête (un header, .h ou .hpp)
Cela, parce que ce using sera inclus sans le savoir par tout code qui utiliserait l'en-tête.

Par contre, un using sur un type particulier (comme using std::vector) peut apparaître dans la déclaration d'une classe.

Pour les fichiers d'implémentation, c'est à toi de voir.
Dans l'implémentation d'un vecteur (au sens mathématique), je n'utiliserais certainement pas using std::vector, mais dans d'autre cas, pourquoi pas.

2) << est initialement un opérateur binaire, qui calcule un décalage à gauche (left shift).
Ainsi, 2 << 3 vaut 16, car 2 s'écrit 0000000010 et qu'en décalant les bits de 3 vers la gauche, on obtient 0000010000.

Le modèle de classe std::basic_ostream<...> (dont hérite la classe dont std::cout est un objet) surcharge cet opérateur.
Ainsi, std::basic_ostream<...>::operator<<(double) est une fonction membre.

L'un des moyens d'étendre le vocabulaire du C++ est justement de surcharger les opérateurs pour certaines classes.
Par exemple, les classes std::vector et std::map surchargent l'opérateur [] (chacune à sa façon).

3) la valeur de retour de main est (ou n'est pas, la norme ne l'impose pas) utilisé comme code d'exécution du programme.
Comme a priori il n'y a qu'une manière de réussir et plein de se tromper, la coutume veut qu'on utilise 0 pour la réussite du programme et tous les autres entiers pour les erreurs.
Ca n'empêche pas que ton programme fait bien ce qu'il veut avant de retourner.

Concrêtement, pour le C++, tu peux retourner la valeur qu'il te plait.
Voire même, il est possible pour la fonction main (et uniquement celle-ci) de ne pas faire de return explicitement, car il sera ajouté en cas de besoin par la compilation.
Dans ce cas particulier, je ne sais plus ce que C++ demande ou suggère comme valeur. J'imagine cependant que ce sera 0.

4) Le "core language" ou "langage pur", c'est le langage sans sa bibliothèque standard.
Il s'agit du vocabulaire primitif et de la grammaire.
Pour résumer succintement, c'est ce qui est disponible sans utiliser #include.


5) une instruction est exécutée. une expression est une opération produisant une valeur.
Il existe trois grands genres d'instructions:
les déclarations: un type, un nom et éventuellement une valeur (int a = 2; ou int f(int i) {return 2*i})
les instructions-expressions: c'est à dire une expression suivie d'un point-virgule.
les instructions de controle comme if ou while.

[dfshr8]

Merci pour ces réponses précises et très instructives.
6) Je ne coprends pas bien cette portion de cour:
"The input operation has another side effect: It causes our prompt, which asks for the user's
name, to appear on the computer's output device. In general, the input-output library saves
its output in an internal data structure called a buffer, which it uses to optimize output
operations. Most systems take a significant amount of time to write characters to an output
device, regardless of how many characters there are to write. To avoid the overhead of
writing in response to each output request, the library uses the buffer to accumulate the
characters to be written, and flushes the buffer, by writing its contents to the output
device, only when necessary. By doing so, it can combine several output operations into a
single write."

[Bousk]

En gros y'a un buffer interne pour pas avoir à faire un flush à chaque fois vers la sortie, opération longue. Et tu flush tout une fois à la fin.

[ternel]

Voici une version imagée:
Le processeur est à quelques centimètres de la RAM.
Le processeur est à environ un mètre de l'utilisateur (plus, en longueur de fil).
Il est donc a priori cent fois plus rapide d'accéder à un bloc mémoire qu'à l'utilisateur.

Partant de ce constat, les affichages et saisies sont faites au travers d'un bloc mémoire interne (un buffer) de la manière suivante:

• En sortie: On écrit quand on veut, l'OS l'affiche quand il peut, et quand on l'exige, on peut s'arreter pour attendre que l'ordinateur l'affiche (flush the buffer)
• En lecture: L'utilisateur quand il veut, l'OS nous le transmet quand il le veut, nous, on l'attendra.

C'est très imagé, à moitié faux, mais ca explique le problème.
En réalité, le problème, c'est de convertir un caractère en pixels à l'écran.
Et c'est d'autant plus difficile que l'interface graphique est puissante.

[dfshr8]

Je suis désolé mais j'ai du mal à bien comprendre...
Si je combine vos deux répnses (enfin ce que j'en comprends): on veut limiter les "flushs" qui prennent trop de temps. Pour celà on va essayer d'optimiser l'utilisation du buffeur lors des ecritures/lectures.

Pour bien expliquer l' ensemble du prblème voici le paragraphe complet:

"The input operation has another side effect: It causes our prompt, which asks for the user's
name, to appear on the computer's output device. In general, the input-output library saves
its output in an internal data structure called a buffer, which it uses to optimize output
operations. Most systems take a significant amount of time to write characters to an output
device, regardless of how many characters there are to write. To avoid the overhead of
writing in response to each output request, the library uses the buffer to accumulate the
characters to be written, and flushes the buffer, by writing its contents to the output
device, only when necessary. By doing so, it can combine several output operations into a
single write.

There are three events that cause the system to flush the buffer. First, the buffer might be
full, in which case the library will flush it automatically. Second, the library might be asked
to read from the standard input stream. In that case, the library immediately flushes the
output buffer without waiting for the buffer to become full. The third occasion for flushing
the buffer is when we explicitly say to do so.

When our program writes its prompt to cout , that output goes into the buffer associated
with the standard output stream. Next, we attempt to read from cin . This read flushes the
cout buffer, so we are assured that our user will see the prompt.

Our next statement, which generates the output, explicitly instructs the library to flush the
buffer. That statement is only slightly more complicated than the one that wrote the prompt.
Here we write the string literal "Hello, " followed by the value of the string variablename , and finally by std::endl . Writing the value of std::endl ends the line of output,and then flushes the buffer, which forces the system to write to the output stream
immediately.

Flushing output buffers at opportune moments is an important habit when you are writing
programs that might take a long time to run. Otherwise, some of the program's output
might languish in the system's buffers for a long time between when your program writes it
and when you see it"

Moi j' en comprends :
- A chaque cout le tampn se vide au moment ou le texte s'affiche sur l' écran
- Lors d'un cin, là je ne sais pas trop... Car il faut le temps au pc de lire ce qui est tapé puis de le stoker dans une variable....

7) Quel différence entre char et string ? Ce sont évidement deux types différents, mais char ne représente t'il qu'un seul caractère alors que string est une suite de caractères ?

[ternel]

char est un caractère unique, c'est aussi un type primitif.
char* est un pointeur de char, c'est aussi le type utilisé en C référer à une suite continue de char, terminée par un '\0' qui est le caractère nul.
std::string est une classe standard garantissant de ne pas faire de bêtise avec la mémoire (sauf à le faire exprès).

Pour les deux buffers, en gros, il permettent de ne pas payer le coût d'accès à l'écran/le clavier pour à chaque fois.

Par exemple, si ton programme contient ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
std::cout << "veuillez saisir trois nombre " << std::endl;
int a, b, c;
std::cin >> a >> b >> c;

Alors à l'exécution, après l'affichage, l'utilisateur est attendu.
Il peut par exemple taper ceci: "1 2<entrée>3"

cin >> a >> b >> c; est évalué ainsi:

• cin >> a qui retourne (une référence sur) cin
• cin >> b qui retourne cin
• cin >> c qui retourne cin
• puis rien de plus, car on arrive au point-virgule. C'est un exemple d'instruction-expression. Seul ses effets de bord sont intéressant, car la valeur est abandonnée.

la première partie s'arrête jusqu'à ce que le buffer soit assez rempli.
Concrètement, l'OS va attendre jusqu'à ce que l'utilisateur appuie sur <entrée> ou provoque une fin de fichier (EOF, Ctrl+D avec un linux).

voici ce qui se passe:
avant l'étape 1: a, b et c valent "random: mémoire non initialisée", le buffer est vide.
durant l'étape 1:
le buffer étant vide, le programme rend la main à l'OS
l'utilisateur commence à taper. En appuyant sur la touche <entrée>, il signale à l'OS que le buffer est assez rempli.
le buffer contient "1 2\n"
cin parvient à lire un int, qu'il retire du buffer, et assigne 1 à a.
le buffer contient finalement " 2\n"

étape 2:
le buffer n'est pas vide, cin cherchant un int, il saute les éventuels caractères blancs (espace, tab, \n ...), arrivant devant 2.
Il lit cet int, et l'affecte à b (2).
le buffer contient "\n".

étape 3:
le buffer n'est pas vide, cin cherchant un int, il saute les éventuels caractères blancs (espace, tab, \n ...), vidant ainsi le buffer.
le programme rend la main à l'OS, qui continue alors à écouter l'utilisateur.
celui-ci finit sa saisie: "3"
tant qu'il n'a pas appuyé sur <entrée> ou provoqué une fin de fichier, l'OS attend sagement.

Voila pour la mécanique du buffer d'entrée.
Si au lieu de saisir "3", l'utilisateur appuie de suite sur <entrée>, cin ne trouve rien à lire, mais comme il n'est pas sur un cas d'erreur, il demande encore la suite à l'OS.
Enfin, si l'utilisateur ne saisi toujours pas de nombre, mais provoque enfin une fin de fichier, cin ne donnera pas de valeur à c, mais se marquera en erreur.

chose que tu pourras vérifier avec if(cin), voire meme avec une instruction combinée:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
if (!(cin>>c)) {
    cout << "le troisième nombre n'a pas été lu" << endl;
}

C'est précisément ce qu'on fait quand on lit un fichier.