Reallocation de mémoire pour un tableau

Version imprimable

Voir 40 message(s) de cette discussion en une page

19/08/2013, 10h16
Bysbobo

Coucou,

Citation:

Envoyé par Neyort

Je suis navré si je vous fait sauter au plafond devant ce code^^"

Aucun problème ;)

Je pense que tu devrais revoir la portée de tes variables. Je ne suis pas un expert comme les autres membres de cette communauté mais je pense que tu oublies par moment où certaines variables sont définies et où elles ne le sont pas.
Par exemple, ton tableau Variables. Tu l'utilises dans ta fonction mais il n'est pas passé en paramètre de ta fonction.

Et aussi, tu nommes des variables locales à ta fonction comme les éléments particuliers de ta structure (est-ce le cas? si oui, laisse mais fais gaffe. Si non, fais encore plus gaffe :P)

Salut,

Citation:

Je pense que tu devrais revoir la portée de tes variables

En fait, ce code:
Code:

1 2 3 4 5 6 7 8 9 10 11 typedef struct pvariable { int utilisee; int typeVariable; int valeurChiffre; char valeurLettre; char *valeurChaine; } variable; int nombreDeVariables = 0; variable *Variables = NULL;
se trouve dans un fichier que j'include avant le fichier où se trouve ma fonction 'DeclarationVariable'. En fait, ma structure est une variable globale.

Voilà j'espère avoir été plus clair? ^^

Salut,

Neyort

19/08/2013, 12h29
souviron34

Citation:

Envoyé par Neyort

se trouve dans un fichier que j'include avant le fichier où se trouve ma fonction 'DeclarationVariable'. En fait, ma structure est une variable globale.

Voilà j'espère avoir été plus clair? ^^

Oui et non...

Ce serait effectivement mieux d'avoir l'ensemble du code, parce que je pense que Bysbobo a raison..

Le code présenté en tant que tel est correct.

Maintenant, comment c'est appelé ou géré doit - très certainement vu l'erreur qe tu as - poser problème...
19/08/2013, 15h18
deletme

Salut,

Citation:

Code:

free(tab), tab=NULL ;

Il me semblait que l'opérateur virgule ne garantissait pas l'ordre des opérations effectuées et qu'il était déconseillé de faire du coup ce genre de chose. Si tab=NULL est réalisé en premier, on perd la référence du pointeur et on libère un pointeur qui pointe sur ... rien --> fuite mémoire .

Quelqu'un peut confirmer ? ou au contraire contredire ?

Merci à vous.
19/08/2013, 17h49
Médinoc

La virgule est un point de séquencement, elle garantit l'ordre (du moins, en C; j'ignore si la surcharge d'opérateur marche avec les virgules en C++).

Salut :)

Alors je vais vous montrer le code que je simplifie au maximum pour garder les parties 'intéressantes' :) :

executer opcode.h

Code:

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
 
int ExecuterOpcode(int Opcode)
{
    switch(Opcode)
    {
    //Nul Byte
        case 0x00:
        printf("0x00\n");
        break;
 
    //Déclaration variable type varChiffre.
        case 0x01:
        printf("0x01\n");
        DeclarationVariable(varChiffre);
        break;
 
        case 0x02:
        printf("0x02\n");
        break;
 
        case 0x03:
        printf("0x03\n");
        break;
 
    //Arrêt du programme.
        case 0x15:
        printf("0x15 --> Fin du programme\n");
        continuer = 0;
        break;
 
        case 0x61:
        printf("0x61\n");
        break;
 
        case 0x70:
        printf("0x70\n");
        break;
 
        case 0x7A:
        printf("0x7A\n");
        break;
    }
 
    return 0;
}

