programme simple en C++

**boutheinanabeul** · 11/10/2018, 11h38

Bonjour,

J'ai deux questions qui me semble simple mais je voudrais bien comprendre les détails.

en fait en écrivant un programme en C++ qui utilise les commandes cin et cout il est mentionné dans certains qui 'il faut écrire au début du programme après les instructions include using namespace std au lieu de l'écrire dans chaque instruction cin et cout et dans certains documents cette instruction n'est pas présente ni début du programme ni au milieu du programme donc ma question est est-il obligatoire d'utiliser ce namespace ou non.

la deuxième question concernant getch() selon la définition de cette fonction elle est obligatoire à la fin du chaque programme pour que la fenêtre d'exécution ne se ferme pas de façon automatique mais elle reste ouverte jusqu'à que l'utilisateur introduit un caractère quelconque. ma question alors est ce que cette explication est juste ou non

**Médinoc** · 11/10/2018, 12h04

Bonjour,

Il y a deux façons possibles d'utiliser la bibliothèque standard en C++:
- La méthode du using namespace:
  Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
1
2
3
using namespace std;
...
cout << "Hello world!" << endl;
```
- La méthode d'utiliser le nom du namespace à chaque fois: std::cout << "Hello world!" << std::endl;
Il faut savoir que la première méthode a divers inconvénients (notamment le fait qu'il ne faut jamais l'utiliser dans un fichier qu'on inclut dans un autre), et est progressivement devenue de plus en plus impopulaire sur ce forum, au point qu'on se fasse facilement incendier si on l'utilise même sans faire le con avec les fichiers .h.
Donc, de nos jours tu as intérêt à toujours utiliser la seconde méthode, si pénible soit-elle.
.
Non seulement la fonction getch() n'est pas obligatoire, elle n'existe pas dans la norme C++!
C'est une fonction non-standard qui est souvent appelée en fin de programme (ou remplacée par un appel à l'instruction pause de l'interpréteur de commandes de Windows, via la fonction standard system()) pour pallier au fait que sous Windows, quand on double-clique sur un programme (ou quand on le lance dans le debugger de Visual Studio) sa fenêtre se ferme dès la fin du programme. Ce problème peut être contourné d'autres façons:
- Utiliser un invite de commandes à la place pour lancer le programme.
- Dans le cas de visual studio, utiliser la commande "Start Without Debugging" (dont l'icône est une flèche verte creuse) au lieu de "Start Debugging" (dont l'icône est une flèche verte pleine).
  Il fut un temps où elle était présente par défaut dans les barres d'outils de Visual Studio, mais qq part entre Visual 6 et Visual 2005, quelqu'un chez Microsoft a eu l'idée débile de la retirer, donc il faut utiliser les options de personnalisation des barres d'outils pour l'y remettre manuellement.
Donc, je conseille de retirer l'appel à getch() et utiliser une des autres solutions pour empêcher la fermeture prématurée de la console quand tu testes ton programme.

**bacelar** · 11/10/2018, 16h08

Les "using namespace std;" a été mise en place, à la base, pour des problèmes de rétrocompatibilité avec du code pré-normalisation de 1998.
Donc, dans du code qui a moins de 20 ans, et dans les cours qui en ont aussi moins, cet usage (au sens strict) est à proscrire.
Malheureusement, la qualité des cours sur le C++, sur le net ou les bouquins (surtout français), est en générale très très mauvaise, car fait des personnes qui connaissait le C, on vite fait commencé à "apprendre" le C++ en croyant que ce n'était qu'une simple mise à jour du C ("C with class") et on vite fait de prendre leurs pratiques du C, qui pouvait être bonne en C mais pas en C++.
Les "using namespace std;", c'est clairement un doudou de programmeur C qui ne voulaient pas comprendre l'utilité des namespace.

Code :

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

std::cout << ...

C'est toujours plus clair que

Code :

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

cout << ...

et surtout beaucoup plus simple à maintenir.

Dans les normes suivantes du C++ ont profité de ces mots clés pour avoir des usages bien plus pertinent que la simple compatibilité avec du vieux code tout moisi :
https://en.cppreference.com/w/cpp/language/namespace

Donc, un cours qui utilise systématiquement "using namespace std;" juste en vous disant que c'est plus pratique, fuyez le comme la peste.
S'il utilise une truc comme ""using namespace ..." (donc autre chose que std), il doit au moins expliquer clairement les avantages mais surtout les inconvénients de cet usage.

**Médinoc** · 11/10/2018, 16h21

Envoyé par bacelar

std::cout << ... C'est toujours plus clair que cout << ...

Ça, ça me semble quand même un peu péremptoire...

Envoyé par bacelar

et surtout beaucoup plus simple à maintenir.

Et là j'aimerais des précisions, car je ne connais aucun code tierce partie qui redéfinisse de son côté cout et endl.
Je me demande aussi dans quel(s) cas on peut avoir une ambiguïté de namespace "silencieuse" (les autres pouvant être résolues en appliquant le namespace au cas par cas).

**ternel** · 11/10/2018, 16h50

cout ou endl, pas forcément, mais map ou vector arrivent dès qu'on fait des maths (ou de la physique, c'est tout comme)
Raison pour laquelle, j'opte pour un using std::cout dans les quelques fichiers qui en ont besoin (dans mes cas, seulement celui contenant main)

**bacelar** · 11/10/2018, 16h59

Ça, ça me semble quand même un peu péremptoire...

C'est le genre de code qui n'est utilisable que dans une toute petite partie du projet, celle qui est dépendante avec le type d'IHM.
C'est bien plus simple de faire une recherche sur "std::cout" que sur un "cout" qui peut être inclus dans tout et n'importe quoi.
Et visuellement le "std::", il me fait "triger".

Et là j'aimerais des précisions, car je ne connais aucun code tierce partie qui redéfinisse de son côté cout et endl.

C'est pas pour de la redéfinition mais pour détecter facilement des dépendances foireuses, comme du code qui utilise la console alors qu'il n'est pas dans la partie IHM dépendant.

Économiser 5 caractères que l'IDE remplit pour vous quasi automatiquement, la belle "affaire".
Je veux que la dépendance à l'IHM soit explicite, donc un "std::" devant les "cout" et "cin" la rend plus explicite.

L'usage d'un "using std::cout" en début de fichier annonce explicitement la couleur, c'est une zone IHM dépendant.

"using namespace std;", c'est quoi ? de l'IHM, des algorithmes ? etc... ?

Franchement aucun avantage à "using namespace std;" (sauf pour du code de plus de 20 ans, donc à l'Ouest pour l'apprentissage du C++)

Les inconvénients, pour le coup, sont très présents, et encore plus quand le cours ne les mentionne pas, mais les explications ne sont pas forcément à la portée des débutants, donc ne pas s'en servir est la meilleurs approche pédagogique, pour ma part.

**Médinoc** · 11/10/2018, 17h41

Envoyé par bacelar

L'usage d'un "using std::cout" en début de fichier annonce explicitement la couleur, c'est une zone IHM dépendant.

"using namespace std;", c'est quoi ? de l'IHM, des algorithmes ? etc... ?

Ça je n'y avais pas pensé, merci.

**koala01** · 11/10/2018, 18h18

Salut,

Envoyé par Médinoc

Et là j'aimerais des précisions, car je ne connais aucun code tierce partie qui redéfinisse de son côté cout et endl.
Je me demande aussi dans quel(s) cas on peut avoir une ambiguïté de namespace "silencieuse" (les autres pouvant être résolues en appliquant le namespace au cas par cas).

L'exemple est volontairement idiot, mais imagine un code proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
#include <iostream>
#include <iomanip>
int main (){
    double const tva{0.21};
    double pUHtva{5.21};
    int quantite{15};
    double cout{pUHtva*quantite * (1.+tva)};
    std::cout<<std::setprecision(4)<<cout<<std::endl;
    return 0;
}

Ce code compilera sans aucun problème et fournira le résultat attendu (94.56).

Quelle horreur!!! j'ai du écrire trois fois std::, ce qui fait quinze caractères inutiles, sans compter le temps que j'ai "perdu" (au moins une seconde et demie, dis donc!!!) à l'écrire!!!

Dépêchons nous de rajouter la directive using namespace std; (qui, soit dit en passant, nécessite 20 caractères, et me prend sans doute plus de temps à écrire!!! Mais bon ...)!!!

Nous nous retrouvons donc avec un code proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
#include <iomanip>
using namespace std;
int main (){
    double const tva{0.21};
    double pUHtva{5.21};
    int quantite{15};
    double cout{pUHtva*quantite * (1.+tva)};
    cout<<setprecision(4)<<cout<<endl;
    return 0;
}

Mais, quand je vais essayer de compiler ce code, le compilateur va m'engueuler sous prétexte que

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
$ g++ main.cpp
main.cpp:9:9: error: no match for ‘operator<<’ (operand types are ‘double’ and ‘std::_Setprecision’)
     cout<<setprecision(4)<<cout<<endl;
     ~~~~^~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/8/string:52,
                 from /usr/include/c++/8/bits/locale_classes.h:40,
                 from /usr/include/c++/8/bits/ios_base.h:41,
                 from /usr/include/c++/8/ios:42,
                 from /usr/include/c++/8/ostream:38,
                 from /usr/include/c++/8/iostream:39,
                 from main.cpp:1:
/usr/include/c++/8/bits/basic_string.h:6314:5: note: candidate: ‘template<class _CharT, class _Traits, class _Alloc> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, const std::__cxx11::basic_string<_CharT, _Traits, _Alloc>&)’
     operator<<(basic_ostream<_CharT, _Traits>& __os,
     ^~~~~~~~
/usr/include/c++/8/bits/basic_string.h:6314:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<_CharT, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;
                         ^
In file included from /usr/include/c++/8/bits/ios_base.h:46,
                 from /usr/include/c++/8/ios:42,
                 from /usr/include/c++/8/ostream:38,
                 from /usr/include/c++/8/iostream:39,
                 from main.cpp:1:
/usr/include/c++/8/system_error:217:5: note: candidate: ‘template<class _CharT, class _Traits> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, const std::error_code&)’
     operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e)
     ^~~~~~~~
/usr/include/c++/8/system_error:217:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<_CharT, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;
                         ^
In file included from /usr/include/c++/8/iostream:39,
                 from main.cpp:1:
/usr/include/c++/8/ostream:497:5: note: candidate: ‘template<class _CharT, class _Traits> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, _CharT)’
     operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
     ^~~~~~~~
/usr/include/c++/8/ostream:497:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<_CharT, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;
                         ^
In file included from /usr/include/c++/8/iostream:39,
                 from main.cpp:1:
/usr/include/c++/8/ostream:502:5: note: candidate: ‘template<class _CharT, class _Traits> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, char)’
     operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
     ^~~~~~~~
/usr/include/c++/8/ostream:502:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<_CharT, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;
                         ^
In file included from /usr/include/c++/8/iostream:39,
                 from main.cpp:1:
/usr/include/c++/8/ostream:508:5: note: candidate: ‘template<class _Traits> std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, char)’
     operator<<(basic_ostream<char, _Traits>& __out, char __c)
     ^~~~~~~~
/usr/include/c++/8/ostream:508:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<char, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;
                         ^
In file included from /usr/include/c++/8/iostream:39,
                 from main.cpp:1:
/usr/include/c++/8/ostream:514:5: note: candidate: ‘template<class _Traits> std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, signed char)’
     operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
     ^~~~~~~~
/usr/include/c++/8/ostream:514:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<char, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;
                         ^
In file included from /usr/include/c++/8/iostream:39,
                 from main.cpp:1:
/usr/include/c++/8/ostream:519:5: note: candidate: ‘template<class _Traits> std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, unsigned char)’
     operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
     ^~~~~~~~
/usr/include/c++/8/ostream:519:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<char, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;
                         ^
In file included from /usr/include/c++/8/iostream:39,
                 from main.cpp:1:
/usr/include/c++/8/ostream:539:5: note: candidate: ‘template<class _CharT, class _Traits> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, const _CharT*)’
     operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
     ^~~~~~~~
/usr/include/c++/8/ostream:539:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<_CharT, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;
                         ^
In file included from /usr/include/c++/8/ostream:693,
                 from /usr/include/c++/8/iostream:39,
                 from main.cpp:1:
/usr/include/c++/8/bits/ostream.tcc:321:5: note: candidate: ‘template<class _CharT, class _Traits> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, const char*)’
     operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
     ^~~~~~~~
/usr/include/c++/8/bits/ostream.tcc:321:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<_CharT, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;
                         ^
In file included from /usr/include/c++/8/iostream:39,
                 from main.cpp:1:
/usr/include/c++/8/ostream:556:5: note: candidate: ‘template<class _Traits> std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, const char*)’
     operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
     ^~~~~~~~
/usr/include/c++/8/ostream:556:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<char, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;
                         ^
In file included from /usr/include/c++/8/iostream:39,
                 from main.cpp:1:
/usr/include/c++/8/ostream:569:5: note: candidate: ‘template<class _Traits> std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, const signed char*)’
     operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
     ^~~~~~~~
/usr/include/c++/8/ostream:569:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<char, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;
                         ^
In file included from /usr/include/c++/8/iostream:39,
                 from main.cpp:1:
/usr/include/c++/8/ostream:574:5: note: candidate: ‘template<class _Traits> std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, const unsigned char*)’
     operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
     ^~~~~~~~
/usr/include/c++/8/ostream:574:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<char, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;
                         ^
In file included from /usr/include/c++/8/iostream:39,
                 from main.cpp:1:
/usr/include/c++/8/ostream:682:5: note: candidate: ‘template<class _Ostream, class _Tp> typename std::enable_if<std::__and_<std::__not_<std::is_lvalue_reference<_Tp> >, std::__is_convertible_to_basic_ostream<_Ostream>, std::__is_insertable<typename std::__is_convertible_to_basic_ostream<_Tp>::__ostream_type, const _Tp&, void> >::value, typename std::__is_convertible_to_basic_ostream<_Tp>::__ostream_type>::type std::operator<<(_Ostream&&, const _Tp&)’
     operator<<(_Ostream&& __os, const _Tp& __x)
     ^~~~~~~~
/usr/include/c++/8/ostream:682:5: note:   template argument deduction/substitution failed:
/usr/include/c++/8/ostream: In substitution of ‘template<class _Ostream, class _Tp> typename std::enable_if<std::__and_<std::__not_<std::is_lvalue_reference<_Tp> >, std::__is_convertible_to_basic_ostream<_Ostream>, std::__is_insertable<typename std::__is_convertible_to_basic_ostream<_Tp>::__ostream_type, const _Tp&, void> >::value, typename std::__is_convertible_to_basic_ostream<_Tp>::__ostream_type>::type std::operator<<(_Ostream&&, const _Tp&) [with _Ostream = double&; _Tp = std::_Setprecision]’:
main.cpp:9:25:   required from here
/usr/include/c++/8/ostream:682:5: error: no type named ‘type’ in ‘struct std::enable_if<false, void>’
In file included from main.cpp:2:
/usr/include/c++/8/iomanip:79:5: note: candidate: ‘template<class _CharT, class _Traits> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, std::_Resetiosflags)’
     operator<<(basic_ostream<_CharT, _Traits>& __os, _Resetiosflags __f)
     ^~~~~~~~
/usr/include/c++/8/iomanip:79:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<_CharT, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;
                         ^
In file included from main.cpp:2:
/usr/include/c++/8/iomanip:109:5: note: candidate: ‘template<class _CharT, class _Traits> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, std::_Setiosflags)’
     operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f)
     ^~~~~~~~
/usr/include/c++/8/iomanip:109:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<_CharT, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;
                         ^
In file included from main.cpp:2:
/usr/include/c++/8/iomanip:143:5: note: candidate: ‘template<class _CharT, class _Traits> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, std::_Setbase)’
     operator<<(basic_ostream<_CharT, _Traits>& __os, _Setbase __f)
     ^~~~~~~~
/usr/include/c++/8/iomanip:143:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<_CharT, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;
                         ^
In file included from main.cpp:2:
/usr/include/c++/8/iomanip:178:5: note: candidate: ‘template<class _CharT, class _Traits> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, std::_Setfill<_CharT>)’
     operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f)
     ^~~~~~~~
/usr/include/c++/8/iomanip:178:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<_CharT, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;
                         ^
In file included from main.cpp:2:
/usr/include/c++/8/iomanip:208:5: note: candidate: ‘template<class _CharT, class _Traits> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, std::_Setprecision)’
     operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f)
     ^~~~~~~~
/usr/include/c++/8/iomanip:208:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<_CharT, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;
                         ^
In file included from main.cpp:2:
/usr/include/c++/8/iomanip:238:5: note: candidate: ‘template<class _CharT, class _Traits> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, std::_Setw)’
     operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f)
     ^~~~~~~~
/usr/include/c++/8/iomanip:238:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<_CharT, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;
                         ^
In file included from main.cpp:2:
/usr/include/c++/8/iomanip:311:5: note: candidate: ‘template<class _CharT, class _Traits, class _MoneyT> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, std::_Put_money<_MoneyT>)’
     operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_money<_MoneyT> __f)
     ^~~~~~~~
/usr/include/c++/8/iomanip:311:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<_CharT, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;
                         ^
In file included from main.cpp:2:
/usr/include/c++/8/iomanip:363:5: note: candidate: ‘template<class _CharT, class _Traits> std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, std::_Put_time<_CharT>)’
     operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_time<_CharT> __f)
     ^~~~~~~~
/usr/include/c++/8/iomanip:363:5: note:   template argument deduction/substitution failed:
main.cpp:9:25: note:   mismatched types ‘std::basic_ostream<_CharT, _Traits>’ and ‘double’
     cout<<setprecision(4)<<cout<<endl;

Bien vu!!! Tout cela parce que le compilateur aura repéré un conflit entre std::cout et ma variable cout!!!

Je reconnais que l'exemple est volontairement caricatural, car une "bêtise sans nom" provoque une sortie imbitable de ... 193 lignes !!!. Mais cet exemple a au moins le bon gout de nous faire prendre conscience du fait que using namespace XXX brise très clairement le système d'espaces de noms

**boutheinanabeul** · 12/10/2018, 12h12

donc il y a un accord qu'on doit utiliser à chaque fois le namespace std avec les instructions cin et cout au lieu de mettre l'instruction au début de programme sauf que moi j'ai pensé comme ce point de vue de

Quelle horreur!!! j'ai du trois fois std::, ce qui fait quinze caractères inutiles, sans compter le temps que j'ai "perdu" (au moins une seconde et demie, dis donc!!!) à l'écrire!!!

Dépêchons nous de rajouter la directive using namespace std; (qui, soit dit en passant, nécessite 20 caractères, et me prend sans doute plus de temps à écrire!!! Mais bon ...)!!!

donc gagner de temps et éliminer le fait de réécrire la meme chose à chaque fois.

Concernant le getch c'est quoi la meilleure solution en théorique c-a-d en écrivant un programme sans l’exécuter sans utiliser les boutons ou les icones de VisualBasic comment garantir que l'interface d'exécution de se fermer avec le code sans utiliser le getch donc.
et merci pour vos réponses

**foetus** · 12/10/2018, 12h31

Envoyé par boutheinanabeul

donc il y a un accord qu'on doit utiliser à chaque fois le namespace std avec les instructions cin et cout au lieu de mettre l'instruction au début de programme sauf que moi j'ai pensé comme ce point de vue de donc gagner de temps et éliminer le fait de réécrire la meme chose à chaque fois.

Le problème du truc

, c'est qu'avant C++11 (*), on ne peut pas ouvrir partiellement/ totalement un namespace dans un bloc ... comme certains langages.

Parce que tu peux faire aussi using std::cout; et using std::cin; mais en global. Et des fois c'est pénible de mettre à jour cette liste ... et cela reste global.

Mais depuis C++11, on peut mettre des using dans les blocs : donc à l'endroit de l'utilisation.

* : les experts me corrigeront

**boutheinanabeul** · 12/10/2018, 12h40

personnellement je trouve using namespace au début du programme plus facile donc si c'est compilé et exécuter sans aucun erreur surtout dans des programmes simples donc j’utiliserai cette solution.

**koala01** · 12/10/2018, 13h34

Envoyé par boutheinanabeul

donc il y a un accord qu'on doit utiliser à chaque fois le namespace std <snip>

On ne doit pas le faire uniquement avec l'espace de noms std!!!

On doit utiliser le "nom pleinement qualifié"(car c'est comme cela que l'on désigne des éléments de code comme std::cout) pour toutes les fonctionnalités qui se trouvent dans n'importe quel espace de noms.

Ou, si tu préfères : tu ne dois JAMAIS utiliser la directive using namespace XXX; (où XXX représente n'importe quel espace de noms que tu pourras rencontrer par la suite).

Dans "pas très longtemps", tu vas très certainement commencer à "jouer" avec d'autres bibliothèques, dont certaines auront eu "la bonne idée" de fournir leurs fonctionnalités dans des espaces de noms (et parfois même dans des espaces de noms "secondaires" comme boo::chrono ou boost::filesystem).

La règle que l'on essaye d'imposer pour l'espace de noms std est valable pour tous les espaces de noms que tu pourras rencontrer par la suite

Nous reconnaissons cependant sans problème que cela peut -- des les cas les plus "graves" devenir vachement long d'écrire un code proche de namespace1::sous_namespace1::sous_sous_namespace4::foo.

Ce que nous conseillons dans ces cas là, c'est de créer ce que l'on appelle un alias de l'espace de noms, sous une forme proche de

Code :

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

namespace nsSubSub =namespace1::sous_namespace1::sous_sous_namespace4;

qui te permettra de faire appel à la fonctionnalité foo sous la forme de nsSubSub::foo.

sauf que moi j'ai pensé comme ce point de vue de donc gagner de temps et éliminer le fait de réécrire la meme chose à chaque fois.

Je ne sais pas à quel point tu es habitué à la disposition de ton clavier, mais, de manière générale, les gens utilisent leur clavier:

soit à "deux doigts", en cherchant chaque lettre, chaque caractère entre chaque appuis sur une touche
soit à "deux mains et dix doigts", pour ainsi dire sans regarder leur clavier.

Il est vrai que beaucoup de gens commencent dans la première situation, et que l'écriture du moindre texte se transforme en "parcours du combattant"... Alors, que dire de l'écriture d'un code, qui nécessite l'utilisation de tout plein de caractères "non alpha numériques"

Mais je peux te rassurer : on est sans doute tous passés par là, et l'habitude du clavier vient d'autant plus rapidement que tu l'utilisera de manière "intensive". Et, au pire, en suivant une formation (même en cours du soir) de dactylographie, tu prendra très rapidement l'habitude d'utiliser tes dix doigts, et tu pourrais même perdre l'habitude de regarder ton clavier en permanence, pour regarder le texte que tu écris sur ton écran

Toujours est-il que je te proposerais bien un petit défi : tu sera d'accord avec moi pour dire que les codes que j'ai donné en exemple sont "relativement simples", vu qu'il ne contiennent que dix et onze lignes.

Pourquoi n'essayerais tu pas de les écrire toi-même en te chronométrant :questiion: C'est encore le meilleur moyen de constater par toi-même que ce qui prend le plus de temps n'est pas forcément le moyen que tu crois

. Et, au pire, tu pourras constater que la différence n'est vraiment pas énorme

Concernant le getch c'est quoi la meilleure solution en théorique c-a-d en écrivant un programme sans l’exécuter sans utiliser les boutons ou les icones de VisualBasic comment garantir que l'interface d'exécution de se fermer avec le code sans utiliser le getch donc.
et merci pour vos réponses

Regarde du coté de la FAQ C'est la manière la plus portable de faire

Ceci étant dit : imposer une pause à un programme est très rarement la meilleure des choses à faire.

L'idéal, si tu veux juste une pause en toute fin du programme, c'est encore de configurer ton EDI pour qu'il garde la console ouvert à la fin de l'exécution ou, si tu n'y arrive vraiment pas, d'ouvrir une "ligne de commandes" (ou une console, selon le système d'exploitation) à partir de laquelle tu lancera ton programme

**boutheinanabeul** · 12/10/2018, 13h43

ok merci c'est clair je vais écrire à chaque fois le std avant cin et cout et merci.

**Bktero** · 12/10/2018, 21h01

Le seul endroit où je m'autorise des using namespace, c'est dans les tests unitaires. Je fais un using namespace du namespace où se trouve la classe à tester. C'est un endroit où les conflits n'arrivent (quasiment) pas et où il n'y a (quasiment) jamais d'ambiguïté.

Et je ne fais jamais de using namespace std car lorsque j'ai besoin de faire une écriture sur la sortie standard, je tape "cout" suivi de CRTL+Espace et mon auto-complétion trouve mon template de code et le remplace par "std::cout << (curseuri ici) << std::endl;".

**koala01** · 12/10/2018, 21h22

Envoyé par Bktero

<snip>je tape "cout" suivi de CRTL+Espace et mon auto-complétion trouve mon template de code et le remplace par "std::cout << (curseuri ici) << std::endl;".

Quel dommage que le template ajoute automatiquement std::endl à la fin au lieu de se contenter d'un '\n', mais bon... c'est déjà mieux que rien

**Bktero** · 13/10/2018, 10h46

Quand je l'ai créé, je ne connaissais pas les impacts de endl par rapport \n. Maintenant, je me dis que je devrais utiliser \n mais comme cout ne me sert que pour quelques traces que j'enlève après (des fois au profit de loggers), j'ai laissé comme ça.

**Médinoc** · 13/10/2018, 11h21

D'un autre côté, le fait que endl force un flush est important si on joue à rediriger les entrées/sorties vers des tubes sous Windows, parce que \n ne cause pas de flush, et donc un programme qui lit la sortie d'un autre ligne par ligne peut rester bloqué indéfiniement, surtout s'il attend la ligne pour renvoyer des données sur l'entrée standard du programme.

J'ai été confronté à ce problème.

**koala01** · 13/10/2018, 11h57

Envoyé par Bktero

Quand je l'ai créé, je ne connaissais pas les impacts de endl par rapport \n. Maintenant, je me dis que je devrais utiliser \n mais comme cout ne me sert que pour quelques traces que j'enlève après (des fois au profit de loggers), j'ai laissé comme ça.

Envoyé par Médinoc

D'un autre côté, le fait que endl force un flush est important si on joue à rediriger les entrées/sorties vers des tubes sous Windows, parce que \n ne cause pas de flush, et donc un programme qui lit la sortie d'un autre ligne par ligne peut rester bloqué indéfiniement, surtout s'il attend la ligne pour renvoyer des données sur l'entrée standard du programme.

J'ai été confronté à ce problème.

Et les gars, c'était un peu d'humour, rien de plus

**jo_link_noir** · 13/10/2018, 15h17

Envoyé par Médinoc

un programme qui lit la sortie d'un autre ligne par ligne peut rester bloqué indéfiniement, surtout s'il attend la ligne pour renvoyer des données sur l'entrée standard du programme.

Il existe std::ios::tie pour ce problème. Lorsqu'un flux d'écriture est associé à un flux de lecture, il est alors automatiquement flushé avant toute tentative de lecture. Même plus besoin de se prendre la tête à savoir quand mettre std::flush/std::endl.