transformer un tableau de char en string puis en float?

Version imprimable

30/04/2009, 10h51
maf.mouton

transformer un tableau de char en string puis en float?

Bonjour,

j'imagine que cette question est souvent revenue, mais il y a-t-il un moyen simple de tranformer un tableau de char en float?

En fait mon problème est le suivant: j'ai un fichier txt avec plein de données réelle, et je souhaiterais les récupérer dans un tableau... voilou, peut-être qu'il existe un moyen simple de faire ça, car j'ai beau chercher, j'ai l'impression qu'il n'existe rien alors que c'est quand meme quelque chose de basique... J'ai essayé plusieurs trucs de forum, mais rien de bien convaincant..
Merci 8-)
mouton
30/04/2009, 11h03
3DArchi
Salut,
Pourquoi ne pas utiliser mes flux pour ta lecture et injecter la valeur lue directement dans un float :
Code:

1 2 3 4 5 // a adapter évidemment ! std::ifstream fichier(nom_de_mon_fichier.c_str()); float valeur; fichier>>valeur;
30/04/2009, 11h05
maf.mouton

.. c'est quoi la différence entre fichier et nom_de_fichier si j'écris:

Code:

f=fopen("test1.txt","r");

(dsl moi=newby)

Citation:

Envoyé par maf.mouton

(dsl moi=newby)

Code:

1
2
3
4
5
6
 
// a adapter évidemment !
std::string nom_de_mon_fichier("test1.txt"); // chaine de caractère contenant le nom du fichier à ouvrir
std::ifstream fichier(nom_de_mon_fichier.c_str()); // flux ouvert sur le fichier que l'on souhaite lire
float valeur;
fichier>>valeur;

...comprend pas trop, enfin on va essayer...

je dois écrire ça alors:
Code:

1 2 3 4 std::string f("test1.txt"); // chaine de caractère contenant le nom du fichier à ouvrir std::ifstream f2(f.c_str()); // flux ouvert sur le fichier que l'on souhaite lire float valeur; f2>>valeur;
et en plus supprimer le fopen???

30/04/2009, 11h29
maf.mouton

Je donne aussi un extrait des fichiers de données....:

8.56260000 -0.99870000 -0.51240000 207 207 207
8.54840000 -0.99990000 -0.51160000 193 193 193
8.55960000 -1.00410000 -0.51220000 139 139 139
8.57160000 -1.00820000 -0.51290000 50 50 50
73.95980000 -8.72430000 -4.42530000 181 181 181
8.57120000 -1.01390000 -0.51290000 123 123 123
8.55720000 -1.01510000 -0.51210000 200 200 200
8.54770000 -1.01690000 -0.51160000 210 210 210
8.54960000 -1.01990000 -0.51170000 215 215 215

il y a 6 colonnes (et bcp plus de lignes) et on souhaite récupérer les 4 première lignes qui sont en fait le (x,y,z,couleur) d'un nuage de point...
30/04/2009, 12h11
maf.mouton

oki j'arrive à récupérer chacune des lignes séparément grâce à la faq C++....
mainteant, stocker dans un tableau de float et puis je serais contente pour la journée ....
30/04/2009, 12h16
3DArchi

Regarde std::vector pour le tableau.

Salut,

Pour répondre à ta question:fopen est une fonction issue du C, qui manipule typiquement des File Descriptor caché dans la structure FILE.

Le C++ préfère travailler sur base de flux de données, dont les classes ifstream (i pour input, f pour file ;)) et ofstream (o pour output, f pour... file itou).

Elles sont créées de manière à fournir une interface commune quelle que soit la donnée à lire (ou à écrire), et fonctionne "naturellement" quel que soit le type primitif utilisé, ainsi que s'il est nécessaire d'écrire des chaines de caractères.

Il est également possible de définir les opérateurs de flux << (pour l'écriture) et >> (pour la lecture) de tes structures de données personnalisées

Il existe un principe nommé RAII (Ressource Acquisition Is Initialisation) qui considère qu'il faut qu'une variable soit correctement initialisée dés le moment où elle est déclarée.

Du point de vue des flux de fichier, cela se traduit par le fait que, dés que l'on en déclare un, il faut être en mesure de lire (ou d'écrire, selon le cas) dans ce fichier.

Le but est, en définitive, de simplifier le plus possible l'utilisation de ces flux ;)

Il existe un certain nombre de possibilités de créer un fichier, dont celle proposée par 3DArchi (qui est celle à préférer aussi souvent que possible), qui nécessite, pour une question purement historique, de fournir le nom du fichier sous la forme d'une chaine de caractères "C style" (un tableau de caractères terminé par un '/0'.

Tu peux donc décider de créer un flux de lecture dans un fichier sous la forme de
Code:

1 2 std::ifstream ifs("mon_fichier.txt"); /* ici vient la lecture du fichier */
Mais, cela implique un problème de taille: la lecture ne pourra se faire que... dans mon_fichier.txt...

Si, par la suite, tu décider de créer un autre fichier qui pourrait être lu de manière identique à mon_fichier.txt, tu sera obligé de... recopier exactement le même code pour ce deuxième fichier, ce qui, il faut l'avouer, n'est pas des plus efficaces ;)

L'idée est donc de "factoriser" l'ouverture et la lecutre du fichier dans une fonction, et de fournir à cette fonction le nom du fichier sous la forme d'une chaine de caractères que l'on souhaite ouvrir.

Pour manipuler les chaines de caractères, nous utilisons la classe string, disponible dans l'espace de noms std par inclusion du fichier d'en-tête <string> de préférence à toute autre alternative issue du C (dont les fameuses chaines de caractères C style).

Pour passer une chaine de caractères en paramètre d'une fonction qui ne doit pas modifier la chaine en question, l'idéal reste toujours de la transmettre sous la forme d'une référence constante.

Mais, l'aberration historique aidant, il faudra, uniquement pour permettre d'ouvrir le fichier, convertir cette chaine de caractères de type string en une chaine de caractères C style.

Il se fait qu'il est très facile d'y arriver, car il existe une fonction membre de la classe string prévue à cet effet: la fonction membre c_str().

Tu en arrives donc à une fonction dont la forme sera proche de
Code:

1 2 3 4 5 6 7 8 9 TypeDeRetour lecture(std::string const& filename) { /* ouverture du fichier */ std::ifstream ifs(filename.c_str()); /* lecture du fichier * ... * retour éventuel */ }
Il sera ensuite assez facile de décider le fichier que tu veux lire en donnant simplement le nom de ce fichier comme argument à la fonction.

Cela peut prendre la forme "simple" de

Code:

lecture("mon_fichier.txt");

mais cela peut tout aussi bien prendre une forme plus complexe proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 std::string tempname("c:\\"); /*rajoutons le chemin d'acces au fichier */ tempname+="Program Files\\mon application\\ data"; /* créons dix noms de fichiers à lire de manière dynamique */ for (int i = 1;i<=10;++i) { /*stringstream est un flux de conversion "bi directionnel" */ std::stringstream ss; ss<<tempname<<"mon_fichier_"<<i<<".txt"; filename=ss.str(); lecture(filename); }
qui aura, selon l'exemple, comme résultat de lire les fichiers nommés resectivement mon_fichier_1.txt, mon_fichier_2.txt,(... tous les autres ...) ,mon_fichier_10.txt qui se trouvent dans c:\Program Files\mon application\data