Discussion :

[Bysbobo]

Coucou,

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 )

[Neyort]

Salut,

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

En fait, ce code:

Code :

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

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

[souviron34]

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...

[deletme]

Salut,

Code :

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

 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.

[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++).

[Neyort]

Salut

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

executer opcode.h

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
 
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 :

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
 
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 :

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
 
#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 :

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
 
#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

[Médinoc]

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 C :

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

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 C :

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

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

[Bktero]

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.

[souviron34]

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 :

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

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 :

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

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 :

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

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 ....

[Neyort]

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 :

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

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

[Obsidian]

Hello,

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.

[Bysbobo]

Coucou

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
 
#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
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

[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

[Bysbobo]

.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

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

[Kannagi]

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

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

[Bysbobo]

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

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" C'est lui qui implémente.

Je me suis bien rattrapé ça va?