Discussion :

[lezurp]

bonjour,

j ai une structure definie dans mon header de type:

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
 
typedef struct {
    int a;
    int b;
    /*...........*/
    int z;
 
    string a;
    string b;
    /*............*/
    string zz;
 
    vector <int> a;
    vector <string> b;
    /*...*/
   vector <autre>ZZ;
}ma_structure;

dans mon main je cree une instance de cette structure et l utilise.
on fois que j e n en ai plus besoin, plus tot que de cree une autre instance , je voudrais la purger completement, et l utiliser a nouveau.

est ce que je peux faire un methode pour ma structure style, si oui comment
ma_structure.efface_tout();

est ce que je peu supprimer mon instance de ma structure, si oui comment

ou alors est ce que je dois imperativement cree une fonction de type
efface_struct(&ma_structure) , chose que je voulais eviter car je ne trouve pas ca tres elegant.

Merci

[three minute hero]

bonjour,

Salut

j ai une structure definie dans mon header de type:

typedef struct {
int a;
int b;
...........
int z;

string a;
string b;
............
string zz;

vector <int> a;
vector <string> b;
...
vector <autre>ZZ;
}ma_structure;

Ouch… des tableaux bidimentionnels, ça aurait été bien aussi

dans mon main je cree une instance de cette structure et l utilise.
on fois que j e n en ai plus besoin, plus tot que de cree une autre instance , je voudrais la purger completement, et l utiliser a nouveau.

est ce que je peux faire un methode pour ma structure style, si oui comment
ma_structure.efface_tout();

Pas sûr qu'une telle méthode serait plus rapide que la création d'une nouvelle instance. Presque sûr que non, même.

Ceci dit, tu peux tout à fait créer une méthode comme celle-ci. Pour la créer, fais comme n'importe quelle méthode de classe. La seule différence entre une structure et une classe, c'est que les éléments sont par défaut publics pour l'un et privés pour l'autre.

est ce que je peu supprimer mon instance de ma structure, si oui comment

Il suffit de limiter la portée de ton objet (par exemple le déclarer dans ta boucle plutôt qu'en dehors).

[lezurp]

merci de tes reponces,

pour les tableau, je suis un peu obliger de le laisser tel quel pour des raisons pratique et d organisation, de plus je trouve les vecteurs tres pratique , j 'avoue que ca fait un peu bizzard.

par contre pour de qui est de cree une methode pour ma structure
euu j avoue que je ne maitrise pas les classes alors un petit exemple serai sympa, j ai bien deja regarder sur le net, mais je n ai pas trouver quelque chose qui me conviens ( souvent trop complexe, ou assez sucintement expliqué, et a 99% du temp applique a une class).

et derniere question , il n est pas possible de detruire une instance de structure ?? autrement qu en creent mon instance dans une boucle ou une fonction ,

merci

[koala01]

Salut,

D'abord, une petite remarque en passant: la définition d'une structure (qu'il s'agisse d'une class, d'une struct, d'un enum ou d'une union ) en C++ provoque automatiquement la déclaration du type associé.

Ainsi, et contrairement au C (ou la définition d'une structure ne provoque pas la déclaration du type associé), il n'est pas nécessaire de passer par typedef et tout le saint frusquin, tellement lourd à gérer en C.

Ainsi les codes proches de

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
class MaClass
{
    /*...*/
};
struct MaStruct
{
    /*...*/
};
union MonUnion
{
    /*...*/
};
enum MonEnum
{
    /*...*/
};

suffisent pour que le C++ considère MaClass, MaStruct, MonUnon et MonEnum comme autant de types différents, sans qu'il soit nécessaire de rajouter quoi que ce soit

Maintenant, il faut savoir qu'il est possible de déclarer des variables n'importe quand dans le code.

C'est également une différence d'avec le C, où, historiquement, les variables sont à déclarer en début de fonction.

Dés lors, une variable existe depuis le moment de sa déclaration jusqu'à l'accolade fermant le bloc d'instructions dans lequel elle est déclarée.

Ainsi, voici ce que l'on peut constater:

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
void fonction()
{
    int a;//a existe à partir d'ici
    for(int i=0;i<10;++i)//i n'existe que dans la boucle
    {
        cout<<i; //OK i est connu
        int j = i; //j est créé ici
       cout<<j<<i<<a;//les trois variables sont connues 
    }//j est chaque fois détruit ici
    //et i est détruit quand on en retourne plus dans la boucle
    /*les deux lignes suivante sont mauvaises parce que i et j n'existent plus
     *
     cout<<i;
     cout<<j;
    */
    cout<<a //OK a existe encore
}//a est détruit ici;

Il est donc tout à fait possible de prévoir des variables qui n'existent que dans un bloc d'instructions particuliers, qui sont construites lors de leur déclaration, et qui sont automatiquement détruites (donc vidée) lorsque l'on quitte le bloc d'instructions dans lequel elles ont été déclarées.

Il est même tout à fait possible d'envisager 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
12
13
14
15
16
17
18
19
20
21
22
23
void fonction()
{
    {
        MonType mavar;
        /* j'ai besoin d'une variable de type MonType ici, mais je sais que je
         * n'en ai plus l'usage une fois que j'ai fini le traitement qui y a trait
         * je traite mavar ici, et elle sera automatiquement détruite
         * lorsque l'on passera l'accolade fermante
         */
    }
    for(int i=0;i<MAX;++i) 
    {
        MaClasse var1;
        /* var1 sera à chaque fois "réinitialisée" du fait qu'elle est détruite
         * lorsque l'accolade fermante est rencontrée et (re) crée lorsque
         * la déclaration est rencontrée
         */
    }
    /* suite du code où l'on n'a besoin d'accéder ni à mavar ni à var1
     * le compilateur refuse d'ailleurs catégoriquement toute tentative
     * en ce sens
     */
}

[three minute hero]

Un objet (ou une variable) créé statiquement (c'est-à-dire pas avec un new) est détruit automatiquement lorsqu'il sort de sa portée :

Code :

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

1
2
3
4
5
6
 
{
    int d = 0;
    std::cout << d; //ok
}
std::cout << d; //erreur de compilation

Autrement dit, une variable n'est plus visible dés lors que l'on est sorti des accolades !
Pas besoin d'une boucle. Le mieux serait que tu nous montres ton code pour lui appliquer cette logique, tu comprendrais mieux.


En ce qui concerne la méthode, creuse un peu plus ta recherche sur le net. Savoir programmer c'est aussi savoir chercher ! Il existe plein de cours biens sur développez.
Si tu ne trouves que des exemples appliqués à des classes, alors dans un premier temps crée une classe avec ces mêmes attributs (a, b, …), et crée également ta méthode tel que le cours te l'indiquera.

koala01 > Ce soir, décidément…