Discussion :

[Knarf64]

Salut a tous ,

Le titre est volontairement racoleur
Voici donc le souci : J'ai une liste de Station, que j'arrive a afficher quand d'appel la méthode depuis une de ces instances ( station) .
Cependant quand j'essai d'appeler cette méthode depuis des Station contenu dans une LIST , ca ne fonctionne plus. et je suis obligé de faire une liste de pointeur de stations, pourquoi donc ? .

Voici le code :
La classe Station : constructeur et afficheur :

Code :

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

1
2
3
4
5
6
7
8
class Station
{
    public:
        int id ;
        int cycleCourant ; // TEMPS
        Conteneur* conteneurCourant ;
        Operateur* operateurCourant ;
// ETC ......

Ce code marche quand je l'appel depuis une station , donc ca vient pas de là.
Et voici le parcours de la liste :

Code :

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

1
2
3
4
5
6
7
8
9
list<Station> *sta = new list<Station>() ;
sta->push_front(*station1) ;
sta->push_front(*station2) ;
 
 list<Station>::iterator it = sta->begin() ;
    for (it ; it != sta->end() ; it++)
    {
        it->affichageTotal();
    }

Voici ce qui en résulte :
Station0: vide
Station0: vide
Au lieu d'afficher les id 1 et 2 , ca affiche 0. Il considere que ces instances sont vides , mais pourquoi , il est capable de copier une Station et la caser dans la liste normalement non ?

Merci a ceux qui me donneront la réponse.

[koala01]

Salut,

Attention à ce que tu fais: tu déclare... un pointeur sur une liste de station et non une liste de pointeurs sur station, voila qui est différemment pas pareil

La meilleure preuve (je présumes que station1 et station2 sont déclarées sous la forme de Station * station1 = new Station), c'est que tu demande de prendre... ce qui est pointé par station1 et station2

Or, il n'y a, a priori, aucune raison de déclarer station1 et station2 comme étant des pointeurs (et donc de recourir à l'allocation dynamique de la mémoire pour ces deux variables), et il y en a encore moins de faire pareil avec la liste.

De toute évidence, tu te "plante", simplement, dans ton code, qui devrait sans doute ressembler à :

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
int main()
{
    /* création d'une liste de stations */
    std::list<Station> la_liste;
    /* création d'une première station ...*/
    Station s1;
    /* ... définition de ses membres, à ta charge ... */
    /* ... et insertion dans la liste */
    la_liste.push_back(s1);
    /* faire pareil pour les autres */
    /* parcours des éléments */
    list<Station>::iterator it = sta->begin() ;
    for (it ; it != sta->end() ; it++)
    {
        (*it).affichageTotal();
    }
    return 0;
}

[Knarf64]

Je comprends bien le principe de mon erreur : en fait je passe par des pointeurs pour ensuite utiliser ce qu'il pointe, ce qui est idiot.
Mais de là a ce que ca empêche la list d'afficher correctement le contenu je comprends tjrs pas.

J'ai essayé ce code - ci , l'affichage craint tjrs :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
    // Station
    Station station1 ;
    station1.id = 1 ;
    // Liste
    list<Station> sta  ;
    sta.push_front(station1) ;
    // parcours
    list<Station>::iterator it = sta.begin() ;
    for (it ; it != sta.end() ; it++)
    {
        (*it).affichageTotal();
    }
 cout << "Station 1 ID  : " << station1.id <<endl ;

Affichage :
Station0 : vide
Station 1 ID : 1

Comment ca se fait qu'il ne produise pas la meme chose pour une instance dans et hors de la liste ?

ps : code d'affichage

Code :

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

1
2
3
4
5
6
7
8
void Station::affichageTotal()
{
        cout << "Station" << this->id ;
        if (this->operateurCourant != NULL ){cout << ": Operateur" << this->operateurCourant->id ;}
        if (this->conteneurCourant != NULL ){cout << " , Conteneur" << this->conteneurCourant->id ;}
        if  ( (this->conteneurCourant == NULL ) && (this->operateurCourant == NULL ) )
        {cout << " : Vide" ;} cout << endl;
}

[3DArchi]

Salut,
LE problème est ailleurs. En reprenant les éléments que tu proposes, j'obtiens bien le bon comportement :

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
#include <iostream>
#include <list>
 