declaration variable.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
int DeclarationVariable(int typeVariable)
{
    variable *tmp = NULL;
/*Je précise que cette condition fonctionne à chaque fois, c'est la seconde qui pose problème ;)*/
    if(typeVariable == varChiffre)
    {
            if( (tmp = (variable*)realloc(Variables, ((nombreDeVariables+1)*sizeof(variable))) ) != NULL )
            {
                Variables = tmp;
                Variables[nombreDeVariables].typeVariable = varChiffre;
                Variables[nombreDeVariables].utilisee = 1;
                Variables[nombreDeVariables].valeurChiffre = 0;
                printf("Création d'une variable\n");
                nombreDeVariables++;
            }
 
            else if(tmp == NULL)
            printf("erreur\n");
 
    }
    return 0;
}

definitions.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
#define varChiffre 1
#define varLettre 2
#define varChaine 3
 
typedef struct pvariable
{
    int utilisee;
    int typeVariable;
    int valeurChiffre;
    char valeurLettre;
    char *valeurChaine;
} variable;
 
int nombreDeVariables = 0;
variable *Variables = NULL;
int continuer = 1;

et main.c

Code:

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
 
#include "definitions.h"
#include "declaration variable.h"
#include "executer opcode.h"
 
int main (int argc, char** argv)
{
    FILE *Application = NULL;
    Application = fopen("application.apz", "rb");
 
    int retour;
 
    retour = Initialisation();
 
    if(retour == EXIT_FAILURE)
        return EXIT_FAILURE;
 
    retour = PreparationApplication();
 
    if(retour == EXIT_FAILURE)
        return EXIT_FAILURE;
 
    SDL_Event event;
 
//Le nombre d'opcode depuis le début du programme.
    int nbOpcodeActuel = 0;
 
    while(continuer || (fread(&OctetActuelBrut, 1, 1, Application)) != 0)
    {
            nbOpcodeActuel++;
            fread(&OctetActuelBrut, 1, 1, Application);
 
        //On éxécute pas l'entête ni le nul byte qui la sépare de la première instuction.
            if(nbOpcodeActuel > 4)
            ExecuterOpcode(ApplicationMasque(OctetActuelBrut));
 
        SDL_PollEvent(&event);
        switch (event.type)
        {
            case SDL_QUIT:
            continuer = 0;
            break;
 
            case SDL_KEYDOWN:
            {
                switch(event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                        continuer = 0;
                    break;
 
                    default:
                    break;
                }
            }
        }
 
        SDL_FillRect(ecran, 0, SDL_MapRGB(ecran->format, 0, 0, 0));
        SDL_Flip(ecran);
    }//Fin du while.
 
    fclose(Application);
    Liberation();
 
    return EXIT_SUCCESS;
}

Voilà donc mon code :)

En espérant cette fois avoir été plus clair^^

Salutation,

Neyort

Pourquoi ce cast du retour de realloc()? Tu compiles en C++?

PS: Une syntaxe que je tends à privilégier pour realloc(), c'est ce wrapper:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 /*Retourne 0 pour OK, -1 si échec*/ int realloc_variable(variable **ppMem, size_t nNew) { int ret = -1; variable * pNew = realloc(*ppMem, nNew * sizeof(**ppMem)); if(pNew != NULL || nNew==0) { *ppMem = pNew; ret = 0; } return ret; }
Code:

1 2 3 4 5 6 7 8 if(ajout variable) { if(realloc_variable(&Variables, nombreDeVariables+1) >= 0) { Variables[nombreDeVariables]. blablabla; nombreDeVariables++; } }
Après, voyons ce qu'il te manque: Si tu dois identifier tes variables par nom, tu dois:

Gérer l'allocation et la destruction des noms
Pouvoir retrouver une variable par son nom
Vérifier qu'une variable du même nom n'existe pas déjà quand tu en crées une

19/08/2013, 18h28
Bktero

Citation:

Envoyé par Médinoc

La virgule est un point de séquencement, elle garantit l'ordre (du moins, en C; j'ignore si la surcharge d'opérateur marche avec les virgules en C++).

