Discussion :

[OXXYGENE]

Bonjour à toutes et à tous
J’essais de faire une imbrication de classes comme dans le programme. La compilation passe mais l’exécution indique un problème et s’arrête : « xyz.exe a rencontré un problème et doit fermer ». J’aimerais avoir de l’aide sur ce sujet. (je travaille sur windows XP et eclipse). Merci d'avance

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
#include <iostream.h>
#include <alloc.h>
#include <math.h>
using namespace std;
 
//========================================================
class Atom
 {public:
   float *electron; long ne; Atom (int ne0); ~Atom ();
 };
Atom::Atom (int ne0)
 { ne=ne0; 
   electron = (float*) malloc(ne*sizeof(float));
   for(int i=0; i<ne; i++) electron[i]=.031;
   }
Atom::~Atom () { /*delete[] e;*/ free(electron);}
//===========================================================================================================
class Molecule
 {public:
   Atom *nA; int ne, na;
   Molecule(int ne0, int na0); ~Molecule();
 };
Molecule::Molecule(int ne0, int na0)
{ ne=ne0; na=na0;
  nA = (Atom*) malloc(na*sizeof(Atom(ne)));
 
  for(int i=0; i<na; i++)
        	for(int j=0; j<ne; j++,nA++)
        		cout<<"\n ___ nA.e: "<<nA->electron[j];
}
Molecule::~Molecule()
 { //delete nA;
 free(nA);
 }
 
//========================================================
int main ()
 {
	Molecule m(3,5);
	return 0;
 }

[koala01]

Salut, et bienvenue sur le forum

Avant toute chose, il faut que tu prenne l'habitude de ne mettre qu'une seule instruction par ligne...

Cela facilitera énormément la (re)lecture de ton code, que ce soit celles des GI (gentils intervenants ) du forum, ou la tienne dans trois ou quatre mois

Dans la même veine, n'hésite pas à placer des accolades autour des différents "blocs" d'instructions, même si le bloc ne contient en réalité qu'une
seule instruction

Et, toujours sur le même thème, essaye de décider une bonne fois pour toute d'une "politique" de mise en forme, et de t'y tenir au moins pour la totalité du projet en cours...

Sans modifier autre chose que la "mise en forme", tu avouera que le code présenté ainsi

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
#include <iostream.h>
#include <alloc.h>
#include <math.h>
using namespace std;
 
//========================================================
class Atom
 {
    public:
        float *electron; 
        long ne; 
        Atom (int ne0); 
        ~Atom ();
 };
Atom::Atom (int ne0)
{ 
    ne=ne0; 
    electron = (float*) malloc(ne*sizeof(float));
    for(int i=0; i<ne; i++) 
        electron[i]=.031;
}
Atom::~Atom () 
{ 
    /*delete[] e;*/ 
    free(electron);
}
//=======================================================
class Molecule
{
    public:
       Atom *nA; 
       int ne;
       int na;
       Molecule(int ne0, int na0); 
       ~Molecule();
};
Molecule::Molecule(int ne0, int na0)
{ 
    ne=ne0; na=na0;
    nA = (Atom*) malloc(na*sizeof(Atom(ne)));
    for(int i=0; i<na; i++)
    {
        for(int j=0; j<ne; j++,nA++)
        {
            cout<<"\n ___ nA.e: "<<nA->electron[j];
        }
    }
}
Molecule::~Molecule()
{ 
    //delete nA;
   free(nA);
 }
 
//========================================================
int main ()
{
    Molecule m(3,5);
    return 0;
}

est tout de suite beaucoup plus lisible

Ensuite, je voudrais attirer ton attention sur le fait que les fichiers d'en-tête fournis par le standard n'utilisent plus d'extension...

Il s'agit donc normalement d'inclure <iostream> et, si tu veux inclure un fichier issu du standard C, d'utiliser la version préfixée de la lettre ..c (cmath, par exemple)

En outre, si tu tiens réellement à utiliser l'allocation dynamique, c'est bel et bien new / new[] et delete / delete[] qu'il faut utiliser...

new est à utiliser lorsque tu ne souhaite allouer dynamiquement la mémoire que pour un élément et new [] est à utiliser lorsque tu souhaite allouer dynamiquement la mémoire pour plusieurs élément... Evidemment, pour libérer la mémoire, il s'agit d'utiliser la version correspondante de delete: delete si tu as utilisé new, delete[] si tu as utilisé new[]

Mais, il faut avouer que l'idéal reste toujours de les possibilités propres au C++ à toute alternative issue du C...

Par exemple, tu reconnaitra sans problème que la gestion dynamique de la mémoire, et la gestion de pointeurs de manière générale est une source de soucis et de problèmes sans noms...

