Tableaux dynamiques en parametre [Fermé]

Signaler
-
 Mau -
voila j'ai une fonction :

void Ireq (float *Gata){
Gata[i]=0;
}

et je veux passer un tab dyn en parametre...
float *tab;
tab= (float*)malloc(smurtz*sizeof(...);

donc Ireq(tab);

ca marche pas???

2 réponses

Messages postés
4
Date d'inscription
vendredi 5 avril 2002
Statut
Membre
Dernière intervention
15 avril 2002

Ca doit marcher, il n'y as pas de problème de type. Cependant, si tu peux, travaille en C++ pour pouvoir faire des new (pour des problèmes d'alignement en mémoire)(sii tu veux plus d'info, maile moi en privé, je vais pas commencer avec ça ici).
Un exemple qui fonctionne :

#include <malloc.h>
void ireq(float*);

int main(int argc, char* argv[])
{
float* tab;
int nb = 5;
tab = (float*) malloc(nb*sizeof(float));/*allocation d'un tableau de 5 float*/
ireq(tab);
free(tab);/*libération d'un bloc mémoire : super important dans les programmes, à ne pas oublier*/
return 0;
}

void ireq(float * Gata){
int i =3;
Gata[i] = 0;/*on met 0 dans le 4ème élément du tableau*/
}

je recommende plutot que malloc, d'utiliser (en C pur) calloc :
#include <malloc.h>
void ireq(float*);

int main(int argc, char* argv[])
{
float* tab;
int nb = 5;
tab = (float*) calloc(nb,sizeof(float));/*allocation d'un tableau de 5 float et mise à 0 des éléments de ce tableau*/
ireq(tab);
free(tab);/*libération d'un bloc mémoire : super important dans les programmes, à ne pas oublier*/
return 0;
}

void ireq(float * Gata){
int i =3;
Gata[i] = 1;/*on met 1 dans le 4ème élément du tableau*/
}

En version C++ cela devient (c'est plus propre) :
#include <malloc.h>
void ireq(float*);

int main(int argc, char* argv[])
{
float* tab;
int nb = 5;
tab = new float[nb];/*allocation d'un tableau de 5 float*/
ireq(tab);
delete []tab;/*libération d'un bloc mémoire : super important dans les programmes, à ne pas oublier*/
return 0;
}

void ireq(float * Gata){
int i =3;
Gata[i] = 0;/*on met 0 dans le 4ème élément du tableau*/
}
dernière chose :
utilisation de calloc,malloc,realloc oblige d'utiliser free pour relacher la mémoire.
utilisation de new oblige d'utiliser delete dans le programme

A+
Bruno
Salut,
en fait mon problème c'est que :
Ce que tu à mis dans ton main, je veux l'effectuer dans une fonction du style.

void f(float *tab,unsigned size,float *Sortie){

float *tab2;
tab2 = (float *) calloc(size*sizeof(float));

for( i;i<size;i++){
tab2[i]=(tab[i]<0)?tab[i]:(float)0.0;
}

j'appelle une dll ou une fonction qui travaille tab2;
et qui a en sontie un tableau de taille identique,
que je me fais un plaisir d'envoyer dans *sortie;

Oui je sais c'est un peu compliqué mais le but c'est de faire une DLL
qui prend en parametre un tableau d'entrée et un de sortie,
fait une opération sur l'entrée la stoke sur un tableau quelle crée de meme taille(pour etre plus dynamique)
fait une opération sur ce tableau et l'envoie en sortie;

NB: si je crée un tableau en dur dans le main : OK;
si je crée un tableau en dynamique dans le main : OK;
si je crée un tableau en dynamique dans une fonction : Pas OK;

et je sais pas pourquoi, il compile mais fait une erreur d'assert...

Apres ca je comprendrais tres bien que tu ne veuille plus me parler...

Allez A+
Et Merci encore... Manu
Messages postés
4
Date d'inscription
vendredi 5 avril 2002
Statut
Membre
Dernière intervention
15 avril 2002
> Mau
C'est normal que celà ne marche pas. Tu modifie la valeur de Sortie (passage par valeur), ce que tu ne peux pas faire en C. Tu as 2 solution : passer le pointeur sur ton tableau de pointeur de float :
#include <malloc.h>
void f(float* tab, unsigned size,float ** Sortie);
int main(int argc, char* argv[])
{
float tab1[5],*tab2;
tab1[0] = 1;
tab1[1] = 1;
tab1[2] = -1.3;
tab1[3] = 1.2;
tab1[4] = -1;
f(tab1,5,&tab2);
return 0;
}

void f(float *tab,unsigned size,float **Sortie){
float *tab2;
tab2 = (float *) calloc(size,sizeof(float));

for(int i=0;i<size;i++){
if (tab[i]<0){
tab2[i]=tab[i];
}else{
tab2[i]=0.0;
}
}
*Sortie = tab2;
}


Ou, si tu ne veux pas voir de float**,
#include <malloc.h>
float* f(float* tab, unsigned size);
int main(int argc, char* argv[])
{
float tab1[5],*tab2;
tab1[0] = 1;
tab1[1] = 1;
tab1[2] = -1.3;
tab1[3] = 1.2;
tab1[4] = -1;
tab2 = f(tab1,5);
return 0;
}

float* f(float *tab,unsigned size){
float *tab2;
tab2 = (float *) calloc(size,sizeof(float));

for(int i=0;i<size;i++){
if (tab[i]<0){
tab2[i]=tab[i];
}else{
tab2[i]=0.0;
}
}
return tab2;
}

Je te rassure, c'est une erreur courante. Pour l'ASSERT, c'est un test fait à l'exécution quand tu travaille en mode debug. Celà permet de détecter certaines erreur, entre autre celles de passage de pointeur (ici, c'est parce que tu fait un access violation je suppose....)
Et voilà.

Je ne vois pas pourquoi je refuserais de te parler....

Le seul problème, c'est que tu n'a pas l'air d'une femme ;)

A+
Phy
"Beuhh encore  un bug"
>
Messages postés
4
Date d'inscription
vendredi 5 avril 2002
Statut
Membre
Dernière intervention
15 avril 2002

Salut...

Ben en fait comme je ne passe pas un tableau de pointeur en sortie, ca a marché.

J'avais en fait juste une erreur, de variable globale...

Le style qui fait que tu sais pas d'ou viens l'erreur, enfin.

Par contre si tu sais ou connais un code qui permet d'ouvrir et de traiter un fichier .wav...

ca serais cool...

pour ta dernière phrase, non je suis désolé je n'en suis pas une...
Messages postés
1276
Date d'inscription
jeudi 7 décembre 2000
Statut
Contributeur
Dernière intervention
26 février 2009
170
today, je ne p rien faire, mais demain j'y jetterai un coup d'oeil et je te dirai peut etre quelque chose, mais par ailleurs, il est faux de passer en parametre un pointeur sur un tableau en parametre en sachant que tu vas le modifier.En fait si tu modifies quelque chose, tu ne modifies rien du tableau mais plutot le pointeur et c'est pourqoi t'as un assert, c'est ton pointeur qui cause cela.
Donc, soit tu declares ton tableau de sortie de taille size(comme size c'est la taille de ton tableau initial), soit le C/C++ te permet de declarer un tableau en parametre en omettant la derniere taille ie ds la definition et declaration de ta fct, t'as ceci :

void toto( float *entree, unsigned short size, float sorti[] );
et la tu manipules sortie comme ds les tableaux normaux.
et pour l'utiliser, tu fais ds leprogramme appelant :
float param_sortie[size];
toto(*entree,size,sortie);
RM: fais tres attention que ton tableau passe en parametre reel ait la meme taille que celui du parametre reel representant le parametre entree.

j'espere t'avoir aide.
tafiscobar