using std::cout;
using std::endl;
using std::list;
 
class Station
{
    public:
        int id ;
 
    void affichageTotal()
    {
            cout << "Station" << this->id ;
            cout << endl;
    }
};
 
int main()
{
 
    Station station1 ;
    station1.id = 1 ;
    // Liste
    list<Station> sta  ;
    sta.push_front(station1) ;
    // parcours
    list<Station>::iterator it = sta.begin() ;
    for (it ; it != sta.end() ; it++)
    {
        (*it).affichageTotal();
    }
    cout << "Station 1 ID  : " << station1.id<<endl;
 
     return 0;
}

produit :

Station1
Station 1 ID : 1

Aurais-tu défini un constructeur de copie ?

P.S. : new systématique c'est java ou C# mais pas C++

[Knarf64]

En virant le constructeur par copie , ça marche.Vous avez une explication ?
Merci beaucoup

[N i h i l]

En virant le constructeur par copie , ça marche.

C'est la réponse à 3DA :-).

Vous avez une explication ?

Ton constructeur par copie était erroné.

[Knarf64]

Si je veux faire une boucle qui me creer 10 stations ce code ci ne fonctionnant pas , que dois je ajouter ?

Code :

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

1
2
3
4
5
6
list<Station> stations ;
for (i = 0 ; i == nb_stations ; i ++ )
{
    Station temp = Station(i) ;
    stations.push_front(temp) ;
}

merci encore

[Arzar]

Rajoute des traces dans ta boucle tu devrais vite comprendre.

[Knarf64]

Ouais le == ca aide pas

Donc ce code marche bien

Code :

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

1
2
3
4
5
6
list<Station> stations ;
for (i = 0 ; i < nb_stations ; i ++ )
{
    Station temp = Station(i) ;
    stations.push_front(temp) ;
}

[Knarf64]

Petite question supplémentaire : il vaut mieux, dans une classe qui en contient d'autre , utiliser une list<Station> ou un pointeur de list ?
Que faut il préférer , pourquoi ?

Merci bien.

[3DArchi]

Que faut il préférer , pourquoi ?

Utiliser les listes par valeurs.

=> Car les conteneurs ont été construits pour ça. Ils encapsulent la gestion des pointeurs sous-jacentes. Ils ont une sémantique de valeur. L'allocation dynamique ne t'apporte rien dans ce cas
Et d'une façon plus générale:
=> Car l'utilisation correcte des pointeurs est complexe et souvent source d'erreur.


Et puis : pourquoi vouloir utiliser un pointeur ? Qu'est ce que cela t'apportera ?

[Knarf64]

J'etais partie sur les pointeurs par intuition. effectivement, mauvaise idée.
Mais là j'ai un cas ou ca devrait m'être utile :

Une station peut contenir
1 operateur et 1 conteneur , mais on peut aussi vider la station.
Dans ce cas j'etais parti sur des pointeurs d'operateur et de conteneur, je les mets a null quand la station est vidée et je rempli quand il faut remplir. Mais comme tu dis , c'est source de pas mal d'erreur notamment, quand je rempli, il me change le contenu de mes objets.

Par exemple j'affiche les données d'un conteneur , ca me donne A , je fais une affectation vers une station , et je redemande les données via la station , ca me sort B . Ca doit évidement venir de ma manière d'affecter avec les pointeurs.

Donc je pose la question, y'a t il un moyen avec des objets par valeur ( plus de pointeurs donc ) de simuler le vide ( NULL n'etant pas faisable) ? ou suis - je obliger de conserver mes pointeurs, si c'est le cas , je vais vous link la manière dont j'affecte mes objets a ma station pour que vous m'indiquiez ce qui cloche.

Je sais pas si j'ai été très clair. Dites moi. Merci encore.

[Knarf64]

Pour gagner du temps , je vais poser le problème que j'ai cité plus haut, celui de la manipulation de mes pointeur sur conteneur et opérateur.

Voici la hiérarchie : Atelier contient Stations ( une liste ) , liste contient un pointeur vers un Conteneur et un Operateur. L'affichage d'atelier se fait en parcourant chaque station et demandant a chacune de s'afficher, l'affichage de station affiche l'id du conteneur et de l'opérateur, ou "vide" si les pointeurs sont null.

