Bonjour à tous,

Je suis bloqué actuellement je vous explique j'ai un ficher file1.txt qui contient des valeurs, je dois mettre c'est valeur dans un tableau mais là je bloque j'essaye de connaitre combien il y'a de valeur dans mon fichier pour avoir un tableau de bonne taille mais je n'y arrive pas voici mon code : 

int main() 
{
  ifstream file("file1");
  file.seekg(0, ios::end);
  int n=file.tellg();
  int *T=new int[n];
  for(int i=0;i<n;i++)
  {
    T[i]<<file;
  }
}

Utilise std vector plutôt qu'un new.

Je n'ai pas encore vu ça en cours on nous demande d'utiliser que ce que l'on a vu

C'est bizarre, utiliser l'opérateur new est complexe et les professionnels l'utilisent très peu, car fort risque de bug à son utilisation (2 problèmes dans ton exemple!). Pourquoi est-ce enseigné au début?

Pour tes réels stockés dans ton fichier, il faut connaître en premier le format de stockage. Par exemple, du texte ou du binaire.

// exemple de lecture texte qui aurait les valeurs écrites séparées par des \n
istream  file( "nomfichier.txt" );
double  value;
file >> value;
// exemple de lecture binaire qui aurait écrit en binaire des doubles bout à bout
istream  file( "nomfichier.bin" , std::ios::binary );
double  value;
file.read( &value , sizeof value );

Dans le second cas, on peut déduire de la taille du fichier le nombre d'élément à réserver. Un double fait 8 octets, donc la taille doit être divisée par 8 pour avoir le nombre de double. Si les nombres sont des int, il faut faire attention car les int font parfois 4 parfois 8 octets.
Dans le premier cas, on ne peut rien déduire de la taille du fichier, et si tu utilisais des vector<> comme indiqué par necros211, il suffirait de les mettre dedans et sa taille s'auto-adapterait. Avec des allocations par new c'est plus complexe. Il faudrait par exemple parcourir une première fois le fichier sans mémoriser les valeurs, juste pour savoir combien il y en a. On peut alors allouer avec new double[N], puis relire le fichier.

Ou bien faire des réallocations à mesure qu'on lit le fichier, c'est abominablement casse-gueule, mais c'est possible de le faire proprement. Quand je dis que c'est possible, je ne raconte pas de vantardises, il y a deux méthodes.

La première est abominablement compliquée, je ne vais pas la développer tout de suite...

La seconde est diaboliquement simple, elle consiste à se décharger de toute la difficulté de la gestion de la mémoire sur vector. vector est le fruit de la réflexion de programmeurs c++ dont le niveau se situe à des années lumières de celui du meilleur prof que tu pourras jamais avoir.

Pour revenir à la première méthode, cela revient ni plus ni moins, que refaire vector, c'est un exercice très intéressant, mais extrêmement difficile, qui dépasse largement les capacités d'un débutant même très avancé.

Il y a un autre point, le temps que tu vas passer sur la lecture de ton fichier, tu ne pourras plus le passer sur le reste de ton projet, de toutes les ressources, le temps est incontestablement la plus précieuse, c'est la seule que tu ne peux ni remplacer, ni compenser.

Je ne sais pas si j'ai bien compris la question, mais la réponse est plutôt simple puisque ça ne requière qu'un seul new/delete et non de multiples allocations:

// read a file into memory
#include <iostream>     // std::cout
#include <fstream>      // std::ifstream

int main () {
  std::ifstream is ("test.txt", std::ifstream::binary);
  if (is) {
    // get length of file:
    is.seekg (0, is.end);
    int length = is.tellg();
    is.seekg (0, is.beg);

    // allocate memory:
    char * buffer = new char [length];

    // read data as a block:
    is.read (buffer,length);

    is.close();

    // print content:
    std::cout.write (buffer,length);

    delete[] buffer;
  }

  return 0;
}

@Maeiky, 

Dans le monde fabuleux des bisounours peut-être, mais dans la vraie vie, is.read, std::cout & co, ça peut foirer et te balancer une exception dans la gueule. Et là t'es comme un con parce que ton buffer ne sera jamais libéré. Sur un petit main de test, on s'en fout, l'OS va faire le ménage, par contre sur une appli critique on s'en fout pas du tout, le temps qu'elle redémarre, l'avion s'est crashé, le réacteur nucléaire est parti en live, et là va expliquer aux familles des victimes que c'est un tout petit bug de rien du tout...

Et vector ne peut pas te balancer d’exception dans la gueule?

Si je prend le contexte qu'il ne s'agit que d'un exercice, il faut pas sortir le bazooka.
Si tu veux vraiment pas prendre de chance tu peux lancer tes ogives nucléaires sur le code pas fiable que j'ai copier de la ref de cplusplus.com et ajouter tout simplement des try/catch.

> Et vector ne peut pas te balancer d’exception dans la gueule?

Si, mais std::vector libère quoi qu'il arrive la mémoire. Même si ici je préfère utiliser std::unique_ptr (avec std::make_unique_default_init \o/)