Decouper son main() en fonctions

Version imprimable

bonjours,
je suis nouveau en C, et j'aimerais partagé mon code (main) en fonction, je n'y arrive vraiment pas. Merce de l'aide

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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
 
#define numberL 256
#define numberC 1024
 
int position(char *text, char chara)
{
    int i;
 
    for (i = 0; i < strlen(text); i++)
        if (text[i] == chara)
            return i;
 
    return -1;
}
 
char * spaces(char *text)
{
    if (position(text, '#') != -1)
        return text;
 
    char text2[numberC];
 
    int i; bool space2 = true; int count = 0;
 
    for (i = 0; i < strlen(text); i++)
    {
        if (text[i] == ' ')
        {
            if (space2 && count != 0)
            {
                text2[count] = text[i];
                count++;
                space2 = false;
            }
        }
        else
        {
            text2[count] = text[i];
            count++;
            space2 = true;
        }
    }
 
    text2[count] = '\0';
 
    return text2;
}
 
int main()
{
    FILE *file;
    char line[numberC];
    char input[numberL][numberC];
    file = fopen("input.txt", "r");
 
    int  i, j, k, lineNumber = 0, indentation = 0, counterL = 0, counterC = 0, count = 0;
 
    while (fgets(line, sizeof line, file) != NULL)
    {  
        for (i = 0; i < numberC; i++)
            input[lineNumber][i] = spaces(line)[i];
 
        lineNumber++;
    }  
 
    char temp[numberL][numberC];
 
    for (j = 0; j < numberL; j++)
    {
        for (i = 0; i < strlen(input[j]); i++)
        {
            if (position(input[j], '#') == -1 && position(input[j], '{') != -1 && position(input[j], '}') == -1)
            {
                if (input[j][i-1] == '{' && strlen(input[j]) > 3)
                {
                    counterL++;
 
                    counterC = 0;
 
                    for (k = 0; k < numberC; k++)
                        if (counterC > 0 || input[j][k+i] != ' ')
                        {
                            temp[counterL][counterC] = input[j][k+i];
                            counterC++;
                        }
 
                    temp[counterL-1][i] = '\n';
 
                    break;
                }
                else
                {
                    temp[counterL][i] = input[j][i];
                }
            }
            else
            if (position(input[j], '#') == -1 && position(input[j], '{') == -1 && position(input[j], '}') != -1)
            {
                if (input[j][i] == '}' && strlen(input[j]) > 3)
                {
                    counterL++;
 
                    counterC = 0;
 
                    for (k = 0; k < numberC; k++)
                        if (counterC > 0 || input[j][k+i] != ' ')
                        {
                            temp[counterL][counterC] = input[j][k+i];
                            counterC++;
                        }
 
                    temp[counterL-1][i] = '\n';
 
                    break;
                }
                else
                {
                    temp[counterL][i] = input[j][i];
                }
            }
            else
            if (position(input[j], '#') == -1 && position(input[j], '}') < position(input[j], '{'))
            {
                temp[counterL][i] = input[j][i];
            }
            else
            {
                temp[counterL][i] = input[j][i];
            }
        }
 
        counterL++;
    }
 
    for (i = 0; i < numberL; i++)
        printf("%s", temp[i]);
 
    for (j = 0; j < numberL; j++)
        for (i = 0; i < numberC; i++)
            temp[j][i] = spaces(temp[j])[i];
 
    for (i = 0; i < numberL; i++)
        printf("%s", temp[i]);
    printf("\n\n\n");
 
 
    char output[numberL][numberC];
 
    for (j = 0; j < numberL; j++)
    {
        count = 0;    
 
        for (i = 0; i < strlen(temp[j]); i++)
        {
            if (position(input[j], '#') == -1 && position(temp[j], '{') != -1 && position(temp[j], '}') == -1)
            {
                for (i = 0; i < indentation; i++)
                {
                    output[j][i] = ' ';
                    count++;
                }
 
                for (i = 0; i < strlen(temp[j]); i++)
                    output[j][i + count] = temp[j][i];
 
                indentation += 4;
            }
            else
            if (position(input[j], '#') == -1 && position(temp[j], '{') == -1 && position(temp[j], '}') != -1)
            {
                indentation -= 4;
 
                for (i = 0; i < indentation; i++)
                {
                    output[j][i] = ' ';
                    count++;
                }
 
                for (i = 0; i < strlen(temp[j]); i++)
                    output[j][i + count] = temp[j][i];
            }
            else
            if (position(input[j], '#') == -1 && position(temp[j], '}') < position(temp[j], '{'))
            {
                for (i = 0; i < strlen(temp[j]); i++)
                    output[j][i + count] = temp[j][i];
            }
            else
            {
                for (i = 0; i < indentation; i++)
                {
                    output[j][i] = ' ';
                    count++;
                }
 
                for (i = 0; i < strlen(temp[j]); i++)
                    output[j][i + count] = temp[j][i];
            }
 
            output[j][i + count + 1] = '\0';
        }
    }
    for (i = 0; i < numberL; i++)
        printf("%s", output[i]);
}