Problématique : J'aimerai pouvoir affecter des conteneurs et opérateur a une station depuis atelier.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
bool Atelier::affecterConteneurEtOperateurAStation(Conteneur&  c , Operateur& o , Station& s)
{
    // on déplace le conteneur
    this->addConteneur(c , s) ;
    this->ze->freeConteneur(c) ;
    // on déplace l'operateur
    this->addOperateur(o , s) ;
    this->zr->freeOperateur(o) ;
    return true ;
}

Je vais mettre uniquement les code lié a l'ajout d'un conteneur , car le probleme est sans doute lememe pour les deux objets, et le free marche.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
bool Atelier::addConteneur(Conteneur& c , Station& s)
{
    list<Station>::iterator it = this->stations.begin() ;
    for(it ; it!= this->stations.end() ; it++ )
    {
        if(it->id == s.id)
        {
            return s.addConteneur(c);
        }
    }
    return false ;
}

Code :

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

1
2
3
4
5
6
7
8
9
bool Station::addConteneur(Conteneur& c)
{
    if (this->conteneurCourant == NULL)
    {
        this->conteneurCourant = &c ;
        return true ;
    }
    return false ;
}

Bon, a priori rien de bien compliqué, et pourant quand je demande a la fin de tout cela , depuis le main, de m'afficher le contenu de l'atelier, il parcours chaque station et verifie que leur pointeur ne soient pas null pour m'afficher leur conteneurs/Operateurs . Et il me dit "Vide", considerant que ma station conserve ses pointeurs a null. Je comprends pas.

j'ai voulu débuggé :
A la fin de la méthode Atelier::affecterConteneurEtOperateurAStation
On a bien la station a l'@0x28fe7c qui passe son pointeur de conteneur de 0x0 à 0x28fe08.
(dans les deux méthodes par lesquelles elle passe, l'@ de la station reste la même) .

Quand on revient dans le main, la station passée en paramètre affecterConteneurEtOperateurAStation(....) a pour pointeur sur conteneur 0x28fe08 et malgré tout , le test != NULL reste false a l'affichage.

Je ne trouve pas de solutions.Dites moi si vous oui

Merci encore.

[Knarf64]

Voici le main :

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
    // Qualifications :
    Qualification q1(1,10) ;
    Qualification q2(2 , 20) ;
 
    // Operateurs :
    Operateur op1(1) ;
    Operateur op2(2) ;
        // remplissage
        op1.qualifications.push_back(q1);
        op2.qualifications.push_back(q2);
 
    // Station
    Station st1(1) ;
        st1.qualifications.push_front(q1) ;
    Station st2(2) ;
        st2.qualifications.push_front(q2) ;
 
    // Conteneur
    Conteneur c1(1 ,28) ;
        c1.ajouterQualification(q1) ;
        c1.calculerPriorite() ;
    Conteneur c2(2 ,30 ) ;
        c2.ajouterQualification(q2) ;
        c2.calculerPriorite() ;
 
    //PLACER DANS ZONES :
        // Zone entree
        ZoneEntree zoneEntree ;
        zoneEntree.addConteneur(c1) ;
        zoneEntree.addConteneur(c2) ;
        // Zone Stockage
        ZoneStockage zoneStockage ;
        // Zone Repos
        ZoneRepos zoneRepos  ;
        zoneRepos.addOperateur(op1) ;
        zoneRepos.addOperateur(op2) ;
 
        // Atelier
        list<Station> stationsAtelier ;
        stationsAtelier.push_back(st1) ; stationsAtelier.push_back(st2) ;
 
 
    // Affichage des zones
    zoneEntree.affichageTotal() ; cout <<endl;
    zoneRepos.affichageTotal() ; cout <<endl;
    zoneStockage.affichageTotal() ;
 
    // Atelier
    Atelier atelier(&zoneRepos , &zoneEntree  , &zoneStockage , stationsAtelier) ; // rempli par sta
 
 
    // TEST AFFECTATION
    atelier.affichageTotal() ;  cout <<endl;
    atelier.affecterConteneurEtOperateurAStation(c1 , op1  , st1) ;
    cout <<" Apres affectation" <<endl;
    atelier.affichageTotal() ;

Je vous mets aussi l'affichage d'une station :

Code :

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

1
2
3
4
5
6
7
8
 void Station::affichageTotal()
{
        cout << "Station " << this->id << " : "<< endl ;
        if (this->operateurCourant != NULL ){this->operateurCourant->affichageTotal() ;}
        if (this->conteneurCourant != NULL ){this->conteneurCourant->affichageTotal() ;}
        if ((this->conteneurCourant == NULL ) && (this->operateurCourant == NULL ) )
        {cout << " Vide" ;} cout << endl;
}

Concernant ce qui se passe au niveau de la console :

Zone Entree :
Conteneur 1 : de prio2.8
Conteneur 2 : de prio1.5

Zone Repos :
Operateur : 1
Operateur : 2

Zone Stockage :
Vide
Atelier :
Station 1 :
Vide
Station 2 :
Vide
Apres affectation
Atelier :
Station 1 :
Vide
Station 2 :
Vide

----------------
Ce qui devrai y a voir dans l'atelier : Station 1 : operateur 1 et conteneur 1 qui ont étés déplacés de leur zone ( ça ça fonctionne) mais pas replacé dans l'atelier.

Merci a ceux qui répondront après un tel pavé

[3DArchi]

Salut,

Donc je pose la question, y'a t il un moyen avec des objets par valeur ( plus de pointeurs donc ) de simuler le vide ( NULL n'etant pas faisable) ?

