Discussion :

[babykichon]

Bonjour, cela fait quelques annees que je n'ai plus touche a du C et je suis quelques peu rouille.

J'ai besoin de lire deux fichiers .txt
les donnees a l'interieur sont presentees de la facon suivante :

325
648.2541
321268
0.144
etc ...

je dois stocker les valeurs de fichier1.txt a la suite dans tab1[65] et de meme pour le deuxieme fichier.

Ensuite je dois faire des operations entre ces deux tableaux et ecrire le resultat dans un fichier de sortie.

Exemple pour etre plus clair :

J'ai 65 valeurs par fichier.
remplis mes tab1[65] et tab2[65] puis je fais y = tab1[i] + tab2[i] et j'ecris le resultat dans un troisieme fichier, une ligne par resultat.

Voici le code ( enfin si on peut dire ) que j'ai pondu pour le moment :

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
 
#include <stdio.h>
#include <stdlib.h>
 
int test (int argc, char *argv[])
{
 
    FILE* fSrc1;  //fichier1
    FILE* fSrc2;  //fichier2
    FILE* fDest;  //fichier Destination
 
    char Xn[65];
    int Nb1;    
    char Hn[65];
    int Nb2    
    double Yn;    
    int i = 0;
 
// j'ai virer la partie ou j'ouvre les fichiers, test si ca c'est bien passe.
//Ca marche etant donne que j'arrive a recopier les donnes d'un fichier dans 
//celui de sortie
 
/*************************************************
* Start Process
*************************************************/ 
 
         Nb1= fread(Xn, 1, 65, fSrcXn);
 
        for(i = 0; i < Nb1; i++)
        printf("%c", Xn[i]);
	printf("\n Nombre lus :%d", Nb1);
 
	fwrite(Xn, sizeof(Xn[0]), Nb1, fDest);
 
/*************************************************
* End Process
*************************************************/ 
 
  //Close Files  enlever aussi pour alleger :D 
 
    return 0;
}

Pour le moment tout ce que le code fait c'est reecrire le fichier1 dans le fichier de sortie. je galere a faire des operations sur mes tableaux en faite O_o

Donc voila, je crois que ce qu'on recupere d'un .txt est au format ASCII donc je suppose que si je veux inclure dans ma boucle un :