(Je passe par là par hasard.)

Je suis d'accord avec Médinoc sur ce point. Le free() est donc forcément fait avant.
19/08/2013, 18h38
souviron34
Citation:

Envoyé par Neyort

Voilà donc mon code :)

En espérant cette fois avoir été plus clair^^

Tu es plus clair, mais il y a beaucoup de choses à revoir !!!!

D'abord, NE JAMAIS METTRE DU CODE DANS DES include !!!!

Un fichier ".h" sert à inclure des définitions, de type de variables, de structure, de valeurs (via define), de prototypes de fonctions...

Un code se met dans un fichier .c !!!!!!!!!!!!!!!!!!!!

Tes fichiers opcode.h et variable.h doivent être opcode.c et variable.c
Ton fichier Définitions.h ne doit pas contenir d'initialisation, ni de variables locales ou globales..

(donc tu dois enlever

Code:

1 2 3 int nombreDeVariables = 0; variable *Variables = NULL; int continuer = 1;

)

Ensuite, fread renvoie un nombre lu, que tu ne testes pas, et tu doubles le fread.. Je ne sais pas trop ce que tout ça peut donner :
Code:

1 2 3 4 while(continuer || (fread(&OctetActuelBrut, 1, 1, Application)) != 0) { nbOpcodeActuel++; fread(&OctetActuelBrut, 1, 1, Application);
- Si ton 2ième fread échoue, quid ?
- De même, si le premier a réussi, tu lis 2 fois en ayant "oublié" le premier ?
@Médinoc :

Code:

Pourquoi ce cast du retour de realloc()? Tu compiles en C++?

Tu as raison... Une absence trop longue du forum m'avait fait oublié ce diag !!!! voir page précédente .... :oops:

Salut et tout d'abord merci à tous de vos réponses! :)

Alors:

@Médinoc:

Pour la compilation, j'étais bien en C++ car c'est un projet SDL et il est en C++ par défaut. C'est maintenant du C pur^^ merci pour cette précision cela m'évite de faire un cast pas très beau :)

Ton code fonctionne nikel, merci donc ^^
Petite question tout de même: que signifie wrapper? :)

Pour l'instant je fais l'allocation d'une variable, lorsque cela sera fait je me pencherait sur la suppression de celle-ci ;)

@souviron34:

Tout d'abord, je ne savais pas que les extensions étaient importantes. On m'a toujours dit que je mette .h ou .c ou .nimportequoi, cela n'empêchera pas de compiler, c'est donc plus une convention? :)

Mais je changerais comme tu me l'as précisé, mes noms de fichiers ;)

Enfin pour le fread, je ne sais pas ce qui m'a pris^^'

Voici le code corrigé pour le fread :) :
Code:

1 2 3 4 5 6 7 8 9 10 11 while(continuer) { nbOpcodeActuel++; if(fread(&OctetActuelBrut, 1, 1, Application) == 0) continuer = 0; //On éxécute pas l'entête ni le nul byte qui la sépare de la première instuction. if(nbOpcodeActuel > 4) ExecuterOpcode(ApplicationMasque(OctetActuelBrut), Application);
Un grand merci à vous, j'aurais en plus d'avoir un programme fonctionnel, encore appris pleins de choses grâce à vous!

Merci énormément ^^

Neyort

19/08/2013, 22h24
Obsidian

Hello,

Citation:

Envoyé par Neyort

Petite question tout de même: que signifie wrapper? :)

« To wrap », en anglais, signifie « enrouler » autour de quelque chose et, par extension, « emballer », comme l'emballage d'une confiserie.

Un wrapper est un donc un logiciel minimaliste conçu pour n'être qu'une surcouche à un produit déjà existant, généralement pour servir d'adaptateur et mettre en forme une API selon une forme voulue, mais parfois également pour ajouter quelques fonctionnalités.

Coucou

Citation:

Envoyé par Neyort

