voila mon premier programme consiste à créer une liste
comportant un pointeur premier pointant sur le premier element que
j'initialise à NULL et j'ajoute devant
voila:
#include <iostream>
using namespace std;
struct element
{
int entier;
struct element * suivant;
};
void ajout (element*);
void affichage(element*);
void main()
{
element *premier;
premier=NULL;
ajout(premier);
ajout (premier);
affichage(premier);
}
void ajout(element * ptr)
{
element *inter=new element;
int asaisir;
cout<<"donner votre element : "<<"\n";
cin>>asaisir;
inter->suivant=ptr;
inter->entier=asaisir;
ptr=inter;
}
void affichage(element * ptr)
{
element *pointeur;
pointeur=ptr;
while (pointeur->suivant!=NULL)
{
cout<<"la valeur est : "<<pointeur->entier;
pointeur=pointeur->suivant;
}
}
mais ca marche pas pkoi?
et comment s'éviter de passer premier en argument (faut il rajouter
quelquechose dans les fonctions pour dire que la déclaration est ailleurs?
je vous remercie par avance
Pour les entrées/sorties, chercher dans les archives du groupes après « getline » pourrait être utile (pas sûr).
Et surtout, j'aurais plutôt pensé à quelque chose comme :
class Element { public: Element() ; std::ostream & affichage( std::ostream & out ) ; private: int obtenirEntier() ; } ;
std::ostream & operator<<( std::ostream & out , Element const & elem ) ;
--drkm
Eric Fournier
Aussi, à moins que ce ne soit pour des fins d'apprentissages, utiliser std::list réglerais tous tes problèmes.
-Eric
"jmarc" a écrit dans le message de news:4197ba23$0$25365$
voila mon premier programme consiste à créer une liste comportant un pointeur premier pointant sur le premier element que j'initialise à NULL et j'ajoute devant voila:
#include <iostream> using namespace std;
struct element { int entier; struct element * suivant;
};
void ajout (element*); void affichage(element*);
void main() {
element *premier; premier=NULL; ajout(premier); ajout (premier); affichage(premier);
}
void ajout(element * ptr)
{
element *inter=new element; int asaisir; cout<<"donner votre element : "<<"n"; cin>>asaisir; inter->suivant=ptr; inter->entier=asaisir; ptr=inter;
}
void affichage(element * ptr) { element *pointeur; pointeur=ptr; while (pointeur->suivant!=NULL) { cout<<"la valeur est : "<<pointeur->entier; pointeur=pointeur->suivant; }
}
mais ca marche pas pkoi? et comment s'éviter de passer premier en argument (faut il rajouter quelquechose dans les fonctions pour dire que la déclaration est ailleurs? je vous remercie par avance
Aussi, à moins que ce ne soit pour des fins d'apprentissages, utiliser
std::list réglerais tous tes problèmes.
-Eric
"jmarc" <jean.marc.cholet@wanadoo.fr> a écrit dans le message de
news:4197ba23$0$25365$8fcfb975@news.wanadoo.fr...
voila mon premier programme consiste à créer une liste
comportant un pointeur premier pointant sur le premier element que
j'initialise à NULL et j'ajoute devant
voila:
#include <iostream>
using namespace std;
struct element
{
int entier;
struct element * suivant;
};
void ajout (element*);
void affichage(element*);
void main()
{
element *premier;
premier=NULL;
ajout(premier);
ajout (premier);
affichage(premier);
}
void ajout(element * ptr)
{
element *inter=new element;
int asaisir;
cout<<"donner votre element : "<<"n";
cin>>asaisir;
inter->suivant=ptr;
inter->entier=asaisir;
ptr=inter;
}
void affichage(element * ptr)
{
element *pointeur;
pointeur=ptr;
while (pointeur->suivant!=NULL)
{
cout<<"la valeur est : "<<pointeur->entier;
pointeur=pointeur->suivant;
}
}
mais ca marche pas pkoi?
et comment s'éviter de passer premier en argument (faut il rajouter
quelquechose dans les fonctions pour dire que la déclaration est ailleurs?
je vous remercie par avance
Aussi, à moins que ce ne soit pour des fins d'apprentissages, utiliser std::list réglerais tous tes problèmes.
-Eric
"jmarc" a écrit dans le message de news:4197ba23$0$25365$
voila mon premier programme consiste à créer une liste comportant un pointeur premier pointant sur le premier element que j'initialise à NULL et j'ajoute devant voila:
#include <iostream> using namespace std;
struct element { int entier; struct element * suivant;
};
void ajout (element*); void affichage(element*);
void main() {
element *premier; premier=NULL; ajout(premier); ajout (premier); affichage(premier);
}
void ajout(element * ptr)
{
element *inter=new element; int asaisir; cout<<"donner votre element : "<<"n"; cin>>asaisir; inter->suivant=ptr; inter->entier=asaisir; ptr=inter;
}
void affichage(element * ptr) { element *pointeur; pointeur=ptr; while (pointeur->suivant!=NULL) { cout<<"la valeur est : "<<pointeur->entier; pointeur=pointeur->suivant; }
}
mais ca marche pas pkoi? et comment s'éviter de passer premier en argument (faut il rajouter quelquechose dans les fonctions pour dire que la déclaration est ailleurs? je vous remercie par avance
Alexandre
bonsoir,
voila mon premier programme consiste à créer une liste comportant un pointeur premier pointant sur le premier element que j'initialise à NULL et j'ajoute devant
ça ressemble à un exo, ça.
voila:
#include <iostream> using namespace std;
struct element { int entier; struct element * suivant;
};
et aucune méthode dans élément ? Pas de constructeur ? ça ressemble à du C, ça.
void ajout (element*); void affichage(element*);
ah oui, je confirme c'est du C.
void main() {
element *premier; premier=NULL; ajout(premier); ajout (premier); affichage(premier);
}
void ajout(element * ptr)
{
element *inter=new element; int asaisir; cout<<"donner votre element : "<<"n"; cin>>asaisir; inter->suivant=ptr; inter->entier=asaisir; ptr=inter;
}
void affichage(element * ptr) { element *pointeur; pointeur=ptr; while (pointeur->suivant!=NULL) { cout<<"la valeur est : "<<pointeur->entier; pointeur=pointeur->suivant; }
}
mais ca marche pas pkoi? et comment s'éviter de passer premier en argument (faut il rajouter quelquechose dans les fonctions pour dire que la déclaration est ailleurs? je vous remercie par avance
pourquoi ne pas tout simplement créer une classe LISTE de la manière suivante :
class LISTE { struct EltLISTE { int element; EltLISTE *suivant; EltLISTE(int Elt):element(Elt),suivant(NULL){} }; EltLISTE *Premier; public: ~LISTE(); LISTE():Premier(NULL){} void Ajoute(int E) { EltLISTE *Nouveau = new EltLISTE(E); Nouveau->suivant = Premier; Premier = Nouveau; } };
etc...
bonsoir,
voila mon premier programme consiste à créer une liste
comportant un pointeur premier pointant sur le premier element que
j'initialise à NULL et j'ajoute devant
ça ressemble à un exo, ça.
voila:
#include <iostream>
using namespace std;
struct element
{
int entier;
struct element * suivant;
};
et aucune méthode dans élément ? Pas de constructeur ?
ça ressemble à du C, ça.
void ajout (element*);
void affichage(element*);
ah oui, je confirme c'est du C.
void main()
{
element *premier;
premier=NULL;
ajout(premier);
ajout (premier);
affichage(premier);
}
void ajout(element * ptr)
{
element *inter=new element;
int asaisir;
cout<<"donner votre element : "<<"n";
cin>>asaisir;
inter->suivant=ptr;
inter->entier=asaisir;
ptr=inter;
}
void affichage(element * ptr)
{
element *pointeur;
pointeur=ptr;
while (pointeur->suivant!=NULL)
{
cout<<"la valeur est : "<<pointeur->entier;
pointeur=pointeur->suivant;
}
}
mais ca marche pas pkoi?
et comment s'éviter de passer premier en argument (faut il rajouter
quelquechose dans les fonctions pour dire que la déclaration est ailleurs?
je vous remercie par avance
pourquoi ne pas tout simplement créer une classe LISTE de la manière
suivante :
class LISTE
{
struct EltLISTE
{
int element;
EltLISTE *suivant;
EltLISTE(int Elt):element(Elt),suivant(NULL){}
};
EltLISTE *Premier;
public:
~LISTE();
LISTE():Premier(NULL){}
void Ajoute(int E)
{
EltLISTE *Nouveau = new EltLISTE(E);
Nouveau->suivant = Premier;
Premier = Nouveau;
}
};
voila mon premier programme consiste à créer une liste comportant un pointeur premier pointant sur le premier element que j'initialise à NULL et j'ajoute devant
ça ressemble à un exo, ça.
voila:
#include <iostream> using namespace std;
struct element { int entier; struct element * suivant;
};
et aucune méthode dans élément ? Pas de constructeur ? ça ressemble à du C, ça.
void ajout (element*); void affichage(element*);
ah oui, je confirme c'est du C.
void main() {
element *premier; premier=NULL; ajout(premier); ajout (premier); affichage(premier);
}
void ajout(element * ptr)
{
element *inter=new element; int asaisir; cout<<"donner votre element : "<<"n"; cin>>asaisir; inter->suivant=ptr; inter->entier=asaisir; ptr=inter;
}
void affichage(element * ptr) { element *pointeur; pointeur=ptr; while (pointeur->suivant!=NULL) { cout<<"la valeur est : "<<pointeur->entier; pointeur=pointeur->suivant; }
}
mais ca marche pas pkoi? et comment s'éviter de passer premier en argument (faut il rajouter quelquechose dans les fonctions pour dire que la déclaration est ailleurs? je vous remercie par avance
pourquoi ne pas tout simplement créer une classe LISTE de la manière suivante :
class LISTE { struct EltLISTE { int element; EltLISTE *suivant; EltLISTE(int Elt):element(Elt),suivant(NULL){} }; EltLISTE *Premier; public: ~LISTE(); LISTE():Premier(NULL){} void Ajoute(int E) { EltLISTE *Nouveau = new EltLISTE(E); Nouveau->suivant = Premier; Premier = Nouveau; } };
etc...
Alexandre
"Eric Fournier" a écrit dans le message de news: MaXld.152694$
Aussi, à moins que ce ne soit pour des fins d'apprentissages, utiliser std::list réglerais tous tes problèmes.
à mon avis c'est un exercice, pour comprendre les pointeurs par ex.
"Eric Fournier" <victor.fournier@globetrotter.net> a écrit dans le message
de news: MaXld.152694$df2.137232@edtnps89...
Aussi, à moins que ce ne soit pour des fins d'apprentissages, utiliser
std::list réglerais tous tes problèmes.
à mon avis c'est un exercice, pour comprendre les pointeurs par ex.
"Eric Fournier" a écrit dans le message de news: MaXld.152694$
Aussi, à moins que ce ne soit pour des fins d'apprentissages, utiliser std::list réglerais tous tes problèmes.
à mon avis c'est un exercice, pour comprendre les pointeurs par ex.
kanze
"jmarc" wrote in message news:<4197ba23$0$25365$...
voila mon premier programme consiste à créer une liste comportant un pointeur premier pointant sur le premier element que j'initialise à NULL et j'ajoute devant
Plusieurs commentaires -- la plupart ne sont que des détails, mais qu'il vaut mieux connaître, mais le dernier est fondamental.
voila:
#include <iostream>
Il te faut aussi un :
#include <ostream> #include <istream>
L'en-tête <iostream> ne fait que déclarer les objets std::cin, etc., et non les opérateurs sur ces objets.
using namespace std;
struct element { int entier; struct element * suivant; };
void ajout (element*); void affichage(element*);
void main()
Le type de retour de main doit être int.
{ element *premier; premier=NULL; ajout(premier); ajout (premier); affichage(premier); }
void ajout(element * ptr) { element *inter=new element; int asaisir; cout<<"donner votre element : "<<"n"; cin>>asaisir;
Il y a beaucoup à dire au sujet de la gestion des erreurs. Mais j'imagine que ce n'est pas le but de l'exercise.
Tu affectes une variable locale, puis tu quittes la fonction. Ça sert à rien.
A priori, c'est là ton problème. Les paramètres en C++ se passe par valeur, et sont des variables locales de la fonction appelée. Du coup, tu ajoute le nouvel élément à une copie de la liste, copie qui cesse d'exister dès que tu quittes la fonction. Et la liste initiale reste vide.
Si tu veux modifier ce que tu passes comme paramètre, il faut déclarer le paramètre comme référence, donc :
void ajout( element*& teteDeListe ) ...
(Aussi, il vaut mieux aussi utiliser les noms avec une signification réele. Je sais que le paramètre est un pointeur, à cause du *. Mais un pointeur à quoi ? L'élément à ajouter, la tête de la liste, ...)
}
void affichage(element * ptr) { element *pointeur; pointeur=ptr;
Pourquoi la variable supplémentaire ? Un paramètre fait partie des variables de la fonction. Tu pourrais donc travailler directement sur ptr.
while (pointeur->suivant!=NULL)
Deux choses : - Que se passe-t-il si tu passes une liste vide, c-à-d si tu appelles affichage avant de jamais avoir appelé ajout ? Déréférencer un pointeur NULL est interdit, et sur la plupart des machines modernes, provoque un core dump (ou son équivalent Windows). - Même si la liste n'est pas vide, tu ne vas jamais visiter le dernier élément, parce que ta condition, c'est tant qu'il y a un élément qui suit.
L'idiome classique ici, c'est :
while ( ptr != NULL ) { // Fait quelque chose avec l'élément, c-à-d ptr->... ptr = ptr->suivant ; }
Certains préfère même encapsuler toute la gestion de la boucle en tête, avec un for :
{ cout<<"la valeur est : "<<pointeur->entier; pointeur=pointeur->suivant; } }
mais ca marche pas pkoi?
Ça ne marche pas, comment ? Il y a un crash ? Ou ça n'affiche pas ce que tu attends ? S'il y a un crash, quand ?
et comment s'éviter de passer premier en argument (faut il rajouter quelquechose dans les fonctions pour dire que la déclaration est ailleurs?
La plupart du temps, en C++, on ferait une fonction membre, de façon à ce que ce soit le compilateur qui passe le paramètre. Mais plus important : pourquoi exactement cette question ? On peut déclarer des variables globales, de façon à ce que la fonction les connaisse sans qu'on les passe comme paramètre. Mais alors, qu'est-ce qui se passe si on veut plus d'une liste ? La plupart du temps, ce qu'on veut, c'est que la fonction ne connaît que ce qu'on lui passe comme paramètre. C'est le b a ba de l'encapsulation.
-- James Kanze GABI Software http://www.gabi-soft.fr Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
"jmarc" <jean.marc.cholet@wanadoo.fr> wrote in message
news:<4197ba23$0$25365$8fcfb975@news.wanadoo.fr>...
voila mon premier programme consiste à créer une liste comportant un
pointeur premier pointant sur le premier element que j'initialise à
NULL et j'ajoute devant
Plusieurs commentaires -- la plupart ne sont que des détails, mais qu'il
vaut mieux connaître, mais le dernier est fondamental.
voila:
#include <iostream>
Il te faut aussi un :
#include <ostream>
#include <istream>
L'en-tête <iostream> ne fait que déclarer les objets std::cin, etc., et
non les opérateurs sur ces objets.
using namespace std;
struct element
{
int entier;
struct element * suivant;
};
void ajout (element*);
void affichage(element*);
void main()
Le type de retour de main doit être int.
{
element *premier;
premier=NULL;
ajout(premier);
ajout (premier);
affichage(premier);
}
void ajout(element * ptr)
{
element *inter=new element;
int asaisir;
cout<<"donner votre element : "<<"n";
cin>>asaisir;
Il y a beaucoup à dire au sujet de la gestion des erreurs. Mais
j'imagine que ce n'est pas le but de l'exercise.
Tu affectes une variable locale, puis tu quittes la fonction. Ça sert à
rien.
A priori, c'est là ton problème. Les paramètres en C++ se passe par
valeur, et sont des variables locales de la fonction appelée. Du coup,
tu ajoute le nouvel élément à une copie de la liste, copie qui cesse
d'exister dès que tu quittes la fonction. Et la liste initiale reste
vide.
Si tu veux modifier ce que tu passes comme paramètre, il faut déclarer
le paramètre comme référence, donc :
void ajout( element*& teteDeListe ) ...
(Aussi, il vaut mieux aussi utiliser les noms avec une signification
réele. Je sais que le paramètre est un pointeur, à cause du *. Mais un
pointeur à quoi ? L'élément à ajouter, la tête de la liste, ...)
}
void affichage(element * ptr)
{
element *pointeur;
pointeur=ptr;
Pourquoi la variable supplémentaire ? Un paramètre fait partie des
variables de la fonction. Tu pourrais donc travailler directement sur
ptr.
while (pointeur->suivant!=NULL)
Deux choses :
- Que se passe-t-il si tu passes une liste vide, c-à-d si tu appelles
affichage avant de jamais avoir appelé ajout ? Déréférencer un
pointeur NULL est interdit, et sur la plupart des machines modernes,
provoque un core dump (ou son équivalent Windows).
- Même si la liste n'est pas vide, tu ne vas jamais visiter le dernier
élément, parce que ta condition, c'est tant qu'il y a un élément qui
suit.
L'idiome classique ici, c'est :
while ( ptr != NULL ) {
// Fait quelque chose avec l'élément, c-à-d ptr->...
ptr = ptr->suivant ;
}
Certains préfère même encapsuler toute la gestion de la boucle en tête,
avec un for :
{
cout<<"la valeur est : "<<pointeur->entier;
pointeur=pointeur->suivant;
}
}
mais ca marche pas pkoi?
Ça ne marche pas, comment ? Il y a un crash ? Ou ça n'affiche pas ce que
tu attends ? S'il y a un crash, quand ?
et comment s'éviter de passer premier en argument (faut il rajouter
quelquechose dans les fonctions pour dire que la déclaration est
ailleurs?
La plupart du temps, en C++, on ferait une fonction membre, de façon à
ce que ce soit le compilateur qui passe le paramètre. Mais plus
important : pourquoi exactement cette question ? On peut déclarer des
variables globales, de façon à ce que la fonction les connaisse sans
qu'on les passe comme paramètre. Mais alors, qu'est-ce qui se passe si
on veut plus d'une liste ? La plupart du temps, ce qu'on veut, c'est que
la fonction ne connaît que ce qu'on lui passe comme paramètre. C'est le
b a ba de l'encapsulation.
--
James Kanze GABI Software http://www.gabi-soft.fr
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
"jmarc" wrote in message news:<4197ba23$0$25365$...
voila mon premier programme consiste à créer une liste comportant un pointeur premier pointant sur le premier element que j'initialise à NULL et j'ajoute devant
Plusieurs commentaires -- la plupart ne sont que des détails, mais qu'il vaut mieux connaître, mais le dernier est fondamental.
voila:
#include <iostream>
Il te faut aussi un :
#include <ostream> #include <istream>
L'en-tête <iostream> ne fait que déclarer les objets std::cin, etc., et non les opérateurs sur ces objets.
using namespace std;
struct element { int entier; struct element * suivant; };
void ajout (element*); void affichage(element*);
void main()
Le type de retour de main doit être int.
{ element *premier; premier=NULL; ajout(premier); ajout (premier); affichage(premier); }
void ajout(element * ptr) { element *inter=new element; int asaisir; cout<<"donner votre element : "<<"n"; cin>>asaisir;
Il y a beaucoup à dire au sujet de la gestion des erreurs. Mais j'imagine que ce n'est pas le but de l'exercise.
Tu affectes une variable locale, puis tu quittes la fonction. Ça sert à rien.
A priori, c'est là ton problème. Les paramètres en C++ se passe par valeur, et sont des variables locales de la fonction appelée. Du coup, tu ajoute le nouvel élément à une copie de la liste, copie qui cesse d'exister dès que tu quittes la fonction. Et la liste initiale reste vide.
Si tu veux modifier ce que tu passes comme paramètre, il faut déclarer le paramètre comme référence, donc :
void ajout( element*& teteDeListe ) ...
(Aussi, il vaut mieux aussi utiliser les noms avec une signification réele. Je sais que le paramètre est un pointeur, à cause du *. Mais un pointeur à quoi ? L'élément à ajouter, la tête de la liste, ...)
}
void affichage(element * ptr) { element *pointeur; pointeur=ptr;
Pourquoi la variable supplémentaire ? Un paramètre fait partie des variables de la fonction. Tu pourrais donc travailler directement sur ptr.
while (pointeur->suivant!=NULL)
Deux choses : - Que se passe-t-il si tu passes une liste vide, c-à-d si tu appelles affichage avant de jamais avoir appelé ajout ? Déréférencer un pointeur NULL est interdit, et sur la plupart des machines modernes, provoque un core dump (ou son équivalent Windows). - Même si la liste n'est pas vide, tu ne vas jamais visiter le dernier élément, parce que ta condition, c'est tant qu'il y a un élément qui suit.
L'idiome classique ici, c'est :
while ( ptr != NULL ) { // Fait quelque chose avec l'élément, c-à-d ptr->... ptr = ptr->suivant ; }
Certains préfère même encapsuler toute la gestion de la boucle en tête, avec un for :
{ cout<<"la valeur est : "<<pointeur->entier; pointeur=pointeur->suivant; } }
mais ca marche pas pkoi?
Ça ne marche pas, comment ? Il y a un crash ? Ou ça n'affiche pas ce que tu attends ? S'il y a un crash, quand ?
et comment s'éviter de passer premier en argument (faut il rajouter quelquechose dans les fonctions pour dire que la déclaration est ailleurs?
La plupart du temps, en C++, on ferait une fonction membre, de façon à ce que ce soit le compilateur qui passe le paramètre. Mais plus important : pourquoi exactement cette question ? On peut déclarer des variables globales, de façon à ce que la fonction les connaisse sans qu'on les passe comme paramètre. Mais alors, qu'est-ce qui se passe si on veut plus d'une liste ? La plupart du temps, ce qu'on veut, c'est que la fonction ne connaît que ce qu'on lui passe comme paramètre. C'est le b a ba de l'encapsulation.
-- James Kanze GABI Software http://www.gabi-soft.fr Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
