Using::std ...
pratix
Messages postés
11
Date d'inscription
lundi 10 février 2003
Statut
Membre
Dernière intervention
12 mars 2003
-
10 févr. 2003 à 14:07
jonathanmcdougall Messages postés 64 Date d'inscription dimanche 9 février 2003 Statut Membre Dernière intervention 7 mars 2003 - 13 févr. 2003 à 23:56
jonathanmcdougall Messages postés 64 Date d'inscription dimanche 9 février 2003 Statut Membre Dernière intervention 7 mars 2003 - 13 févr. 2003 à 23:56
A voir également:
- Cpp using std
- Cpp timer - Forum C++ & C++ .NET
- Cpp map ✓ - Forum C
- Ipc cpp ✓ - Forum C++ & C++ .NET
- Std ostream ✓ - Forum C / C++ / C++.NET
- Std stack - Forum C / C++ / C++.NET
8 réponses
jonathanmcdougall
Messages postés
64
Date d'inscription
dimanche 9 février 2003
Statut
Membre
Dernière intervention
7 mars 2003
10 févr. 2003 à 14:37
10 févr. 2003 à 14:37
> celà fait environ deux mois que je me suis mis au C++(j'adore ça).
et t'as pas fini...
> sur les deux premiers livres de poches que j'ai achetés sur le sujet ,aucun ne fait allusion à "using:: std cin" par ex.
poubelle
> sur le troisième qui n'est pas de poche ,"using::std... est utilisé même dans les plus petits programmes.
correct
> Tous mes (petits) programmes fontionnent correctement que j'inclus ou pas "using::std...".
t'es sur?
> Ma question.
>
> quand doit on utiliser "using::std..."?
#include
int main()
{
cout << "salut";
}
Ça, ça ne compile pas. Les fonctions de la STL sont dans un namespace nommé std. On doit se référer explicitement à ce namespace pour pouvoir accéder aux fonctions :
std::cout << "salut";
Sauf que ça devient long. Alors on peut spécifier au compilateur qu'on utilise le 'cout' de :
using std::cout;
cout << "salut";
littéralement 'j'utilise le cout de std'. C'est la forme que je préfère, car elle ne rend disponible que les fonctions que je spécifie. Sinon, si tu utilises 300 fonctions de la STL :
using namespace std;
cout << "salut";
Ici, *toutes* les fonctions du namespace std seront disponibles.
La morale est de ne rien mettre si tu en utilises quelques-unes, de mettre un using std:: si tu en utilises plus et de mettre using namespace std si tu les utilises plus que beaucoup.
Mais il faut toujours garder à l'esprit qu'il faut utiliser des using dans la portée la plus petite possible. Par exemple :
# include
using namespace std;
int main()
{
//...
}
n'est pas très très bon.
# include
int main()
{
using namespace std;
//...
}
est déjà mieux.
> Merci. :)
Plaisir,
Jonathan Mcdougal
Montréal, Québec
mcdougalljonathan@hotmail.com
http://www.multimania.com/utopiasoftware
et t'as pas fini...
> sur les deux premiers livres de poches que j'ai achetés sur le sujet ,aucun ne fait allusion à "using:: std cin" par ex.
poubelle
> sur le troisième qui n'est pas de poche ,"using::std... est utilisé même dans les plus petits programmes.
correct
> Tous mes (petits) programmes fontionnent correctement que j'inclus ou pas "using::std...".
t'es sur?
> Ma question.
>
> quand doit on utiliser "using::std..."?
#include
int main()
{
cout << "salut";
}
Ça, ça ne compile pas. Les fonctions de la STL sont dans un namespace nommé std. On doit se référer explicitement à ce namespace pour pouvoir accéder aux fonctions :
std::cout << "salut";
Sauf que ça devient long. Alors on peut spécifier au compilateur qu'on utilise le 'cout' de :
using std::cout;
cout << "salut";
littéralement 'j'utilise le cout de std'. C'est la forme que je préfère, car elle ne rend disponible que les fonctions que je spécifie. Sinon, si tu utilises 300 fonctions de la STL :
using namespace std;
cout << "salut";
Ici, *toutes* les fonctions du namespace std seront disponibles.
La morale est de ne rien mettre si tu en utilises quelques-unes, de mettre un using std:: si tu en utilises plus et de mettre using namespace std si tu les utilises plus que beaucoup.
Mais il faut toujours garder à l'esprit qu'il faut utiliser des using dans la portée la plus petite possible. Par exemple :
# include
using namespace std;
int main()
{
//...
}
n'est pas très très bon.
# include
int main()
{
using namespace std;
//...
}
est déjà mieux.
> Merci. :)
Plaisir,
Jonathan Mcdougal
Montréal, Québec
mcdougalljonathan@hotmail.com
http://www.multimania.com/utopiasoftware
pratix
Messages postés
11
Date d'inscription
lundi 10 février 2003
Statut
Membre
Dernière intervention
12 mars 2003
10 févr. 2003 à 20:10
10 févr. 2003 à 20:10
-------------------------------
Réponse au message :
-------------------------------
> > celà fait environ deux mois que je me suis mis au C++(j'adore ça).
>
> et t'as pas fini...
>
> > sur les deux premiers livres de poches que j'ai achetés sur le sujet ,aucun ne fait allusion à "using:: std cin" par ex.
>
> poubelle
>
> > sur le troisième qui n'est pas de poche ,"using::std... est utilisé même dans les plus petits programmes.
>
> correct
>
> > Tous mes (petits) programmes fontionnent correctement que j'inclus ou pas "using::std...".
>
> t'es sur?
>
> > Ma question.
> >
> > quand doit on utiliser "using::std..."?
>
> #include
>
> int main()
> {
> cout << "salut";
> }
>
> Ça, ça ne compile pas. Les fonctions de la STL sont dans un namespace nommé std. On doit se référer explicitement à ce namespace pour pouvoir accéder aux fonctions :
>
> std::cout << "salut";
>
> Sauf que ça devient long. Alors on peut spécifier au compilateur qu'on utilise le 'cout' de :
>
> using std::cout;
>
> cout << "salut";
>
> littéralement 'j'utilise le cout de std'. C'est la forme que je préfère, car elle ne rend disponible que les fonctions que je spécifie. Sinon, si tu utilises 300 fonctions de la STL :
>
> using namespace std;
>
> cout << "salut";
>
> Ici, *toutes* les fonctions du namespace std seront disponibles.
>
> La morale est de ne rien mettre si tu en utilises quelques-unes, de mettre un using std:: si tu en utilises plus et de mettre using namespace std si tu les utilises plus que beaucoup.
>
> Mais il faut toujours garder à l'esprit qu'il faut utiliser des using dans la portée la plus petite possible. Par exemple :
>
> # include
>
> using namespace std;
>
> int main()
> {
> //...
> }
>
> n'est pas très très bon.
>
> # include
>
> int main()
> {
> using namespace std;
>
> //...
> }
>
> est déjà mieux.
>
> > Merci. :)
>
> Plaisir,
>
> Jonathan Mcdougal
> Montréal, Québec
> mcdougalljonathan@hotmail.com
> http://www.multimania.com/utopiasoftware
Merci pour ta réponse ultra rapide.
une dernière question (pour aujurd'hui),
qu' elle est l'intérêt d'utiliser "using std..."
puisque les programmes que j'ai compilés fonctionnent?
Re merci.
Practix
Lyon
Réponse au message :
-------------------------------
> > celà fait environ deux mois que je me suis mis au C++(j'adore ça).
>
> et t'as pas fini...
>
> > sur les deux premiers livres de poches que j'ai achetés sur le sujet ,aucun ne fait allusion à "using:: std cin" par ex.
>
> poubelle
>
> > sur le troisième qui n'est pas de poche ,"using::std... est utilisé même dans les plus petits programmes.
>
> correct
>
> > Tous mes (petits) programmes fontionnent correctement que j'inclus ou pas "using::std...".
>
> t'es sur?
>
> > Ma question.
> >
> > quand doit on utiliser "using::std..."?
>
> #include
>
> int main()
> {
> cout << "salut";
> }
>
> Ça, ça ne compile pas. Les fonctions de la STL sont dans un namespace nommé std. On doit se référer explicitement à ce namespace pour pouvoir accéder aux fonctions :
>
> std::cout << "salut";
>
> Sauf que ça devient long. Alors on peut spécifier au compilateur qu'on utilise le 'cout' de :
>
> using std::cout;
>
> cout << "salut";
>
> littéralement 'j'utilise le cout de std'. C'est la forme que je préfère, car elle ne rend disponible que les fonctions que je spécifie. Sinon, si tu utilises 300 fonctions de la STL :
>
> using namespace std;
>
> cout << "salut";
>
> Ici, *toutes* les fonctions du namespace std seront disponibles.
>
> La morale est de ne rien mettre si tu en utilises quelques-unes, de mettre un using std:: si tu en utilises plus et de mettre using namespace std si tu les utilises plus que beaucoup.
>
> Mais il faut toujours garder à l'esprit qu'il faut utiliser des using dans la portée la plus petite possible. Par exemple :
>
> # include
>
> using namespace std;
>
> int main()
> {
> //...
> }
>
> n'est pas très très bon.
>
> # include
>
> int main()
> {
> using namespace std;
>
> //...
> }
>
> est déjà mieux.
>
> > Merci. :)
>
> Plaisir,
>
> Jonathan Mcdougal
> Montréal, Québec
> mcdougalljonathan@hotmail.com
> http://www.multimania.com/utopiasoftware
Merci pour ta réponse ultra rapide.
une dernière question (pour aujurd'hui),
qu' elle est l'intérêt d'utiliser "using std..."
puisque les programmes que j'ai compilés fonctionnent?
Re merci.
Practix
Lyon
jonathanmcdougall
Messages postés
64
Date d'inscription
dimanche 9 février 2003
Statut
Membre
Dernière intervention
7 mars 2003
12 févr. 2003 à 04:32
12 févr. 2003 à 04:32
> Merci pour ta réponse ultra rapide.
>
> une dernière question (pour aujurd'hui),
> qu' elle est l'intérêt d'utiliser "using std..."
> puisque les programmes que j'ai compilés fonctionnent?
Ou bien t'as pas lu ma réponse, ou bien t'as rien compris, dans les deux cas, j'ai manqué mon coup, donc je recommence.
Toutes les fonctions/objets de la librairie standard sont dans un namespace, un espace de nom. Pour pouvoir y accéder, il faut le spécifier, sans quoi ÇA NE COMPILE PAS. Si tu me dis que
# include
int main()
{
cout << "salut";
}
compile et roule, c'est que t'as un sérieux problème mon homme. Si tu utilises à la place de tout court, c'est là ton problème. ne fait pas partie du standard et ne doit pas être utilisé.
Ce qui fait que si tes programmes compilent, c'est parce que tu as utilisé . Dans ce cas, utilise . Sinon, poste ton code.
Jonathan Mcdougal
Montréal, Québec
mcdougalljonathan@hotmail.com
http://www.multimania.com/utopiasoftware
>
> une dernière question (pour aujurd'hui),
> qu' elle est l'intérêt d'utiliser "using std..."
> puisque les programmes que j'ai compilés fonctionnent?
Ou bien t'as pas lu ma réponse, ou bien t'as rien compris, dans les deux cas, j'ai manqué mon coup, donc je recommence.
Toutes les fonctions/objets de la librairie standard sont dans un namespace, un espace de nom. Pour pouvoir y accéder, il faut le spécifier, sans quoi ÇA NE COMPILE PAS. Si tu me dis que
# include
int main()
{
cout << "salut";
}
compile et roule, c'est que t'as un sérieux problème mon homme. Si tu utilises à la place de tout court, c'est là ton problème. ne fait pas partie du standard et ne doit pas être utilisé.
Ce qui fait que si tes programmes compilent, c'est parce que tu as utilisé . Dans ce cas, utilise . Sinon, poste ton code.
Jonathan Mcdougal
Montréal, Québec
mcdougalljonathan@hotmail.com
http://www.multimania.com/utopiasoftware
pratix
Messages postés
11
Date d'inscription
lundi 10 février 2003
Statut
Membre
Dernière intervention
12 mars 2003
12 févr. 2003 à 21:10
12 févr. 2003 à 21:10
-------------------------------
Réponse au message :
-------------------------------
>
> > Merci pour ta réponse ultra rapide.
> >
> > une dernière question (pour aujurd'hui),
> > qu' elle est l'intérêt d'utiliser "using std..."
> > puisque les programmes que j'ai compilés fonctionnent?
>
> Ou bien t'as pas lu ma réponse, ou bien t'as rien compris, dans les deux cas, j'ai manqué mon coup, donc je recommence.
>
> Toutes les fonctions/objets de la librairie standard sont dans un namespace, un espace de nom. Pour pouvoir y accéder, il faut le spécifier, sans quoi ÇA NE COMPILE PAS. Si tu me dis que
>
> # include
>
> int main()
> {
> cout << "salut";
> }
>
> compile et roule, c'est que t'as un sérieux problème mon homme. Si tu utilises à la place de tout court, c'est là ton problème. ne fait pas partie du standard et ne doit pas être utilisé.
>
> Ce qui fait que si tes programmes compilent, c'est parce que tu as utilisé . Dans ce cas, utilise . Sinon, poste ton code.
>
>
> Jonathan Mcdougal
> Montréal, Québec
> mcdougalljonathan@hotmail.com
> http://www.multimania.com/utopiasoftware
ok j'ai utlisé , et le programme est compilé et fonctionne.
Si tu veux y jeter un oeil, il est sur le cite, dans code source récent .
bonne soirée.
Pratix
Réponse au message :
-------------------------------
>
> > Merci pour ta réponse ultra rapide.
> >
> > une dernière question (pour aujurd'hui),
> > qu' elle est l'intérêt d'utiliser "using std..."
> > puisque les programmes que j'ai compilés fonctionnent?
>
> Ou bien t'as pas lu ma réponse, ou bien t'as rien compris, dans les deux cas, j'ai manqué mon coup, donc je recommence.
>
> Toutes les fonctions/objets de la librairie standard sont dans un namespace, un espace de nom. Pour pouvoir y accéder, il faut le spécifier, sans quoi ÇA NE COMPILE PAS. Si tu me dis que
>
> # include
>
> int main()
> {
> cout << "salut";
> }
>
> compile et roule, c'est que t'as un sérieux problème mon homme. Si tu utilises à la place de tout court, c'est là ton problème. ne fait pas partie du standard et ne doit pas être utilisé.
>
> Ce qui fait que si tes programmes compilent, c'est parce que tu as utilisé . Dans ce cas, utilise . Sinon, poste ton code.
>
>
> Jonathan Mcdougal
> Montréal, Québec
> mcdougalljonathan@hotmail.com
> http://www.multimania.com/utopiasoftware
ok j'ai utlisé , et le programme est compilé et fonctionne.
Si tu veux y jeter un oeil, il est sur le cite, dans code source récent .
bonne soirée.
Pratix
Vous n’avez pas trouvé la réponse que vous recherchez ?
Posez votre question
jonathanmcdougall
Messages postés
64
Date d'inscription
dimanche 9 février 2003
Statut
Membre
Dernière intervention
7 mars 2003
13 févr. 2003 à 05:06
13 févr. 2003 à 05:06
> ok j'ai utlisé , et le programme est compilé et fonctionne.
> Si tu veux y jeter un oeil, il est sur le cite, dans code source récent .
Je ne sais pas quelle implémentation de la STL tu as, mais elle n'est pas bonne. Ce code ne compile pas chez moi (et c'est bien normal).
De plus, voici quelques conseils :
1) Il faut un 'using namespace std;' après les #include ou
encore un 'using std::cout', un 'using std::cin' et un 'using
std::endl' (ce que je recommande).
2) Les variables globales sont à éviter le plus possible.
S'arranger pour
a) les mettre locales aux fonctions
b) les passer en argument aux autres
De plus, le mieux est, dans une fonction, de définir
les variables *le plus tard possible* :
int main()
{
int a;
//bla bla bla
a=3;
std::cout << a;
}
n'est pas bon puisque c'est beaucoup plus long de
construire un objet et ensuite de lui assigner une valeur
que de l'initialiser comme ça :
int main()
{
//bla bla bla
int a=3;
std::cout << a;
}
Dans ton programme, je mettrais 'x' dans debut() et je le
passerais en argument à entreNbr().
De plus, tes noms de variables sont vraiment cryptiques. Il
est mieux de passer quelques secondes de plus à taper que
de passer des heures à s'en souvenir.
Finalement, quelle est l'utilité de px? Si ce n'est que pour
apprendre, d'accord. Mais sinon?
3)Tu n'as pas besoin de spécifier les arguments de main() si
tu ne t'en sers pas.
4)Problème de structure : debut() appelle entreNbr() et entreNbr() appelle debut(). Chaque appel de fonction met l'adresse de cette fonction sur un stack (une 'pile'). Voit ça comme un pile d'assiettes. Lorsqu'une fonction termine son exécution, elle est enlevée du stack et l'exécution retourne à celle d'en-dessous. Dans ton programme, on ne retourne *jamais* à la fonction appelante. Ce qui fait que tu empiles des assietes sans arrêts. Si je disais 'o', je sais pas moi, 1000 fois, et bien ton programme manquerait de mémoire, il te dirait : 'stack overflow' ou quelque chose comme ça.
La solution? Une boucle dans ton main() qui, elle, appelle les deux autres.
int main()
{
while (1)
{
debut();
entreNbr();
}
}
Ici, c'est ton main() qui fait tout le travail. Comment sortir de la boucle? Eh bien maintenant, entreNbr() pourrait retourner un bool : 'true' si l'utilisateur répond 'o' pour continuer, 'false' s'il veut quitter. Et là :
int main()
{
while (1)
{
debut();
if (entreNbr() == false)
break;
}
}
Le break sort de ta boucle. Ce qui fait que maintenant,
debut() n'appelle plus entreNbr et entreNbr n'appelle plus
debut(). C'est, de plus, un bon exemple de 'modularité' : dans ton programme, debut() ne peut pas fonctionner sans
entreNbr() et vice-versa. Ces deux fonctions sont
*dépendantes* l'une de l'autre. Dans le mien, elles sont
*indépendantes*, elles fonctionnent même si l'autre
n'existe pas.
Lorsque tu arriveras aux classes, c'est le même système. La
meilleure classe est celle qui fonctionne toute seule.
5) Si tu utilises la boucle dans le main(), tu devras en
mettre une autre dans entreNbr(). Cette boucle tournera tant
que 'x' est plus petit que 9 :
x = 1;
while (x < 9)
{
//entrer nombre
//vérifier nombre
x++;
}
À l'extérieur de ta boucle, tu mettras donc le message 'perdu, le chiffre...'. À l'intérieur, tu mettras le cin et la vérification de la valeur.
5) 'x=x++'. La syntaxe 'x++' équivaut à 'x=x+1'. Donc ce
que tu as écris équivaut à 'x=x=x+1'. Ce n'est illégal, mais
c'est redondant. Seulement 'x++' fait la job.
6) Pour ton test de condition (un peu cryptique), tu n'as maintenant plus besoin de tester 'x' puisqu'il est testé au début de la boucle. Je ferais donc
ceci :
if (b == a) //bon chiffre
{
//....
}else //mauvais chiffre
//....
}
7) Tu as un code identique qui se répète deux fois : la demander pour quitter ou recommencer. Ce code pourrais donc être mis dans une fonction à part, disons quitter() :
bool quitter()
{
//demander si l'utilisateur veut recommencer
if (z == 'o')
return false;
return true;
}
Si l'utilisateur veut continuer, quitter() vaut false, sinon, il vaut true. Comment l'utiliser? Il faut mettre dans le test pour bon chiffre et à l'extérieur de la boucle
return quitter();
Ici, quitter() est appelé et sa valeur est retournée. La boucle du main(), qui teste entreNbr(), teste donc en fait la valeur de quitter().
Tout ça pour dire que est dans le namespace std et qu'il faut le spécifier.
Bonne journée,
Jonathan Mcdougal
Montréal, Québec
mcdougalljonathan@hotmail.com
http://www.multimania.com/utopiasoftware
> Si tu veux y jeter un oeil, il est sur le cite, dans code source récent .
Je ne sais pas quelle implémentation de la STL tu as, mais elle n'est pas bonne. Ce code ne compile pas chez moi (et c'est bien normal).
De plus, voici quelques conseils :
1) Il faut un 'using namespace std;' après les #include ou
encore un 'using std::cout', un 'using std::cin' et un 'using
std::endl' (ce que je recommande).
2) Les variables globales sont à éviter le plus possible.
S'arranger pour
a) les mettre locales aux fonctions
b) les passer en argument aux autres
De plus, le mieux est, dans une fonction, de définir
les variables *le plus tard possible* :
int main()
{
int a;
//bla bla bla
a=3;
std::cout << a;
}
n'est pas bon puisque c'est beaucoup plus long de
construire un objet et ensuite de lui assigner une valeur
que de l'initialiser comme ça :
int main()
{
//bla bla bla
int a=3;
std::cout << a;
}
Dans ton programme, je mettrais 'x' dans debut() et je le
passerais en argument à entreNbr().
De plus, tes noms de variables sont vraiment cryptiques. Il
est mieux de passer quelques secondes de plus à taper que
de passer des heures à s'en souvenir.
Finalement, quelle est l'utilité de px? Si ce n'est que pour
apprendre, d'accord. Mais sinon?
3)Tu n'as pas besoin de spécifier les arguments de main() si
tu ne t'en sers pas.
4)Problème de structure : debut() appelle entreNbr() et entreNbr() appelle debut(). Chaque appel de fonction met l'adresse de cette fonction sur un stack (une 'pile'). Voit ça comme un pile d'assiettes. Lorsqu'une fonction termine son exécution, elle est enlevée du stack et l'exécution retourne à celle d'en-dessous. Dans ton programme, on ne retourne *jamais* à la fonction appelante. Ce qui fait que tu empiles des assietes sans arrêts. Si je disais 'o', je sais pas moi, 1000 fois, et bien ton programme manquerait de mémoire, il te dirait : 'stack overflow' ou quelque chose comme ça.
La solution? Une boucle dans ton main() qui, elle, appelle les deux autres.
int main()
{
while (1)
{
debut();
entreNbr();
}
}
Ici, c'est ton main() qui fait tout le travail. Comment sortir de la boucle? Eh bien maintenant, entreNbr() pourrait retourner un bool : 'true' si l'utilisateur répond 'o' pour continuer, 'false' s'il veut quitter. Et là :
int main()
{
while (1)
{
debut();
if (entreNbr() == false)
break;
}
}
Le break sort de ta boucle. Ce qui fait que maintenant,
debut() n'appelle plus entreNbr et entreNbr n'appelle plus
debut(). C'est, de plus, un bon exemple de 'modularité' : dans ton programme, debut() ne peut pas fonctionner sans
entreNbr() et vice-versa. Ces deux fonctions sont
*dépendantes* l'une de l'autre. Dans le mien, elles sont
*indépendantes*, elles fonctionnent même si l'autre
n'existe pas.
Lorsque tu arriveras aux classes, c'est le même système. La
meilleure classe est celle qui fonctionne toute seule.
5) Si tu utilises la boucle dans le main(), tu devras en
mettre une autre dans entreNbr(). Cette boucle tournera tant
que 'x' est plus petit que 9 :
x = 1;
while (x < 9)
{
//entrer nombre
//vérifier nombre
x++;
}
À l'extérieur de ta boucle, tu mettras donc le message 'perdu, le chiffre...'. À l'intérieur, tu mettras le cin et la vérification de la valeur.
5) 'x=x++'. La syntaxe 'x++' équivaut à 'x=x+1'. Donc ce
que tu as écris équivaut à 'x=x=x+1'. Ce n'est illégal, mais
c'est redondant. Seulement 'x++' fait la job.
6) Pour ton test de condition (un peu cryptique), tu n'as maintenant plus besoin de tester 'x' puisqu'il est testé au début de la boucle. Je ferais donc
ceci :
if (b == a) //bon chiffre
{
//....
}else //mauvais chiffre
//....
}
7) Tu as un code identique qui se répète deux fois : la demander pour quitter ou recommencer. Ce code pourrais donc être mis dans une fonction à part, disons quitter() :
bool quitter()
{
//demander si l'utilisateur veut recommencer
if (z == 'o')
return false;
return true;
}
Si l'utilisateur veut continuer, quitter() vaut false, sinon, il vaut true. Comment l'utiliser? Il faut mettre dans le test pour bon chiffre et à l'extérieur de la boucle
return quitter();
Ici, quitter() est appelé et sa valeur est retournée. La boucle du main(), qui teste entreNbr(), teste donc en fait la valeur de quitter().
Tout ça pour dire que est dans le namespace std et qu'il faut le spécifier.
Bonne journée,
Jonathan Mcdougal
Montréal, Québec
mcdougalljonathan@hotmail.com
http://www.multimania.com/utopiasoftware
pratix
Messages postés
11
Date d'inscription
lundi 10 février 2003
Statut
Membre
Dernière intervention
12 mars 2003
13 févr. 2003 à 12:59
13 févr. 2003 à 12:59
-------------------------------
Réponse au message :
-------------------------------
> > ok j'ai utlisé , et le programme est compilé et fonctionne.
> > Si tu veux y jeter un oeil, il est sur le cite, dans code source récent .
>
> Je ne sais pas quelle implémentation de la STL tu as, mais elle n'est pas bonne. Ce code ne compile pas chez moi (et c'est bien normal).
>
> De plus, voici quelques conseils :
>
> 1) Il faut un 'using namespace std;' après les #include ou
> encore un 'using std::cout', un 'using std::cin' et un 'using
> std::endl' (ce que je recommande).
>
> 2) Les variables globales sont à éviter le plus possible.
> S'arranger pour
> a) les mettre locales aux fonctions
> b) les passer en argument aux autres
>
> De plus, le mieux est, dans une fonction, de définir
> les variables *le plus tard possible* :
>
> int main()
> {
> int a;
> //bla bla bla
> a=3;
> std::cout << a;
> }
>
> n'est pas bon puisque c'est beaucoup plus long de
> construire un objet et ensuite de lui assigner une valeur
> que de l'initialiser comme ça :
>
> int main()
> {
> //bla bla bla
> int a=3;
> std::cout << a;
> }
>
> Dans ton programme, je mettrais 'x' dans debut() et je le
> passerais en argument à entreNbr().
>
> De plus, tes noms de variables sont vraiment cryptiques. Il
> est mieux de passer quelques secondes de plus à taper que
> de passer des heures à s'en souvenir.
>
> Finalement, quelle est l'utilité de px? Si ce n'est que pour
> apprendre, d'accord. Mais sinon?
>
> 3)Tu n'as pas besoin de spécifier les arguments de main() si
> tu ne t'en sers pas.
>
> 4)Problème de structure : debut() appelle entreNbr() et entreNbr() appelle debut(). Chaque appel de fonction met l'adresse de cette fonction sur un stack (une 'pile'). Voit ça comme un pile d'assiettes. Lorsqu'une fonction termine son exécution, elle est enlevée du stack et l'exécution retourne à celle d'en-dessous. Dans ton programme, on ne retourne *jamais* à la fonction appelante. Ce qui fait que tu empiles des assietes sans arrêts. Si je disais 'o', je sais pas moi, 1000 fois, et bien ton programme manquerait de mémoire, il te dirait : 'stack overflow' ou quelque chose comme ça.
>
> La solution? Une boucle dans ton main() qui, elle, appelle les deux autres.
>
> int main()
> {
> while (1)
> {
> debut();
> entreNbr();
> }
> }
>
> Ici, c'est ton main() qui fait tout le travail. Comment sortir de la boucle? Eh bien maintenant, entreNbr() pourrait retourner un bool : 'true' si l'utilisateur répond 'o' pour continuer, 'false' s'il veut quitter. Et là :
>
> int main()
> {
> while (1)
> {
> debut();
> if (entreNbr() == false)
> break;
> }
> }
>
> Le break sort de ta boucle. Ce qui fait que maintenant,
> debut() n'appelle plus entreNbr et entreNbr n'appelle plus
> debut(). C'est, de plus, un bon exemple de 'modularité' : dans ton programme, debut() ne peut pas fonctionner sans
> entreNbr() et vice-versa. Ces deux fonctions sont
> *dépendantes* l'une de l'autre. Dans le mien, elles sont
> *indépendantes*, elles fonctionnent même si l'autre
> n'existe pas.
>
> Lorsque tu arriveras aux classes, c'est le même système. La
> meilleure classe est celle qui fonctionne toute seule.
>
> 5) Si tu utilises la boucle dans le main(), tu devras en
> mettre une autre dans entreNbr(). Cette boucle tournera tant
> que 'x' est plus petit que 9 :
>
> x = 1;
>
> while (x < 9)
> {
>
> //entrer nombre
>
> //vérifier nombre
>
> x++;
>
> }
>
> À l'extérieur de ta boucle, tu mettras donc le message 'perdu, le chiffre...'. À l'intérieur, tu mettras le cin et la vérification de la valeur.
>
> 5) 'x=x++'. La syntaxe 'x++' équivaut à 'x=x+1'. Donc ce
> que tu as écris équivaut à 'x=x=x+1'. Ce n'est illégal, mais
> c'est redondant. Seulement 'x++' fait la job.
>
> 6) Pour ton test de condition (un peu cryptique), tu n'as maintenant plus besoin de tester 'x' puisqu'il est testé au début de la boucle. Je ferais donc
> ceci :
>
> if (b == a) //bon chiffre
> {
> //....
> }else //mauvais chiffre
> //....
> }
>
> 7) Tu as un code identique qui se répète deux fois : la demander pour quitter ou recommencer. Ce code pourrais donc être mis dans une fonction à part, disons quitter() :
>
> bool quitter()
> {
> //demander si l'utilisateur veut recommencer
>
> if (z == 'o')
> return false;
>
> return true;
> }
>
> Si l'utilisateur veut continuer, quitter() vaut false, sinon, il vaut true. Comment l'utiliser? Il faut mettre dans le test pour bon chiffre et à l'extérieur de la boucle
>
> return quitter();
>
> Ici, quitter() est appelé et sa valeur est retournée. La boucle du main(), qui teste entreNbr(), teste donc en fait la valeur de quitter().
>
> Tout ça pour dire que est dans le namespace std et qu'il faut le spécifier.
>
> Bonne journée,
>
> Jonathan Mcdougal
> Montréal, Québec
> mcdougalljonathan@hotmail.com
> http://www.multimania.com/utopiasoftware
Je te remercie d'avoir pris le temps de me répondre.
Je vais lire et relire cette leçon et tenter de l'appliquer.
(leçon que je ne trouve pas dans les bouquins).
Si tu connais un bon livre!
Aprés avoir jeté mes deux bouquins de poche à la poubelle,
j' ai attaqué deitel et deitel 3° édition.
Pour information je compile ce programme avec dev c++4
sous dos et ça tourne OK.
Je te remercie encore et à plus tard.
Réponse au message :
-------------------------------
> > ok j'ai utlisé , et le programme est compilé et fonctionne.
> > Si tu veux y jeter un oeil, il est sur le cite, dans code source récent .
>
> Je ne sais pas quelle implémentation de la STL tu as, mais elle n'est pas bonne. Ce code ne compile pas chez moi (et c'est bien normal).
>
> De plus, voici quelques conseils :
>
> 1) Il faut un 'using namespace std;' après les #include ou
> encore un 'using std::cout', un 'using std::cin' et un 'using
> std::endl' (ce que je recommande).
>
> 2) Les variables globales sont à éviter le plus possible.
> S'arranger pour
> a) les mettre locales aux fonctions
> b) les passer en argument aux autres
>
> De plus, le mieux est, dans une fonction, de définir
> les variables *le plus tard possible* :
>
> int main()
> {
> int a;
> //bla bla bla
> a=3;
> std::cout << a;
> }
>
> n'est pas bon puisque c'est beaucoup plus long de
> construire un objet et ensuite de lui assigner une valeur
> que de l'initialiser comme ça :
>
> int main()
> {
> //bla bla bla
> int a=3;
> std::cout << a;
> }
>
> Dans ton programme, je mettrais 'x' dans debut() et je le
> passerais en argument à entreNbr().
>
> De plus, tes noms de variables sont vraiment cryptiques. Il
> est mieux de passer quelques secondes de plus à taper que
> de passer des heures à s'en souvenir.
>
> Finalement, quelle est l'utilité de px? Si ce n'est que pour
> apprendre, d'accord. Mais sinon?
>
> 3)Tu n'as pas besoin de spécifier les arguments de main() si
> tu ne t'en sers pas.
>
> 4)Problème de structure : debut() appelle entreNbr() et entreNbr() appelle debut(). Chaque appel de fonction met l'adresse de cette fonction sur un stack (une 'pile'). Voit ça comme un pile d'assiettes. Lorsqu'une fonction termine son exécution, elle est enlevée du stack et l'exécution retourne à celle d'en-dessous. Dans ton programme, on ne retourne *jamais* à la fonction appelante. Ce qui fait que tu empiles des assietes sans arrêts. Si je disais 'o', je sais pas moi, 1000 fois, et bien ton programme manquerait de mémoire, il te dirait : 'stack overflow' ou quelque chose comme ça.
>
> La solution? Une boucle dans ton main() qui, elle, appelle les deux autres.
>
> int main()
> {
> while (1)
> {
> debut();
> entreNbr();
> }
> }
>
> Ici, c'est ton main() qui fait tout le travail. Comment sortir de la boucle? Eh bien maintenant, entreNbr() pourrait retourner un bool : 'true' si l'utilisateur répond 'o' pour continuer, 'false' s'il veut quitter. Et là :
>
> int main()
> {
> while (1)
> {
> debut();
> if (entreNbr() == false)
> break;
> }
> }
>
> Le break sort de ta boucle. Ce qui fait que maintenant,
> debut() n'appelle plus entreNbr et entreNbr n'appelle plus
> debut(). C'est, de plus, un bon exemple de 'modularité' : dans ton programme, debut() ne peut pas fonctionner sans
> entreNbr() et vice-versa. Ces deux fonctions sont
> *dépendantes* l'une de l'autre. Dans le mien, elles sont
> *indépendantes*, elles fonctionnent même si l'autre
> n'existe pas.
>
> Lorsque tu arriveras aux classes, c'est le même système. La
> meilleure classe est celle qui fonctionne toute seule.
>
> 5) Si tu utilises la boucle dans le main(), tu devras en
> mettre une autre dans entreNbr(). Cette boucle tournera tant
> que 'x' est plus petit que 9 :
>
> x = 1;
>
> while (x < 9)
> {
>
> //entrer nombre
>
> //vérifier nombre
>
> x++;
>
> }
>
> À l'extérieur de ta boucle, tu mettras donc le message 'perdu, le chiffre...'. À l'intérieur, tu mettras le cin et la vérification de la valeur.
>
> 5) 'x=x++'. La syntaxe 'x++' équivaut à 'x=x+1'. Donc ce
> que tu as écris équivaut à 'x=x=x+1'. Ce n'est illégal, mais
> c'est redondant. Seulement 'x++' fait la job.
>
> 6) Pour ton test de condition (un peu cryptique), tu n'as maintenant plus besoin de tester 'x' puisqu'il est testé au début de la boucle. Je ferais donc
> ceci :
>
> if (b == a) //bon chiffre
> {
> //....
> }else //mauvais chiffre
> //....
> }
>
> 7) Tu as un code identique qui se répète deux fois : la demander pour quitter ou recommencer. Ce code pourrais donc être mis dans une fonction à part, disons quitter() :
>
> bool quitter()
> {
> //demander si l'utilisateur veut recommencer
>
> if (z == 'o')
> return false;
>
> return true;
> }
>
> Si l'utilisateur veut continuer, quitter() vaut false, sinon, il vaut true. Comment l'utiliser? Il faut mettre dans le test pour bon chiffre et à l'extérieur de la boucle
>
> return quitter();
>
> Ici, quitter() est appelé et sa valeur est retournée. La boucle du main(), qui teste entreNbr(), teste donc en fait la valeur de quitter().
>
> Tout ça pour dire que est dans le namespace std et qu'il faut le spécifier.
>
> Bonne journée,
>
> Jonathan Mcdougal
> Montréal, Québec
> mcdougalljonathan@hotmail.com
> http://www.multimania.com/utopiasoftware
Je te remercie d'avoir pris le temps de me répondre.
Je vais lire et relire cette leçon et tenter de l'appliquer.
(leçon que je ne trouve pas dans les bouquins).
Si tu connais un bon livre!
Aprés avoir jeté mes deux bouquins de poche à la poubelle,
j' ai attaqué deitel et deitel 3° édition.
Pour information je compile ce programme avec dev c++4
sous dos et ça tourne OK.
Je te remercie encore et à plus tard.
pratix
Messages postés
11
Date d'inscription
lundi 10 février 2003
Statut
Membre
Dernière intervention
12 mars 2003
13 févr. 2003 à 13:22
13 févr. 2003 à 13:22
-------------------------------
Réponse au message :
-------------------------------
>
>
>
>
> -------------------------------
> Réponse au message :
> -------------------------------
>
> > > ok j'ai utlisé , et le programme est compilé et fonctionne.
> > > Si tu veux y jeter un oeil, il est sur le cite, dans code source récent .
> >
> > Je ne sais pas quelle implémentation de la STL tu as, mais elle n'est pas bonne. Ce code ne compile pas chez moi (et c'est bien normal).
> >
> > De plus, voici quelques conseils :
> >
> > 1) Il faut un 'using namespace std;' après les #include ou
> > encore un 'using std::cout', un 'using std::cin' et un 'using
> > std::endl' (ce que je recommande).
> >
> > 2) Les variables globales sont à éviter le plus possible.
> > S'arranger pour
> > a) les mettre locales aux fonctions
> > b) les passer en argument aux autres
> >
> > De plus, le mieux est, dans une fonction, de définir
> > les variables *le plus tard possible* :
> >
> > int main()
> > {
> > int a;
> > //bla bla bla
> > a=3;
> > std::cout << a;
> > }
> >
> > n'est pas bon puisque c'est beaucoup plus long de
> > construire un objet et ensuite de lui assigner une valeur
> > que de l'initialiser comme ça :
> >
> > int main()
> > {
> > //bla bla bla
> > int a=3;
> > std::cout << a;
> > }
> >
> > Dans ton programme, je mettrais 'x' dans debut() et je le
> > passerais en argument à entreNbr().
> >
> > De plus, tes noms de variables sont vraiment cryptiques. Il
> > est mieux de passer quelques secondes de plus à taper que
> > de passer des heures à s'en souvenir.
> >
> > Finalement, quelle est l'utilité de px? Si ce n'est que pour
> > apprendre, d'accord. Mais sinon?
> >
> > 3)Tu n'as pas besoin de spécifier les arguments de main() si
> > tu ne t'en sers pas.
> >
> > 4)Problème de structure : debut() appelle entreNbr() et entreNbr() appelle debut(). Chaque appel de fonction met l'adresse de cette fonction sur un stack (une 'pile'). Voit ça comme un pile d'assiettes. Lorsqu'une fonction termine son exécution, elle est enlevée du stack et l'exécution retourne à celle d'en-dessous. Dans ton programme, on ne retourne *jamais* à la fonction appelante. Ce qui fait que tu empiles des assietes sans arrêts. Si je disais 'o', je sais pas moi, 1000 fois, et bien ton programme manquerait de mémoire, il te dirait : 'stack overflow' ou quelque chose comme ça.
> >
> > La solution? Une boucle dans ton main() qui, elle, appelle les deux autres.
> >
> > int main()
> > {
> > while (1)
> > {
> > debut();
> > entreNbr();
> > }
> > }
> >
> > Ici, c'est ton main() qui fait tout le travail. Comment sortir de la boucle? Eh bien maintenant, entreNbr() pourrait retourner un bool : 'true' si l'utilisateur répond 'o' pour continuer, 'false' s'il veut quitter. Et là :
> >
> > int main()
> > {
> > while (1)
> > {
> > debut();
> > if (entreNbr() == false)
> > break;
> > }
> > }
> >
> > Le break sort de ta boucle. Ce qui fait que maintenant,
> > debut() n'appelle plus entreNbr et entreNbr n'appelle plus
> > debut(). C'est, de plus, un bon exemple de 'modularité' : dans ton programme, debut() ne peut pas fonctionner sans
> > entreNbr() et vice-versa. Ces deux fonctions sont
> > *dépendantes* l'une de l'autre. Dans le mien, elles sont
> > *indépendantes*, elles fonctionnent même si l'autre
> > n'existe pas.
> >
> > Lorsque tu arriveras aux classes, c'est le même système. La
> > meilleure classe est celle qui fonctionne toute seule.
> >
> > 5) Si tu utilises la boucle dans le main(), tu devras en
> > mettre une autre dans entreNbr(). Cette boucle tournera tant
> > que 'x' est plus petit que 9 :
> >
> > x = 1;
> >
> > while (x < 9)
> > {
> >
> > //entrer nombre
> >
> > //vérifier nombre
> >
> > x++;
> >
> > }
> >
> > À l'extérieur de ta boucle, tu mettras donc le message 'perdu, le chiffre...'. À l'intérieur, tu mettras le cin et la vérification de la valeur.
> >
> > 5) 'x=x++'. La syntaxe 'x++' équivaut à 'x=x+1'. Donc ce
> > que tu as écris équivaut à 'x=x=x+1'. Ce n'est illégal, mais
> > c'est redondant. Seulement 'x++' fait la job.
> >
> > 6) Pour ton test de condition (un peu cryptique), tu n'as maintenant plus besoin de tester 'x' puisqu'il est testé au début de la boucle. Je ferais donc
> > ceci :
> >
> > if (b == a) //bon chiffre
> > {
> > //....
> > }else //mauvais chiffre
> > //....
> > }
> >
> > 7) Tu as un code identique qui se répète deux fois : la demander pour quitter ou recommencer. Ce code pourrais donc être mis dans une fonction à part, disons quitter() :
> >
> > bool quitter()
> > {
> > //demander si l'utilisateur veut recommencer
> >
> > if (z == 'o')
> > return false;
> >
> > return true;
> > }
> >
> > Si l'utilisateur veut continuer, quitter() vaut false, sinon, il vaut true. Comment l'utiliser? Il faut mettre dans le test pour bon chiffre et à l'extérieur de la boucle
> >
> > return quitter();
> >
> > Ici, quitter() est appelé et sa valeur est retournée. La boucle du main(), qui teste entreNbr(), teste donc en fait la valeur de quitter().
> >
> > Tout ça pour dire que est dans le namespace std et qu'il faut le spécifier.
> >
> > Bonne journée,
> >
> > Jonathan Mcdougal
> > Montréal, Québec
> > mcdougalljonathan@hotmail.com
> > http://www.multimania.com/utopiasoftware
>
> Je te remercie d'avoir pris le temps de me répondre.
> Je vais lire et relire cette leçon et tenter de l'appliquer.
> (leçon que je ne trouve pas dans les bouquins).
> Si tu connais un bon livre!
> Aprés avoir jeté mes deux bouquins de poche à la poubelle,
> j' ai attaqué deitel et deitel 3° édition.
>
> Pour information je compile ce programme avec dev c++4
> sous dos et ça tourne OK.
>
> Je te remercie encore et à plus tard.
>
> Bon je vais faire un tour chez utopiasoftware.
Réponse au message :
-------------------------------
>
>
>
>
> -------------------------------
> Réponse au message :
> -------------------------------
>
> > > ok j'ai utlisé , et le programme est compilé et fonctionne.
> > > Si tu veux y jeter un oeil, il est sur le cite, dans code source récent .
> >
> > Je ne sais pas quelle implémentation de la STL tu as, mais elle n'est pas bonne. Ce code ne compile pas chez moi (et c'est bien normal).
> >
> > De plus, voici quelques conseils :
> >
> > 1) Il faut un 'using namespace std;' après les #include ou
> > encore un 'using std::cout', un 'using std::cin' et un 'using
> > std::endl' (ce que je recommande).
> >
> > 2) Les variables globales sont à éviter le plus possible.
> > S'arranger pour
> > a) les mettre locales aux fonctions
> > b) les passer en argument aux autres
> >
> > De plus, le mieux est, dans une fonction, de définir
> > les variables *le plus tard possible* :
> >
> > int main()
> > {
> > int a;
> > //bla bla bla
> > a=3;
> > std::cout << a;
> > }
> >
> > n'est pas bon puisque c'est beaucoup plus long de
> > construire un objet et ensuite de lui assigner une valeur
> > que de l'initialiser comme ça :
> >
> > int main()
> > {
> > //bla bla bla
> > int a=3;
> > std::cout << a;
> > }
> >
> > Dans ton programme, je mettrais 'x' dans debut() et je le
> > passerais en argument à entreNbr().
> >
> > De plus, tes noms de variables sont vraiment cryptiques. Il
> > est mieux de passer quelques secondes de plus à taper que
> > de passer des heures à s'en souvenir.
> >
> > Finalement, quelle est l'utilité de px? Si ce n'est que pour
> > apprendre, d'accord. Mais sinon?
> >
> > 3)Tu n'as pas besoin de spécifier les arguments de main() si
> > tu ne t'en sers pas.
> >
> > 4)Problème de structure : debut() appelle entreNbr() et entreNbr() appelle debut(). Chaque appel de fonction met l'adresse de cette fonction sur un stack (une 'pile'). Voit ça comme un pile d'assiettes. Lorsqu'une fonction termine son exécution, elle est enlevée du stack et l'exécution retourne à celle d'en-dessous. Dans ton programme, on ne retourne *jamais* à la fonction appelante. Ce qui fait que tu empiles des assietes sans arrêts. Si je disais 'o', je sais pas moi, 1000 fois, et bien ton programme manquerait de mémoire, il te dirait : 'stack overflow' ou quelque chose comme ça.
> >
> > La solution? Une boucle dans ton main() qui, elle, appelle les deux autres.
> >
> > int main()
> > {
> > while (1)
> > {
> > debut();
> > entreNbr();
> > }
> > }
> >
> > Ici, c'est ton main() qui fait tout le travail. Comment sortir de la boucle? Eh bien maintenant, entreNbr() pourrait retourner un bool : 'true' si l'utilisateur répond 'o' pour continuer, 'false' s'il veut quitter. Et là :
> >
> > int main()
> > {
> > while (1)
> > {
> > debut();
> > if (entreNbr() == false)
> > break;
> > }
> > }
> >
> > Le break sort de ta boucle. Ce qui fait que maintenant,
> > debut() n'appelle plus entreNbr et entreNbr n'appelle plus
> > debut(). C'est, de plus, un bon exemple de 'modularité' : dans ton programme, debut() ne peut pas fonctionner sans
> > entreNbr() et vice-versa. Ces deux fonctions sont
> > *dépendantes* l'une de l'autre. Dans le mien, elles sont
> > *indépendantes*, elles fonctionnent même si l'autre
> > n'existe pas.
> >
> > Lorsque tu arriveras aux classes, c'est le même système. La
> > meilleure classe est celle qui fonctionne toute seule.
> >
> > 5) Si tu utilises la boucle dans le main(), tu devras en
> > mettre une autre dans entreNbr(). Cette boucle tournera tant
> > que 'x' est plus petit que 9 :
> >
> > x = 1;
> >
> > while (x < 9)
> > {
> >
> > //entrer nombre
> >
> > //vérifier nombre
> >
> > x++;
> >
> > }
> >
> > À l'extérieur de ta boucle, tu mettras donc le message 'perdu, le chiffre...'. À l'intérieur, tu mettras le cin et la vérification de la valeur.
> >
> > 5) 'x=x++'. La syntaxe 'x++' équivaut à 'x=x+1'. Donc ce
> > que tu as écris équivaut à 'x=x=x+1'. Ce n'est illégal, mais
> > c'est redondant. Seulement 'x++' fait la job.
> >
> > 6) Pour ton test de condition (un peu cryptique), tu n'as maintenant plus besoin de tester 'x' puisqu'il est testé au début de la boucle. Je ferais donc
> > ceci :
> >
> > if (b == a) //bon chiffre
> > {
> > //....
> > }else //mauvais chiffre
> > //....
> > }
> >
> > 7) Tu as un code identique qui se répète deux fois : la demander pour quitter ou recommencer. Ce code pourrais donc être mis dans une fonction à part, disons quitter() :
> >
> > bool quitter()
> > {
> > //demander si l'utilisateur veut recommencer
> >
> > if (z == 'o')
> > return false;
> >
> > return true;
> > }
> >
> > Si l'utilisateur veut continuer, quitter() vaut false, sinon, il vaut true. Comment l'utiliser? Il faut mettre dans le test pour bon chiffre et à l'extérieur de la boucle
> >
> > return quitter();
> >
> > Ici, quitter() est appelé et sa valeur est retournée. La boucle du main(), qui teste entreNbr(), teste donc en fait la valeur de quitter().
> >
> > Tout ça pour dire que est dans le namespace std et qu'il faut le spécifier.
> >
> > Bonne journée,
> >
> > Jonathan Mcdougal
> > Montréal, Québec
> > mcdougalljonathan@hotmail.com
> > http://www.multimania.com/utopiasoftware
>
> Je te remercie d'avoir pris le temps de me répondre.
> Je vais lire et relire cette leçon et tenter de l'appliquer.
> (leçon que je ne trouve pas dans les bouquins).
> Si tu connais un bon livre!
> Aprés avoir jeté mes deux bouquins de poche à la poubelle,
> j' ai attaqué deitel et deitel 3° édition.
>
> Pour information je compile ce programme avec dev c++4
> sous dos et ça tourne OK.
>
> Je te remercie encore et à plus tard.
>
> Bon je vais faire un tour chez utopiasoftware.
jonathanmcdougall
Messages postés
64
Date d'inscription
dimanche 9 février 2003
Statut
Membre
Dernière intervention
7 mars 2003
13 févr. 2003 à 23:56
13 févr. 2003 à 23:56
> > Je te remercie d'avoir pris le temps de me répondre.
> > Je vais lire et relire cette leçon et tenter de l'appliquer.
> > (leçon que je ne trouve pas dans les bouquins).
C'est malheureusement le cas avec plein de livres. Lorsque
tu en achètes, vérifie si ces livres respectent le standard
C++ de 1998 (le seul, d'ailleurs), quelques fois noté "Conforme ANSI / ISO", ou encore "ISO/IEC 14882".
Dans le fond, si les examples utilisent (pas
de .h), ça devrait être pas pire.
> > Si tu connais un bon livre!
"Programmer en C++" de Claude Delannoy est un des bons en français (d'après moi). Sinon, si tu comprends l'anglais, tu pourrais t'essayer avec "Accelerated C++" de Koenig et Moo. Lorsque tu seras assez à l'aise ou t'enligneras vers un usage professionel, le premier bouquin à se procurer est "The C++ Programming Language" de Bjarne Stroustrup, le concepteur du C++. Aride, mais inestimable.
Finalement, visite www.accu.org (anglais) pour des reccomendations de livres.
> > Aprés avoir jeté mes deux bouquins de poche à la poubelle,
C'est pas ce que je voulais (en espérant que les éboueurs ne soient pas passés), c'est juste qu'il est bon d'avoir des livres les plus récents possibles, mais surtout des livres recommandés par la communauté de programmeurs. Il y a tant de mauvais livres/écrivains/programmeurs.
> > j' ai attaqué deitel et deitel 3° édition.
Le seul livre de Deitel que j'ai vu est sur le Java et il était moyen. Je ne sais pas pour celui-là.
> > Pour information je compile ce programme avec dev c++4
> > sous dos et ça tourne OK.
J'avais jamais utilisé avant et je viens de l'installer. Un projet console (dont la description est : MSDOS window, c'est faux) démarre avec #include <stdlib.h>, pas bon non plus.
De plus la source de base ne compile même pas et ça ne me tente pas vraiment de chercher pourquoi.
Mais un coup d'oeil rapide sur le fichier /include/c++/iostream me donne
namespace std
{
extern istream cin;
extern ostream cout;
extern ostream cerr;
extern ostream clog;
#ifdef _GLIBCPP_USE_WCHAR_T
extern wistream wcin;
extern wostream wcout;
extern wostream wcerr;
extern wostream wclog;
#endif
// For construction of filebuffers for cout, cin, cerr, clog et. al.
static ios_base::Init __ioinit;
} // namespace std
Donc, ces objets sont dans le namespace std et j'imagine que tous les autres aussi. Tu peux aller voir ce fichier toi aussi et me dire ce qu'il y a dedans?
> > Je te remercie encore et à plus tard.
> >
> > Bon je vais faire un tour chez utopiasoftware.
Pas une mauvaise idée, y'a pas mal de choses de base, quoique je suis en train de tout réécrire et redesigner la page. Tout ça devrait être prêt dans un mois ou deux.
Jonathan Mcdougal
Montréal, Québec
mcdougalljonathan@hotmail.com
http://www.multimania.com/utopiasoftware
> > Je vais lire et relire cette leçon et tenter de l'appliquer.
> > (leçon que je ne trouve pas dans les bouquins).
C'est malheureusement le cas avec plein de livres. Lorsque
tu en achètes, vérifie si ces livres respectent le standard
C++ de 1998 (le seul, d'ailleurs), quelques fois noté "Conforme ANSI / ISO", ou encore "ISO/IEC 14882".
Dans le fond, si les examples utilisent (pas
de .h), ça devrait être pas pire.
> > Si tu connais un bon livre!
"Programmer en C++" de Claude Delannoy est un des bons en français (d'après moi). Sinon, si tu comprends l'anglais, tu pourrais t'essayer avec "Accelerated C++" de Koenig et Moo. Lorsque tu seras assez à l'aise ou t'enligneras vers un usage professionel, le premier bouquin à se procurer est "The C++ Programming Language" de Bjarne Stroustrup, le concepteur du C++. Aride, mais inestimable.
Finalement, visite www.accu.org (anglais) pour des reccomendations de livres.
> > Aprés avoir jeté mes deux bouquins de poche à la poubelle,
C'est pas ce que je voulais (en espérant que les éboueurs ne soient pas passés), c'est juste qu'il est bon d'avoir des livres les plus récents possibles, mais surtout des livres recommandés par la communauté de programmeurs. Il y a tant de mauvais livres/écrivains/programmeurs.
> > j' ai attaqué deitel et deitel 3° édition.
Le seul livre de Deitel que j'ai vu est sur le Java et il était moyen. Je ne sais pas pour celui-là.
> > Pour information je compile ce programme avec dev c++4
> > sous dos et ça tourne OK.
J'avais jamais utilisé avant et je viens de l'installer. Un projet console (dont la description est : MSDOS window, c'est faux) démarre avec #include <stdlib.h>, pas bon non plus.
De plus la source de base ne compile même pas et ça ne me tente pas vraiment de chercher pourquoi.
Mais un coup d'oeil rapide sur le fichier /include/c++/iostream me donne
namespace std
{
extern istream cin;
extern ostream cout;
extern ostream cerr;
extern ostream clog;
#ifdef _GLIBCPP_USE_WCHAR_T
extern wistream wcin;
extern wostream wcout;
extern wostream wcerr;
extern wostream wclog;
#endif
// For construction of filebuffers for cout, cin, cerr, clog et. al.
static ios_base::Init __ioinit;
} // namespace std
Donc, ces objets sont dans le namespace std et j'imagine que tous les autres aussi. Tu peux aller voir ce fichier toi aussi et me dire ce qu'il y a dedans?
> > Je te remercie encore et à plus tard.
> >
> > Bon je vais faire un tour chez utopiasoftware.
Pas une mauvaise idée, y'a pas mal de choses de base, quoique je suis en train de tout réécrire et redesigner la page. Tout ça devrait être prêt dans un mois ou deux.
Jonathan Mcdougal
Montréal, Québec
mcdougalljonathan@hotmail.com
http://www.multimania.com/utopiasoftware
