Discussion :

[vbbarent]

Bonsoir à tous;
je souhaite faire en C++ un fonction qui puissent me permettre de renouveler les données d'un tableau. En effet, je dispose de données de grande taille que je souhaite traiter par paquets de quelques échantillons. Par exemple, j'ouvre un fichier (qui contient un tableau de données) en lecture dont j'ignore la taille. Mon objectif est de pouvoir récupérer les données dans un buffer dont je définis la taille. Lorsque le buffer est plein, je viens lire les données contenus dans celui-ci, puis je renouvelle son contenu;
ci joint le code que j'ai essayé de faire;

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
#include <stdio.h>
#include<vector>
#include<math.h>
#include<conio.h>
#include "UpdateSignal.h"
using namespace std;
 
int UpdateBuffer(float ech, float *Buffer,int indice,int tailleBuffer)
{   vector<float> sigEntre;    
    while(ech!=NULL)
    {	sigEntre.push_back(ech);
    	float *tmp=new float[tailleBuffer];
    	for (int k=0;k<tailleBuffer;++k)
    	{	tmp[k]=sigEntre[sigEntre.size()];
		Buffer[k]=tmp[k];
		}		
    	delete tmp;
		indice = sigEntre.size();
	}
	return indice;
}

Je sollicite votre aide;

[r0d]

Bonjour,

je ne comprend pas trés bien ce que tu souhaites faire. En plus tu ne commente pas ton code, et il est faux. Mais suis je puis me permettre quelques remarques:

- choisis des noms de variables explicites. "ech" par exemple, c'est quoi?
- si ech est un float, le code:

Code :

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

ech!=NULL

n'a aucun sens.

[vbbarent]

Voilà le code commenté

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
 
#include <stdio.h>
#include<vector>
#include<math.h>
#include<conio.h>
#include "UpdateSignal.h"
using namespace std;
 
int UpdateBuffer(float echantillon, float *Buffer,int NumeroEchantillon,int tailleBuffer)
/*ech = l'echantillon courant (la donnée courante)
 * Buffer = le tableau qui contient les échantillons
 * indice = nunero de l'echantillon;
 * tailleBuffer = taille du tableau buffer
 * 
 * */
{   vector<float> sigEntre; //tableau destiné à contenir tous les echentillons  
    int p=1;
	while(p==1) // Tant qu'il ya un echantillon je l'ajoute au tableau sigEntre
    {	p=0;
		sigEntre.push_back(echantillon);
    	float *tmp=new float[tailleBuffer];// variable temporaire
    	for (int k=0;k<tailleBuffer;++k)
    	{	//je souhaite mettre le dernier echantillon dans la première case du Buffer
    		tmp[k]=sigEntre[sigEntre.size()]; 
		Buffer[k]=tmp[k]; // recuperation des echantillons dans le buffer
		}		
    	delete tmp;
    	NumeroEchantillon = sigEntre.size();// recuperation du numero de l'echantillon
		p++;
	}
	return NumeroEchantillon;
}

En fait, Je souhaite précisément stocker les données dans un tableau dont la taille peut varier. Lorsque le tableau est plein, je viens ensuite lire les données puis je renouvelle les données du tableau. (En fait je vide le tableau et je le remplit à nouveau). Pendant ce temps, je ne dois pas lire dans le tableau.

[escafr]

ton code ne veut absolument rien dire, enfin il n'y a aucune logique dedans

A quoi te sers ton Vector? pkoi crées tu ensuite un tableau de float et pas un vector contenant ton sous echantillon?

enfin c'est vraiment pas clair.

[vbbarent]

Je dispose d'un fichier pouvant contenir jusqu'à un million d'échantillons d'un signal. Aussi, je veux traiter ces données par blocs de 1000 échantillons sans perdre le numéro de l'échantillon afin de déterminer certains paramètres. Si donc je mets directement l'echantillon dans mon Buffer, à partir d'un certain moment, il deviendra suffisamment grand, et par conséquent inutilisable. Et puisque je ne connais pas le nombre d'échantillons par avance je pense qu'en utilisant vector, je pourrai determiner celui-ci. Mon objectif c'est de pouvoir remplir mon tableau avec les 1000 premiers échantillons. Quand mon tableau est plein, je le lit, puis j'écrase les milles échantillons par les milles autres qui suivent (c'est -à-dire avec l'échantillon n°1001à1999) et ainsi de suite jusqu'à la fin. avec

Code :

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

sigEntre.size();

je pense ainsi être à mesure de determiner le numero de l'échantilllon qui entre dans le buffer à chaque instant.
Ce n'est pas un code executable, je souhaite l'intégrer dans une dll pour faire du temps réel.

je suis disponible pour toute question d'éclaircissement.

[r0d]

Ok, je cromprend mieux.

Je ne veux pas de décourager, mais il faut que tu sache que ce que tu veux faire là n'est pas trivial. Il y a plusieurs difficultés sournoises, à cause de ce que tu appelles "temps réel" (je n'aime pas ce terme, pour moi, il n'a aucun sens, mais bon, on se comprend, c'est le principal).

Déjà, sur la lecture du fichier, tu l'as déjà implémenté?

[r0d]

Je ne comprend toujours pas ce que tu veux faire. J'ai l'impression que le problème n'est pas bien clair pour toi, sinon tu saurais l'expliquer clairement.

En fait, Je souhaite précisément stocker les données dans un tableau dont la taille peut varier.

Pour un tableau de taille variable, rien de tel qu'un std::vector avec push_back();

Lorsque le tableau est plein,

Ca ne veut rien dire ça en c++. Un tableau est toujours plein, il y a toujours quelque chose dedans.

je viens ensuite lire les données puis je renouvelle les données du tableau.

Bon ok, c'est vendredi, je suis fatigué, mais vraiment, ça ne veut rien dire cette phrase.
Que signifie, pour toi "renouvellement"?

(En fait je vide le tableau et je le remplit à nouveau).

Tu le remplis avec quoi?

Pendant ce temps, je ne dois pas lire dans le tableau.

Tu dois faire plusieurs choses en même temps?
Désolé je comprend pas.

[vbbarent]

Je veux remplir le tableau avec des échantillons contenus dans un fichier ou provenant directement d'un capteur. Lorsque les échantillons proviennent d'un capteur, je dois pour les garder en vue de les sauvegarder. Lorsque je parle de taille variable, je veux dire que je fixe la taille du tableau pour un traitement donné. Quand je lis les échantillons dans le tableau, je veux les remplacer par de nouveaux échantillons. Mais je ne veux pas perdre également les numéros de ces échantillons.