Discussion :

[foetus]

J'utilise parfois une technique consistant à passer toutes ( ou presque ) les variables en mode global, tout le code en "main" et voir si cela passe

Pour les variables globales et le "god object" il faut utiliser une structure + injection de dépendances pour limiter au maximum les inconvénients sans trop modifier le code (<- 2 liens Wikipédia)

En gros :

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
typedef struct s_god_object {
    char buffer1[256];
    char buffer2[256];
    char buffer3[256];
    char buffer4[256];
 
// ...
    XXX var1;
    XXX var2;
    XXX var3;
    XXX var4;
 
} t_god_object;
 
void dim1(/* params, */ t_god_object* var_tab) {
// ....
}
 
void dim2(/* params, */ t_god_object* var_tab) {
// ....
}
 
int main(/*int argc, char* argv[]*/) {
    t_god_object god_object;
 
    dim1(/* params, */ &god_object);
    dim2(/* params, */ &god_object);
}

2-3 trucs:

• peut être allouer dynamiquement la grosse structure avec 1 malloc/free
• tu es obligé de la passer par adresse pour éviter une copie. Et donc il faut utiliser la syntaxe -> pointeur
• mais comme l'objet est créé dans le main tu n'as pas besoin de tester si le pointeur est NULL.

Ensuite, il existe le goto en C ... puisqu'on parle de vieilleries
Évidemment il est fortement recommandé de ne pas l'utiliser sauf dans 1 cas précis : créer 1 point final pour libérer la mémoire.
Exemple Wikipédia:

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
int main(void) {
        int* a, *b, *c, *d = NULL;
        a = malloc(sizeof(int));
        if (!a) return -1;          // si le malloc n'a pas fonctionné
        b = malloc(sizeof(int));
        if (!b) goto clean_b;
        c = malloc(sizeof(int));
        if (!c) goto clean_c;
        d = malloc(sizeof(int));
        if (!d) goto clean_d;
 
clean_d: // libération de la mémoire en cascade
        free(d);
clean_c:
        free(c);
clean_b:
        free(b);
        free(a);
        return 0;
}

Tu as aussi le couple setjmp/ longjmp pour faire des sauts dans le code (<- 2 liens cppreference en anglais)
Mais de souvenirs c'est fortement déconseillé également parce que cela peut provoquer des fuites mémoire : en C++, cela n'appelle pas les destructeurs/ constructeurs (ou un truc comme cela)

[foetus]

Et l'histoire du "god objet"/ variables globales peut être intéressant avec une conception en 2 couches :

• 1 couche "layer_C.XXX" avec les fonctions en C, toutes les variables (peut-être statique pour le "god objet" ) où tu pourras faire des allocations/ désallocations
• 1 couche "layer_BASIC.XXX" avec tes fonctions BASIC ayant la signature BASIC. Toutes les fonctions ici vont appeler les fonctions de la couche "layer_C"
• la couche "layer_BASIC.XXX" peut être un ensemble de macros

Après il faut creuser, c'est peut-être une voie de garage
Peut-être faire

• une fonction d'initialisation et une de destruction
• il faudra bien tracer quelle variable est utilisée. Et on retombe sur le problème de @fred1599 avec 1 seul buffer d'utiliser : il faudra voir comment faire ?

main.c

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#include "layer_BASIC.h"
 
int main(/* ... */) {
    char str[256] = {'\0'};
    char* c;
 
    strncpy(str, "SUNMONTUEWEDTHUFRISAT", 21);
 
    c = DIM(str, 7, 3);
    printf("%s\n", c);
}

layer_BASIC.h

Code :

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

1
2
3
4
5
6
#ifndef LAYER_BASIC
#define LAYER_BASIC
 
char* DIM(char* str, size_t start_index, size_t end_index);
 
#endif // LAYER_BASIC

layer_BASIC.c

Code :

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

1
2
3
4
5
#include "layer_C.h"
 
char* DIM(char* str, size_t start_index, size_t end_index) {
    return DIM_C(str, start_index, end_index);
}

layer_C.h

Code :

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

1
2
3
4
5
6
#ifndef LAYER_C
#define LAYER_C
 
char* DIM_C(char* str, size_t start_index, size_t end_index);
 
#endif // LAYER_C

layer_C.c

Code :

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

1
2
3
4
5
6
char buffer[256];
 
char* DIM_C(char* str, size_t start_index, size_t end_index) {
// ...
    return buffer;
}