Or, il se fait que le C++ fournit, en standard, une série intéressante de conteneurs qui s'adaptent à la majorité des situations que tu peux rencontrer... Tu trouvera une entrée dans la FAQ proposant un diagramme qui te permettra de choisir le conteneur le plus adapté à tes besoins

L'utilisation de ces conteneurs est beaucoup plus sécurisante et facile que les possibilités similaires issues du C... Il n'y a donc aucune raison de ne pas les utiliser

Par exemple, le conteneur qui réagit exactement comme un tableau d'éléments contigus en mémoire alloué de manière dynamique, c'est la classe vector, disponible (à l'instar de tout ce qui est fournit par le standard) dans l'espace de noms std, par inclusion du seul fichier d'en-tête <vector>...

Un gros avantage de cette classe est cependant qu'elle sait le nombre d'éléments qui la composent

De plus, on essaye, autant que possible, d'utiliser les listes d'initialisation dans les constructeurs de classes... Cela permet d'éviter des copies inutiles

Ainsi, ta classe Atome pourrait-elle être modifiée en

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
#include <vector> /* nous avons besoin de la classe std::vector */
/* Nous aurons besoin des flux d'entrées / sorties standards (pour la
 * fonction print()) 
 */
#include <iostream>
class Atome 
{
    public:
        /* il n'est normalement pas conseillé de laisser un membre
         * publique dans une classe, mais je respecte ce que tu as fait
         * à l'origine ;) 
         */
        std::vector<float> electrons;
        Atome (size_t numElec):electrons(numElec,0.31f)
        {
            /*t'a remarqué, je ne gère aucune allocation dynamique :D */
        }
        /* je peux même laisser le compilateur créer le destructeur 
         * le constructeur par copie et l'opérateur d'affectation par
         * défaut grâce au RAII et au fait que le comportement qu'il
         * va implémenté correspond exactement à ce que j'attends :D
         */
 
        /* il est généralement préférable de respecter le principe
         * de la délégation des tâches...
         * c'est pourquoi, celui qui doit se charger de l'affichage des
         * electrons d'un atome, c'est... l'atome lui-meme...
         * j'ai donc créé une fonction print(), qui renvoie la charge
         * totale de l'atome (je me suis dit que ca pourrait être intéressant) ;)
         */
        float print()
        {
            float total = 0.0;
            for(size_t i=0;i<electrons.size();++i)
            {
               /* affichons l'indice de l'électron et sa charge */
               std::cout<<"["<<i+1<<"] = "<<electrons[i];
               /* et ajoutons la charge au total */
               total+= electrons[i]; 
            }
            /*renvoyons la charge totale de l'atome */
            return  total;
        }
};

Et ta classe Molecule pourra être simplifiée en

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
 
/* nous avons besoin de la classe Athom... l'avantage, c'est que
 * nous bénéficions de manière indirecte de l'inclusion 
 * des fichiers d'en-tête <vector> et <iostream>:D
 */
#include "Atome .h"
class Molecule
{
    public:
        /* meme remarque que pour Atome ;) */
        std::vector<Atome> atomes;
        Molecule(size_t atome, size_t elect)
        {
            for(size_t i = 0;i<atome;++i)
                atomes.push_back(Atome(elect));
        }
        void print() const
        {
            /* Il est surement intéressant de pouvoir montrer la charge totale
             * de la molécule :D
             */
            float total = 0.0;
            /* passons tous les atomes en revue */
            for(size_t i = 0;i<atomes.size();++i)
            {
                /* Affichons le numéro de l'atome */
               std::cout<<"Atome ["<<i<<"] :";
                /* demandons en l'affichage, et additionnons la charge
                 * de chaque électron au total
                 */
                total+=atomes[i].print();
            }
            /* affichons la charge totale de la molécule */
            std::cout<<"Pour une charge totale en electrons de "
                     <<total<<std::endl;
        }
};

Après cela, "YAPUKA" utiliser notre splendide classe Molecule

Code :

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

1
2
3
4
5
6
7
8
9
10
11
*/ nous avons besoin de la classe Molécule */
int main
{
    Molecule hydrogen(2,2);
    Molecule oxygen(2,8);
    std::cout<< "une molecule d'hydrogene est composee des atomes"
             <<hydrogen.print()<<endl
             <<"et une molecule d'oxygene des atomes "
             <<oxygen.print()<<endl;
    return 0;
}

(code non testé, mais normalement juste )

[OXXYGENE]

Bonjour,

Tout d'abord , je tiens à vous remercier pour votre réponse.

J'aimerais dire que j'ai voulu utiliser NEW et DELETE mais la declaration et l'inisialisation d'un vecteur, dont la taille est un paramètre, sont compliquées

Et aussi vous avez raison sur tous les remarque concernant le style et ...

En tous cas ce que vous avez proposé et beaucoup mieux de ce que j'ai espèré avoir comme réponse.

Merci encore une fois.