Discussion :

[MicroOnde]

Bonjour,
Voila je suis �tudiant en premi�re ann�e de DUT, et dans le cadre de mes r�visions j'essaie de cr�er les commandes Unix en C++.
Or me voici face a un probl�me que je ne peux r�soudre seul.
C'est pourquoi je demande votre aide, pour la r�alisation de la commande Sort.
Tout d'abord, il y a une erreur au niveau de la ligne 39 que je n'arrive pas a r�soudre.
Et par la m�me occasion, Comment faire pour que le programme utilise l'entr�e standard, pour affecter les variables, qui au pr�alable doivent �tre au nombre d�sir� par l'utilisateur.

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
 
#include <iostream>
#include <string>
#include <vector>
using namespace std;
////////////////////////////////////////////////////////////////
class phrase
   {
   private:
      string texte;
      public:
//--------------------------------------------------------------
//--------------------------------------------------------------
   void displayphrase()
      {
      cout << texte;
      }
//--------------------------------------------------------------
   string getLast()  
      { return texte; }
   }; //end class phrase
////////////////////////////////////////////////////////////////
class ArrayInOb                 // L'erreur survient ici !!
   {
   private:
      vector<phrase*> v;        
      int nElems;                
   public:
//--------------------------------------------------------------
   ArrayInOb(int max) : nElems(0)  
      {
      v.resize(max);              
      }
//--------------------------------------------------------------
 
   void insert(string txt)
      {
      string texte;
      v[nElems] = new phrase(texte);
      nElems++;       
      }
//--------------------------------------------------------------
   void display()              
      {
      for(int j=0; j<nElems; j++)    
         v[j]->displayphrase();     
 
      }
//--------------------------------------------------------------
   void insertionSort()
      {
      int in, out;
      for(out=1; out<nElems; out++)
         {
         phrase* temp = v[out];     
         in = out;                 
 
         while( in>0 && v[in-1]->getLast() > temp->getLast() )
            {
            v[in] = v[in-1];      
            --in;                  
            }
         v[in] = temp;            
         } //end for
      } //end insertionSort()
//--------------------------------------------------------------
   }; //end class ArrayInOb
////////////////////////////////////////////////////////////////
int main()
      {
      int i,j;
      int maxSize = 100;  
      ArrayInOb arr(maxSize);   
 
     //create array
 
 
      arr.insert("John");
      arr.insert("Smith");
      arr.insert("Edward");
      arr.insert("Yee");
 
      cout << "Before sorting:" << endl;
      arr.display();               
      arr.insertionSort();     
      cout << "After sorting:" << endl;
      arr.display();           
      return 0;
}

Merci de votre aide

[hijackMe]

Salut MicroOnde !
Pour commencer, indente ton code J'ai les yeux qui piquent !
Ensuite pourrais-tu copier/coller l'erreur que te signale ton compilateur ?

Pour l'utilisation de l'entr�e standard, je comprend pas trop... Tu veux que l'utilisateur rentre lui-m�me la valeur des variables ?

P.S : Il me semble d'ailleurs que l'entr�e standard est le clavier.

[koala01]

Salut, et bienvenue sur le forum (� tous les deux )

Salut MicroOnde !
Pour commencer, indente ton code J'ai les yeux qui piquent !

Il s'�tait simplement tromp� de bouton:

Il y a le bouton qui place une balice CODE (c'est le #) et, juste � cot�, il y a le bouton "citation" (QUOTE) qui a la forme d'un phylact�re...

Cela ne vaut pas la peine de l'engueuler ainsi (d'autant plus que les mod�rateurs veillent au grain)

Bon, je vais maintenant essayer de voir les diff�rents probl�mes

[hijackMe]

Salut, et bienvenue sur le forum (� tous les deux )
Il s'�tait simplement tromp� de bouton:

Il y a le bouton qui place une balice CODE (c'est le #) et, juste � cot�, il y a le bouton "citation" (QUOTE) qui a la forme d'un phylact�re...

Cela ne vaut pas la peine de l'engueuler ainsi (d'autant plus que les mod�rateurs veillent au grain)

