programme simple en C++

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

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, 13h04

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, 17h08

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, 17h21

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, 17h50

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, 17h59

Ç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, 18h41

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, 19h18

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, 13h12

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

programme simple en C++

C++

Vue hybride

Discussions similaires

Partager

Partager