Code:

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
 
#include "definitions.h"
#include "declaration variable.h"
#include "executer opcode.h"
 
int main (int argc, char** argv)
{
    FILE *Application = NULL;
    Application = fopen("application.apz", "rb");
 
    int retour;
 
    retour = Initialisation();
 
    if(retour == EXIT_FAILURE)
        return EXIT_FAILURE;
 
    retour = PreparationApplication();
 
    if(retour == EXIT_FAILURE)
        return EXIT_FAILURE;
 
    SDL_Event event;
 
//Le nombre d'opcode depuis le début du programme.
    int nbOpcodeActuel = 0;
 
    while(continuer || (fread(&OctetActuelBrut, 1, 1, Application)) != 0)
    {
            nbOpcodeActuel++;
            fread(&OctetActuelBrut, 1, 1, Application);
 
        //On éxécute pas l'entête ni le nul byte qui la sépare de la première instuction.
            if(nbOpcodeActuel > 4)
            ExecuterOpcode(ApplicationMasque(OctetActuelBrut));
 
        SDL_PollEvent(&event);
        switch (event.type)
        {
            case SDL_QUIT:
            continuer = 0;
            break;
 
            case SDL_KEYDOWN:
            {
                switch(event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                        continuer = 0;
                    break;
 
                    default:
                    break;
                }
            }
        }
 
        SDL_FillRect(ecran, 0, SDL_MapRGB(ecran->format, 0, 0, 0));
        SDL_Flip(ecran);
    }//Fin du while.
 
    fclose(Application);
    Liberation();
 
    return EXIT_SUCCESS;
}

Dans les premières lignes, tu mets un fopen mais tu ne vérifies pas si l'ouverture du fichier est valide.

Et en fait non ce n'est pas une convention, c'est comme ça :P
Le .h est juste là pour te rappeler les prototypes. Le .c est là pour définir ces prototypes et les transformer donc en fonction avec devine quoi... du C dedans ;)

20/08/2013, 11h08
Neyort

Salut,

Merci Obsidian pour cette info, je ne connaissais pas^^
J'adore en apprendre toujours plus ^^ Merci donc :)

Merci aussi à toi Bysbobo, ce n'était pas vraiment un oubli car je le vérifiais dans une fonction mais comme là je modifie un peu tout le code, j'ai oublié de le remettre^^ Enfin, c'est corrigé merci ;)

Et pour les .h et les .c c'est donc si j'ai bien compris:

.c = code, fonction, etc...

.h = defines, structures,.. :)

Merci à tous énormément pour votre aide très utile!

Neyort
20/08/2013, 11h44
Bysbobo

Citation:

Envoyé par Neyort

.h = (...) structures,.. :)

Personnellement, je mets les structures avec le code, je l'ai au moins sous les yeux. Après, est-ce que ça change quelque chose à la compilation? Je n'ai pas mon ordinateur perso à côté pour tester ça :P

Citation:

Merci à tous énormément pour votre aide très utile!

:ccool:
20/08/2013, 14h50
Kannagi

Citation:

Envoyé par Bysbobo

Personnellement, je mets les structures avec le code, je l'ai au moins sous les yeux.
:ccool:

Et si tu fais un gros programme de plusieurs fichier .c , tu copie plusieurs fois la structure ? :aie:
20/08/2013, 15h24
Bysbobo

Citation:

Envoyé par Kannagi

Et si tu fais un gros programme de plusieurs fichier .c , tu copie plusieurs fois la structure ? :aie:

Non tu as raison ;)

Mais dans le cas de Neyort, il a séparée toutes les fonctions alors qu'elles pourraient être réunies en un seul fichier et donc sa structure pourrait être définie dans le .c

J'ai bien dit "pouvoir" :mouarf: C'est lui qui implémente.

Je me suis bien rattrapé ça va? :ccool:

Voir 40 message(s) de cette discussion en une page