Oups autant pour moi !
Mais je ne l'ai pas engueul�, c'�tait juste un conseil au cas o� il ne le ferait pas (j'en ai quelques exemples dans ma classe )

[nikko34]

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
 
   void insert(string txt)
      {
      string texte;
      v[nElems] = new phrase(texte);
      nElems++;       
      }

d�j� �a �a va pas faire grand chose

[koala01]

Cet interlude sur les diff�rentes balises dont on dispose �tant fini, je me pose quand m�me quelque questions peut �tre idiotes, mais...

Pourquoi vouloir g�rer des pointeurs de type phrases dans ta classe ArrayInOb au lieu de, tout simplement, utiliser... des instances de phrases

En effet, telle qu'elle est pr�sent�e, ta classe ArrayInOb pose un grave probl�me de... fuite m�moire: Tu alloue dynamiquement de la m�moire pour chaque �l�ment que tu souhaite y ajouter, mais, cette m�moire n'est jamais lib�r�e...

Je sais bien que les syst�mes actuels proposent de plus en plus de m�moire, mais il ne faut pas oublier que, tr�s souvent, ton application ne sera pas la seule � fonctionner sur l'ordinateur ... Il reste donc malgr� tout tr�s important d'�viter d'en gaspiller, car, t�t ou tard, ton application finira par fait planter le syst�me de mani�re irr�m�diable

La solution serait donc, au minimum, de d�finir le destructeur de ta classe ArrayInOb, sous une forme proche de

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
ArrayInOb ::~ArrayInOb()
{
    for(vector<phrase*>::iterator it=v.begin(); it!=v.end();++it)
        delete (*it);
}

mais cela ne r�soudrait qu'� moiti� le probl�me, car, telle qu'elle est l�, ta classe ArrayInOb est... assignable et copiable, avec comme r�sultat qu'il est donc possible que deux instances diff�rentes de ArrayInOb partagent certains pointeurs.

Si, par exemple, tu cr�es une copie de l'instance ("d'origine") de ta classe ArrayInOb, tu te trouvera dans une m...de noire lorsque la copie (ou l'instance d'origine) sera d�truite: les pointeurs contenus dans l'instance "survivante" pointeront vers... une adresse d�j� lib�r�e.

Les probl�mes que peut engendrer cette situation sont multiples:

1. Toute tentative d'acc�s � un des �l�ments de l'instance survivante enverra le processeur "cueillir des p�querettes" (qui r�agira sans doute en lan�ant une erreur de segmentation).
2. Lorsque l'instance survivante sera � son tour d�truite, il y aura ce que l'on appelle une "double tentative de lib�ration de la m�moire" (ben oui, l'adresse point�es par les diff�rents �l�ments a d�j� �t� lib�r�e lorsque la premi�re instance a �t� d�truite )

Il n'est pas impossible de r�soudre ces probl�mes, � condition de red�finir �galement le constructeur par copie et l'op�rateur d'affectation (ou de choisir la solution inverse qui consiste � interdire la copie et l'affectation), mais c'est, finalement, se faire du mal pour rien

En effet, une bonne pratique � garder � l'esprit consiste � n'utiliser les pointeurs que... quand on n'a pas d'autre choix, par exemple, parce que l'on veut g�rer une collection d'objets polymorphes, en les faisant passer pour leur "type de base".

Dans le cas pr�sent, la classe phrase n'est absolument pas polymorphe, et tu n'as donc aucun besoin de la g�rer comme telle (de lui donner une "s�mantique d'entiter").

Par contre, il serait sans doute int�ressant de donner un constructeur prenant... une (r�f�rence constante sur) std::string � ta classe phrase.

En effet, il existe un principe nomm� RAII qui conseille de faire en sorte qu'une instance de classe soit directement initialis�e correctement...

Et c'est d'autant plus vrai que, autrement, tu ne dispose d'aucun moyen de... d�finir la valeur de texte

Au passage, il y a un principe qui s'appelle "const correctness" qui conseille de d�clarer constant tout ce qui ne doit pas �tre modifi�.

Par exemple, il est int�ressant de d�clarer les fonctions membres d'une classe qui ne modifient pas l'objet au d�part duquel elles sont invoqu�es comme fonctions constantes.

En effet, il est tout � fait possible d'appeler une fonction constante depuis un objet qui ne l'est pas, mais il est par contre interdit d'appeler une fonction non constante depuis un objet qui l'est.

Au final, ta classe phrase pourrait ressembler � quelque chose comme:

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
class phrase
{
    public:
        /* le constructeur */
        phrase(std::string const & t):texte(t){}
        /* ces deux fonctions ne modifient pas l'objet et peuvent donc
         * être appelées depuis des objets constants :D
         */
        void displayphrase() const 
       {
            cout << texte;
       }
       /* je m'interroge sur le nom de cette fonction...
        * Si on traduit, elle signifie "prendre le dernier", mais le dernier quoi???
        * il n'y a qu'une chaine, comment pourrait il y en avoir
        * ... une dernière??
        */
       std::string const & getLast() const { return texte; }
    private:
        std::string texte;
}

Ce n'est d'ailleurs qu'un d�tail, mais plut�t que de d�finir une fonction displayphrase, pourquoi ne pas red�finir... l'op�rateur << de manipulation de flux

Cela pourrait prendre la forme de

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
std::ostream & operator << (ostream & ofs, phrase const & p)
{
    ofs<<p.getLast();
    return ofs;
}

Et je reviens maintenant sur la fameuse classe ArrayInOb, car, jusqu'� pr�sent, je n'ai fait que parler de mani�re g�n�rale � son sujet...

Il faut par exemple savoir que la classe std::vector (comme toutes les collections fournies par la STL d'ailleurs) dispose... d'une fonction membre size() qui permet... de connaitre le nombre d'�l�ment qu'elles contiennent.

Cela implique que, au minimum, ta logique est invers�e par rapport � ce que tu souhaites faire, et qu'elle est m�me fausse si on y regarde d'un peu plus pr�s

En effet, si j'ai bien compris, tu veux limiter le nombre de phrases qu'une instance de ArrayInOb peut avoir.

J'ai d�j� du mal � comprendre pour quoi, mais, nous dirons que cela fait encore partie des choses que je peux accepter

Par contre, ce qui me chagrine, c'est que tu ne v�rifie absolument pas, dans la fonction insert, que tu n'aies pas d�pass� cette valeur.

Autrement dit, si tu n'es pas assez attentif, il arrivera fatalement un moment o�... tu arrivera � "taper" en dehors des �l�ments pr�vus pour ton vecteur, et ca, ca occasionnera, au mieux, des r�sultats inconsistants

De plus, il faut savoir que la classe vector (comme toutes les collections fournies par la STL, d'ailleurs) dispose d'une fonction qui ... permet de savoir combien d'�l�ments sont dans la collection: la fonction size().

On peut donc se dire que ta logique est, au minimum, invers�e par rapport � ce qu'il faudrait faire:

Il ne faut pas redimensionner le vector au d�part et compter "par ailleurs" le nombre d'�l�ments que tu y a mis, mais bel et bien... garder quelque part le nombre � ne pas d�passer, et se baser sur la taille du vector pour voir si on peut encore ajouter un �l�ment (si tant est qu'il soit effectivement opportun de limiter le nombre d'�l�ments, ce sur quoi je r�p�te avoir un gros doute ).

Au final, ta classe ArrayInOb devrait plut�t ressembler,
pour la version sans limitation de phrase �:

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
class ArrayInOb
{
    public:
        ArrayInOb(){}
        void insert(std::string const & s)
        {
            /* je profite du constructeur que j'ai rajouté :D */
            v.push_back(phrase(s));
        }
        void display()              
        {
            /* il y a d'autres possibilités, basées sur les itérateurs et
             * même (avec la nouvelle norme en cours de finalisation)
             * quelques trucs très sympa :D
             */
            for(int j=0; j<v.size(); j++)    
                 v[j]->displayphrase();     
         }
    private:
        std::vector<phrase> v;
};

et, pour sa version avec une limitation:

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
class ArrayInOb
{
    public:
        /* il vaut mieux utiliser size_t car le nombre d'élément sera d'office...
         * positif :D
         */
        ArrayInOb(size_t m):m(m){}
        void insert(std::string const & s)
        {
            /* je profite du constructeur que j'ai rajouté :D */
            if(v.size()<m)
                v.push_back(phrase(s));
        }
        void display()
        {
            /* il y a d'autres possibilités, basées sur les itérateurs et
             * même (avec la nouvelle norme en cours de finalisation)
             * quelques trucs très sympa :D
             */
            for(size_t j=0; j<v.size(); j++)
                 v[j].displayphrase();
         }
    private:
        std::vector<phrase> v;
        size_t m;
};

ET pour terminer ce "roman", je voudrais enfin m'attaquer �... ta fonction insertionSort...

Je ne suis vraiment pas sur que l'insertion sort soit... le meilleur moyen de trier ta collection...

Il existe en effet des algorithmes tout pr�t qui ne demandent qu'� servir (dans le fichier d'en-t�te fourni par le standard sous le nom de... algorithm ), dont un algorithme nomm�... sort.

Tout ce qu'il lui faut, c'est le moyen de d�terminer si un objet est strictement plus petit qu'un autre.

Le plus facile pour y arriver consiste, simplement, � d�finir l'op�rateur plus petit que "<" pour le type manipul�:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
bool operator<(phrase const & p1, phrase const & p2)
{
    return p1.getLast()<p2.getLast();
}

et nous pourrions donc avoir une fonction (membre de ArrayInOb) proche de

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
void ArrayInOb::sort()
{
    std::sort(v.begin(),v.end());
}

Nous pourrions aussi nous baser sur ce que l'on appelle un foncteur, ce qui nous donnerait 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
struct comPhrase
{
    bool oprator()(phrase const & p1, phrase const & p2)
    {
        return p1.getLast()<p2.getLast();
    }
};
void ArrayInOb::sort()
{
    std::sort(v.begin(),v.end(), compPhrase());
}

Et, enfin, si ce qui t'int�resse plus que tout, ce sont les valeurs tri�es, il est peut �tre int�ressant d'envisager de g�rer les phrases avec une autre collection... le std::set ou le std::multiset, par exemple

[MicroOnde]

Et bien, merci beaucoup koala01, j'imagine pas le temps que �a a du te prendre

Je vais regarder et corriger tout cela minutieusement, je te tiens au courant