y = x[i] + h[i] il faudra surement forcer le typage en double ( besoin d'un max de precision )

Si quelqu'un a une petite idee, une piste, un conseil, une blague, je suis preneur

Merci d'avance

[Aldiemus]

Bonjour,

A mon avis ce que tu devrais faire c'est :

Ouvrir le fichier 1 en lecture et lire la première ligne
Ouvrir le fichier 2 en lecture et lire la première ligne
Ouvrir le fichier 3 en écriture
Tant qu'il y a une ligne lue dans le fichier 1 et dans le fichier 2
- Convertir les valeurs lue en nombre à virgule
- Additionner les deux nombres
- Ecrire le résultat dans le fichier 3
- Lire la ligne suivante dans le fichier 1
- Lire la ligne suivante dans le fichier 2
Fin Tant
Clore les 3 fichiers

Pour la conversion, tu peux par exemple utiliser la fonction atof() du C (alphanuméric to float). Voici un exemple de son utilisation :

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
view plainprint?
 
    #include <stdio.h>  
    #include <stdlib.h>  
 
    int main()  
    {  
        char *x = "12";  
        char *y = "23";  
 
        float coordX = atof(x);  
        float coordY = atof(y);  
 
        printf ("X : %f - Y : %f\n", coordX, coordY);  
 
        return 0;  
    }

Si ensuite tu veux reconvertir ton nombre a virgule en chaîne, tu peux passer par la fonction sprintf() : http://www.cplusplus.com/reference/c...stdio/sprintf/

Bonne journée,

Aldiemus

[babykichon]

Je te remercie de ton aide mais avant d'aller jusqu'a cette etape et comme je galere un peu , je veux y aller pas a pas.

Pour le moment je me suis rajouter un petit process pour deja verifier que le tableau se rempli bien. j'ai donc mi dans mon premier fichier txt les valeurs suivantes :
1
2
3
4

En sortie j'ai exactement la meme chose qui se recopie dans le fichier de destination MAIS, en rajoutant un petit bout de code debug que voici :

Code :

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

1
2
3
4
5
6
7
8
9
 
        NbXnLus = fread(Xn, sizeof(Xn[0]), 65, fSrcXn);
 
        for(i = 0; i < NbXnLus; i++)
            printf("\n Xn[%d] = %c", i, Xn[i]);
 
	printf("\n Nombre lus :%d", NbXnLus);
 
	fwrite(Xn, sizeof(Xn[0]), NbXnLus, fDest);

J'obtiens sur le terminal :

Xn[0] = 1
Xn[1] =
Xn[2] =

Xn[3] = 2
Xn[4] =
Xn[5] =

Xn[6] = 3
Xn[7] =
Xn[8] =

Xn[9] = 4
Nombre lus :10

Bon je vais jeter un coup d'oeil vu le bordel je dirais que fread renvoie la valeur en bytes ... enfin je suppose, si c'est le cas ca serait donc 8 octets pour les 4 chiffres (c'est 2 octets par asscii je crois) ... je comprends de toute facon pas le 10, peut etre le EOF ...

De plus pourquoi il se rempli de cette facon ce gentil tableau .. et pas en Xn[0,1,2,3] O_o

Il faut deja que j'arrive a regler ca avant de commencer des operations ^^


EDIT :
J'ai vraiment besoin de fonctionner par tableau car en faite j'implémente un filtre FIR et la sortie se calcul sur la somme des 65 x(n) d'entree * reponse impulsionnelle ( en faite un peu plus complique mais bon ce n'est pas le sujet ^^ )

[matafan]

Ton tableau se remplit ainsi car ton fichier ne contient pas que des chiffres, il contient aussi des retours à la ligne. Si tu es sous windows, un retour à la ligne c'est deux char, ce qui explique que tu te retrouves avec un chiffre tous les 3 indices.

4 chiffres, 3 retours à la ligne, 4 + 3*2 = 10 le compte est bon.

[jeroman]

Je ne comprends pas quel est l'intérêt d'utiliser des tableaux pour ce genre d'exo. On peut très bien s'en passer.

Par contre désormais il ne faut plus utiliser atof mais strtof (pour les float) ou strtod (pour les double) : http://man.developpez.com/man3/strtod.3.php

[babykichon]

Je ne comprends pas bien comment tu peux faire cela sans tableau en faite
car au final il n'y a pas seulement 65 entrees pour X mais 10 000 peut etre et donc a chaque fois il faut refaire les calculs sur les 65 dernieres entrees, il faut bien garder en memoire.

On pourrait bien sure faire un petit process pour garder juste en memoire l'entree 1 lorsqu'on est a la 66 valeurs de X et la soustraire a la derniere valeur de sortie trouve et decalle le tout au fur et a mesure mais ca semblerait moins intuitif que faire le process dans des tableaux quand meme

J'espere que je me suis bien exprime ca semble pas super clair a la re lecture

Concernant la facon dont se rempli le tableau je te remercie pour ton explication je abandonner l'idee d'utiliser la fct fread... car il faut que je filtre ce que je recupere en virant les retour chariot T_T

Vais me repencher sur ce probleme , merci pour vos explications.
Si une personne a une idee interessante qu'elle n'hesite pas haha

[diogene]

Je ne comprends pas bien comment tu peux faire cela sans tableau en faite
car au final il n'y a pas seulement 65 entrees pour X mais 10 000 peut etre et donc a chaque fois il faut refaire les calculs sur les 65 dernieres entrees, il faut bien garder en memoire.

On pourrait bien sure faire un petit process pour garder juste en memoire l'entree 1 lorsqu'on est a la 66 valeurs de X et la soustraire a la derniere valeur de sortie trouve et decalle le tout au fur et a mesure mais ca semblerait moins intuitif que faire le process dans des tableaux quand meme

Ton problème est donc en fait :

....j'implémente un filtre FIR et la sortie se calcul sur la somme des 65 x(n) d'entree * reponse impulsionnelle ( en faite un peu plus complique mais bon ce n'est pas le sujet ^^ )

Ce n'est pas du tout le même problème que celui exposé dans ton premier post.

[jeroman]

Je ne comprends pas bien comment tu peux faire cela sans tableau en faite
car au final il n'y a pas seulement 65 entrees pour X mais 10 000 peut etre et donc a chaque fois il faut refaire les calculs sur les 65 dernieres entrees, il faut bien garder en memoire.

Comment pouvait-on le deviner ? D'où l'importance de toujours expliquer clairement et précisément le problème, sinon on part sur de mauvaises pistes et les réponses données ne sont plus adaptées au problème.

[babykichon]

En effet ...


C'est pour cette raison que je n'ai pas trop insiste sur le calcul car celui ci ne posera surement pas de probleme.

Comme je l'ai dit en faite le probleme consiste a pouvoir remplir mes tableaux provenant des fichiers .txt de facon correct.

[babykichon]

Le process pour lire le .txt est le suivant maintenant :
(j'ai vraiment abandonner l'idee du fread, c'est dommage c'etait joli )

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
float Xn[65];
char *temp;
 
for(i=0 ; i< 5 ; i++)
{
fscanf(fSrcXn,"%s \n", temp);
Xn[i] = (float)*temp;
printf("temp = %s \n", temp);
printf("Xn[%i] = %f \n", i, Xn[i]);
}

le fichier de lecture est organise comme suit :

0.545
5415.5
1298.5
16.8549
9877.121


le resultat console est le suivant :

temp = 0.545
Xn[0] = 48.000000
temp = 5415.5
Xn[1] = 53.000000
temp = 1298.5
Xn[2] = 49.000000
temp = 16.8549
Xn[3] = 49.000000
temp = 9877.121
Xn[4] = 57.000000

_________

Forcement le forcage de type foire (surtout que vous m'avez conseille d'utiliser strtof ), mais le probleme etant que la bonne a garder etant celle lu en char si je la converti en float ca ne changera rien au faite que je n'aurai pas la bonne valeur ( en raisonnant avec mes connaissances qui, dans le domaine, sont legeres ).

J'aimerais qu'il garde la valeur lu mais force le type de char en float.

[diogene]

Code :

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

1
2
3
char *temp;
....
fscanf(fSrcXn,"%s \n", temp);

Pourquoi lire une chaine de caractère pour la ranger à une adresse indéterminée (temp est un pointeur non initialisé) ?

Code :

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

Xn[i] = (float)*temp;

Ceci n'a aucune chance de transformer une chaine de caractère en le flottant correspondant à cette chaine. Pour faire ce type de choses, on t'a déjà signalé les fonctions à utiliser.

Sinon ,

Code :

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

1
2
3
4
5
6
7
float Xn[65];
....
for(i=0 ; i< 5 ; i++)
{
   fscanf(fSrcXn,"%f", &Xn[i]); // ou fscanf(fSrcXn,"%f", Xn+i);
   printf("Xn[%i] = %f \n", i, Xn[i]);
}

[babykichon]

Punaise mais j'ai tellement honte ....

c'etait la solution que j'avais essaye en tout premier car ca paraissait simple, mais elle ne marchait, je pensais que c'etait a cause du format ASCII du fichier .txt ... mais j'avais simplement du faire une erreur stupide dans le code, du coup j'etais parti sur d'autres pistes ....

Merci beaucoup, forcement ca marche mieux ....
je te remercie beaucoup ^^