Retourner un string depuis une fonction en C

Citation:

---

Envoyé par Fluorine

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:

---

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

---

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)

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

• 1 couche "layer_C.XXX" avec les fonctions en C, toutes les variables (peut-être statique pour le "god objet" :koi: ) 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 :whistle: :aie:
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 :koi: ?

main.c

Code:

---

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:

---

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:

---

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:

---

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:

---

1 2 3 4 5 6

char buffer[256];   char* DIM_C(char* str, size_t start_index, size_t end_index) { // ... return buffer; }

---