Tu peux utiliser une aide pour la gestion de tes pointeurs : std::shared_ptr ou std::unique_ptr (ou leur équivalent boost si tu n'as pas un compilateur TR1 ou C++0x) selon la politique de gestion de ton pointeur par la classe peuvent t'aider à utiliser les pointeurs comme des valeurs.

[Knarf64]

J'ai finalement reglé le problème en virant tous les pointeurs
le souci que j'ai constaté aussi, dite moi si je me trompe :

Si je prend un objet , je lui donne la caractéristique A ,
je passe ( par RÉFÉRENCE l'objet) a une fonction qui va faire une insertion de l'objet dans la structure.

Si par la suite je modifie l'objet avec une caractéristique A , et bien celui de la structure n'a pas bougé , il reste sur B. Donc malgré l'aspect , passage par reference, les insert dans les structures sont font toujours par copie.

C'est un comportement que j'ai cru constater au vu de mes erreurs de compilation, si vous pouviez confirmer, et après j'arrête de vous embêtez

Merci encore

[koala01]

Il faut comprendre que l'ensemble des conteneurs de la STL créent... des copies des objets que l'on insère dedans.

L'idéal est donc de travailler "dans l'autre sens", à savoir:

1. créer tes objets de manière temporaire et les insérer dans le conteneur (ici la liste)
2. transmettre la liste par référence (éventuellement constante), ou les itérateurs (de début, de fin, ou autre) sur ta liste à toute fonction qui aurait besoin de l'objet pour travailler, voir de passer "ce qui est pointé par" le dit itérateur par référence (éventuellement constante) à la fonction qui a besoin d'un objet particulier

Un petit exemple pour te faire commprendre

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
std::string  createString(int i)
{
    std::stringstream ss;
    ss<<"string_"<<i;
    return ss.str();
}
void modifyString(std::string & str)
{
    str+="modified";
}
void printString(std::string const & str)
{
    std::cout<<str<<std::endl;
}
int main()
{
    std::list<std::string> stringList;
    for(int i = 0; i<10;++i)
        stringList.push_back(createString(i));
    std::cout<<"first result "<<std::endl;
    for(std::list<std::string>::const_iterator it= stringList.begin();
        it!=stringList.end();++it)
        printString(*it);
    std::cout<<"we will now modify the strings"<<std::endl;
    for(std::list<std::string>::iterator it= stringList.begin();
        it!=stringList.end();++it)
        modifyString(*it);
   std::cout<<"Lets see the result"<<std::endl;
 
    for(std::list<std::string>::const_iterator it= stringList.begin();
        it!=stringList.end();++it)
        printString(*it);
    return 0;
}

L'expérience démontre en effet qu'il y a de fortes probabilités que le contenu d'un conteneur (quel qu'il soit) doive "survivre" a la fonction dans laquelle le dit contenu a été créé