18/01/2014, 18h53
Bktero
Il y a quelques warnings à la compilation de ton code. La plupart ne sont pas graves car tu compares des signed et des unsigned. La correction est simple. En revanche, il y en a un autre plus important :
Code:

1 2 test.c:49:5: warning: function returns address of local variable [-Wreturn-local-addr] return text2;
Cette variable est définie ainsi, puis tu fais un return à la fin de la fonction :

Citation:

char text2[numberC];

Problème : une fois sortie de la fonction, le tableau est détruit et la zone que le constituait peut être utilisée pour autre chose. Mais comme tu as gardé l'adresse de ce tableau avec le return, tu continues d'accéder à une zone qui ne contient plus forcément ce que tu penses.
Pour corriger cela, tu devrais utiliser malloc() car une zone allouée avec malloc() reste "protégée" tant que tu n'as pas appelée free().

Citation:

je n'y arrive vraiment pas

Pourquoi n'y arrives-tu pas ? Quelles difficultés rencontres-tu ?

C'est pour cette raison qu'il existe les fonctions sur lesquelles ont peut passer des paramètres. D'après ce que je vois, ton main est beaucoup trop gros. Selon moi, le main ne devrait presque faire rien d'autre que d'appeler d'autres fonctions, là ton main fait la moitié de ton programme. Je pense que c'est surtout dû à un manque de réflexion sur l'implémentation qu'autre chose.

Par exemple prenons le cas du projet sur lequel je travaille, il y a plusieurs modules de compilation donc pas mal de fonctions mais mon main ressemble à ceci:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 #include <stdio.h> #include <stdlib.h> #include <string.h> #include "src/kernel/Kernel.h" int main (int argc, char ** argv) { if (BEngine_init ()) { BScreen * p_screen = BEngine_init_video (640, 480, "BEngine testing !!"); if (p_screen) BEngine_loop (p_screen); BEngine_close (&p_screen); } return EXIT_SUCCESS; }
Bien sûr ici le projet est loin d'être fini mais derrière ces quelques lignes tu as une liste doublement chaînée qui est déjà active avec un semblant de garbage collector (sans compter l'initialisation de la bibliothèque SDL2), un objet de base qui me servira aux autres objets qui seront définis plus tard. Quelques lignes viendrons se rajouter mais c'est pour montrer qu'un main doit toujours rester au plus simple !

Il faut vraiment réfléchir sur le découpage de ton programme. Par exemple si je vois que tu as une partie du programme qui calcul le nombre de lignes de ton fichier, pourquoi ne pas mettre ça dans une fonction qui retourne un entier (non signé de préférence donc de type size_t) et hop tu as déjà quelques lignes en moins dans ton main.

Si tu mets dans une structure les informations de ton fichier à savoir un pointeur sur le flux (FILE *), le nombre de lignes et d'autres informations et dans tes fonctions tu passes en paramètre l'adresse de ta structure tu aurais accès à ton fichier et à ses informations dans toutes tes fonctions acceptant ce paramètres.

Lorsque tu sais ce que ton programme va faire, tu peux aisément imaginer un découpage de ton programme par type de tâches, c'est ça la clé, il faut déterminer les différentes tâches que ton programme va accomplir et le découpage en fonction se fera presque tout seul.

20/01/2014, 14h51
Metalman

Découpe en blocs "logiques" de travail :

Tu as l'air d'ouvrir un fichier
Lire le fichier
Traiter un tableau
Transmettre/Afficher un tableau
Traiter un autre tableau de sortie
Afficher le tableau de sortie
(et pas de fermeture de fichier ?)

Ca fait déjà plusieurs fonctions "possibles" auxquelles tu ne feras que transmettre des paramètres entre elles.