Discussion :

[maluv]

bonjour j'ai un fichier txt qui contient des valeurs que ej voudrais récupérer pour les traiter
cependant, les premières lignes de mon fichier se présente comme:

***************************************
***********test
***************************************

50
12
16

je voudrais commencer à récupérer mes valeurs à partir de la ligne 5 du fichier
jusqu'à présent , je supprime les 5 premières lignes de mon fichier pour bien pouvoir l'utiliser ( pour çà je n'ai pas de pb)


voilà le code utilisé mais rien ne se passe

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
j=1;
i=1;
while (!feof(fp)) 
      {  
        if(j<5)
         {fscanf (fp, "%s", &internal_table[i]);}
         else
         {   fscanf (fp, "%f", &internal_table[i]);
              i++;
         } 
        j++;
      }
nb_total=i;

voilà si vous avez des idées je suis prenante

autre problème si c'était un fichier avec 2 colonnes
comment dans 2 tableaux ayant les mêmes indices, je peux récupérer les valeurs.

Merci encore pour votre aide si précieuse

[wadabush]

Ton code ne marche pour l'instant que parce que ton fichier texte ne contient pas d'espaces.
Si tu veux recuperer des lignes, tu devrais utiliser fgets plutot. Ensuite tu pourras traiter tes lignes en les parsant et en trouvant les separateurs:

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
 
 
int array[255][255];
int column_nb = 0;
int line_nb=0;
 
while (!feof(fp)) 
{
    int i = 0;
    int j = 0;
 
    char buff[255]; 
    char current_buff[10];
 
    //read a line or the 255 first characters
    fgets(255,buff, fp); 
 
    //check if the line is something we want to keep
    if(buff[0] == '*' || (buf[0] > '9' && buf[0] < 0))
    {
        //discard line, comments line, or invalid number
        continue;
    }
 
    //parse the row or the first 255 characters of it.
    while(buff[i] != 0)
    {
        if(buff[i] >'9' && buff[i] < '0')
        {
            //In case the next char is not a number, we consider it as a separator
 
            current_buff[j++] = 0;
 
            //convert the string in integer
            array[line_nb][column_nb++] = atoi(current_buff);
            j = 0;
        }
        else
        {
            current_buffer[j++] = buff[i];
        }
        i++;
    }
 
    line_nb ++;
    column_nb = 0;
}
 
nb_total=i;

J'ai pas teste le code, et je ne sais pas si il builde non plus, mais dans l'idee ca devrait marcher. J'ai pas non plus fait les cas limites, dans lesquels tu as des lignes de plus de 255 caracteres, et que tu as un nombre coupe. Je te laisse le soin de les faire

[maluv]

je te remercie, je vais tester ton id
mais je me demandais si tu ne connais pas à l'avance le nombre de ligne que tu auras dans ton tableau , comment peux tu utiliser fgets ?

[wadabush]

Ici on est parti du principe qu'on allouait statiquement les tableaux assez grand pour que l'on puisse stocker correctement toutes les valeurs.

Maintenant, etant donne que tes fichiers peuvent avoir plus de 255 lignes, il faut que tu calcules la taille qu il va avoir au final.

Pour cela, plusieurs methodes, mais je prefere de loin faire un premier passage sur le fichier, pour connaitre le nombre de lignes - colonnes qu'il possede, allouer dynamiquement le tableau, et refaire une passe sur tout le fichier pour remplir correctement le tableau.

Ensuite le probleme que l'on peut avoir avec fgets, c'est que tu pourrais avoir une ligne qui soit plus longue que la taille du buffer que l'on lui donne. Dans ce cas la, tu as aussi quelque chose a rajouter, qui va etre le check que le buffer que fgets te retourne contienne bien un retour chariot, dans le cas contraire, on sait que la ligne n'est pas finie, et on peut continuer des fgets jusqu'a obtenir le end of line.


en reprenant l'algo precedant:

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
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
 
int **array = NULL;
int nb_of_line = 0;
int nb_of_column = 0;
int column_nb = 0;
int line_nb=0;
 
//First pass of the file to calculate the number of line
while (!feof(fp)) 
{
    int i = 0;
    int j = 0;
    int local_nb_of_column = 0;
    end_of_line_found = 0;
 
    while(end_of_line == 0)
    {
        //read a line or the 255 first characters
        fgets(255,buff, fp); 
 
        //check if the line is something we want to keep
        if(buff[0] == '*' || (buf[0] > '9' && buf[0] < '0'))
        {
            //discard line, comments line, or invalid number
            continue;
        }
 
        //parse the row or the first 255 characters of it.
        while(buff[i] != 0)
        {
            if(buf[i] == '\n')
            {
                end_of_line_found = 1;
                break;
            }
            if(buff[i] >'9' && buff[i] < '0')
            {
                local_nb_of_column++;
            }
            i++;
        }
    }
 
    nb_of_line ++;
    if(local_nb_of_column > column_nb)
    {
        column_nb = local_nb_of_column;
    }
}
 
//come back at the beginning of the file.
 
fseek(fp, 0, SEEK_SET);
//allocation of the array:
array = char(**)malloc(sizeof(char *) * nb_of_line);
 
for(i = 0; i < nb_of_line; i++)
{
    array[i] = char(*)malloc(sizeof(char *) * nb_of_column);
}
 
//Second pass of the file to fill the array
while (!feof(fp)) 
{
    int i = 0;
    int j = 0;
    end_of_line_found = 0;
 
    char buff[255]; 
    char current_buff[10];
 
    while(end_of_line == 0)
    {
        //read a line or the 255 first characters
        fgets(255,buff, fp); 
 
        //check if the line is something we want to keep
        if(buff[0] == '*' || (buf[0] > '9' && buf[0] < '0'))
        {
            //discard line, comments line, or invalid number
            continue;
        }
 
        //parse the row or the first 255 characters of it.
        while(buff[i] != 0)
        {
            if(buf[i] == '\n')
            {
                end_of_line_found = 1;
                break;
            }
            if(buff[i] >'9' && buff[i] < '0')
            {
                //In case the next char is not a number, we consider it as a separator
 
                current_buff[j++] = 0;
 
                //convert the string in integer
                array[line_nb][column_nb++] = atoi(current_buff);
                j = 0;
            }
            else
            {
                current_buffer[j++] = buff[i];
            }
            i++;
        }
    }
 
    line_nb ++;
    column_nb = 0;
}
 
nb_total=i;

Maintenant tu peux allouer une certaine taille par default et utiliser des realloc pour reallouer des blocks, mais personnellement je n'aime pas du tout cette facon de faire.

Par contre il te reste un bug dans le code que j'ai ecrit qui que lorsque la ligne fait plus de 255 caracteres, il est possible qu'un nombre soit coupe en deux. J'ai pas eu le courage de gerer ce cas . Mais d'un autre cote tu devrais etre capable de le gerer !!

Je n'ai pas teste le code, mais ca devrait pas etre loin de marcher!