1. #include <stdio.h>                             // fonction de base(printf, fgets,....)
2. #include <string.h>                            // strtok() -> decoupage de chaine de caracteres
3. #include <stdlib.h>                            // atof -> convertir une chaine de caractere en un float
5. #define CMAX                 400               // Nombre de ligne maximum du tableau
6. #define LMAX                 400               // Nombre de colonne maximum du tableau
7. #define MAX_CHAR_PER_LINE    1650              // Nombre de caratere maximum par ligne dans le fichier lu :  
8.                                                //       3*400+400+1 = 1601 mais j'ai mis 1650 pour arrondir
9. #define SEP                  " "               // Séparateur utilisé dans le fichier
10. #define PATH                 "test.txt"        // Mets l'emplacement de ton fichier contenant les valeurs
13. int main(int argc, char* argv[])
14. {
15.     FILE*    m_File;
16.     int        i;
17.     int        j;
18.     float    Tab[LMAX][CMAX];
19.     char    szbuff[MAX_CHAR_PER_LINE];
20.     char*    token;
22.    
23.    
24.     // On initialise le tableau a -1
25.     for(i=0;i<LMAX;i++)
26.     {
27.         for(j=0;j<CMAX;j++)
28.         {
29.             Tab[i][j] = -1;
30.         }
31.     }
32.    
33.     // On réinitialise le compteur de ligne car i;a été incrémenté lors de l'iniatialisation
34.     i = 0;
35.    
36.     // On ouvre le fichier en lecture seule et en mode texte
37.     m_File = fopen(PATH,"rt" );
39.     // On vérifie qu'il n'y ai pas eu d'erreur pendant l'ouverture du fichier
40.     if(!m_File) return 1;
42.     // On lit le fichier ligne a ligne et on stocke les valeurs dans un tableau d'entier
43.     // La boucle while a l'avantage de permettre la lecture d'un fichier sans connaitre son nombre de ligne exact
44.     // et nous évite donc de faire bugger le programme
45.     // Le "feof" veut "End Of File". On lit donc jusuqu'à la fin du fichier
46.     while(!feof(m_File) && i < LMAX)
47.     {
48.        
49.         j = 0;
51.         // On récupere la ligne courante du fichier
52.         fgets(szbuff,MAX_CHAR_PER_LINE,m_File);
53.        
54.         // On decoupe la ligne selon le charactere de séparation SEP (" " )
55.         token = strtok(szbuff,SEP);
57.         // On lit les éléments découpés un à un et on les stocke dans le tableau Tab
58.         while(token != NULL && j < CMAX)
59.         {
60.             // On stocke la valeur lue dans le tableau
61.             Tab[i][j] = atof(token);
62.             // On lit l'element suivant retourner par strtok
63.             token = strtok(NULL,SEP);
64.             // On incremente le compteur des ordonnées
65.             j++;
66.         }
67.        
68.         // On incrémente le compteur des abscisses
69.         i++;
70.     }
73.     // On affiche le tableau pour etre sur que tout s'est bien passé... Le \t correspond au caractere tabulation
74.     // Le 0.2f indique qu'on doit afficher un float avec 2 decimales après la virugle
75. int x;
76. int y;
77.     for(x=0;x<i;x++)
78.     {
79.         for(y=0;y<j;y++)
80.         {
81.             printf("%0.2f\t",Tab[x][y]);
82.         }
83.         printf("\n" );
84.     }
86.     return 0;
88. }

#include <stdio.h>                             // fonction de base(printf, fgets,....)
#include <string.h>                            // strtok() -> decoupage de chaine de caracteres
#include <stdlib.h>                            // atof -> convertir une chaine de caractere en un float
 
#define CMAX                 400               // Nombre de ligne maximum du tableau
#define LMAX                 400               // Nombre de colonne maximum du tableau
#define MAX_CHAR_PER_LINE    1650              // Nombre de caratere maximum par ligne dans le fichier lu : 
//       3*400+400+1 = 1601 mais j'ai mis 1650 pour arrondir
#define PATH                 "test.txt"        // Mets l'emplacement de ton fichier contenant les valeurs
 
 
int main(int argc, char* argv[])
{
   int ret;
   double Tab[LMAX][CMAX];
 
   // On initialise le tableau a -1
   {
      int i;
      for (i = 0;i < LMAX;i++)
      {
         int j;
         for (j = 0;j < CMAX;j++)
         {
            Tab[i][j] = -1;
         }
      }
   }
 
   {
      int nb_lin;
      int nb_col;
      // On ouvre le fichier en lecture seule et en mode texte
      FILE* m_File = fopen(PATH, "rt" );
 
      // On vérifie qu'il n'y ai pas eu d'erreur pendant l'ouverture du fichier
      if (m_File != NULL)
      {
         char szbuff[MAX_CHAR_PER_LINE];
 
         // Mise a 0 du compteur de ligne
         int i = 0;
 
         // On lit le fichier ligne a ligne et on stocke les valeurs dans un tableau d'entier
         // La boucle while a l'avantage de permettre la lecture d'un fichier sans connaitre son nombre de ligne exact
         // et nous évite donc de faire bugger le programme
         // On récupere la ligne courante du fichier
         while (fgets(szbuff, sizeof szbuff, m_File) != NULL && i < LMAX)
         {
            // On decoupe la ligne selon le charactere de séparation SEP (" " )
            char* token = szbuff;
 
            // mise a zero du compteur des ordonnees
            int j = 0;
 
            // On lit les éléments découpés un à un et on les stocke dans le tableau Tab
            while (*token != 0 && j < CMAX)
            {
               // On stocke la valeur lue dans le tableau
               Tab[i][j] = strtod (token, &token);
               token++;
 
               // On incremente le compteur des ordonnées
               j++;
            }
            nb_col = j;
 
            // On incrémente le compteur des abscisses
            i++;
         }
         nb_lin = i;
         /* fermeture du fichier */
         fclose (m_File), m_File = NULL;
         ret = EXIT_SUCCESS;
 
         {
            // On affiche le tableau pour etre sur que tout s'est bien passe...
            int x;
            int y;
            for (x = 0;x < nb_lin;x++)
            {
               for (y = 0;y < nb_col;y++)
               {
                  printf("%8.2f", Tab[x][y]);
               }
               printf("\n" );
            }
         }
      }
      else
      {
         perror(PATH);
         ret = EXIT_FAILURE;
      }
   }
 
   return ret;
}