Lorsque je compile mon programme sous visual basic j'obtiens cette erreur:
CXX0030: Erreur : impossible d'évaluer l'expression.
Je ne sais pas qu'est ce que je dois faire. L'erreur se produit dans les allocations dynamiques. Dans le prog_2 le tableau ne s'arrête pas.
J'ai essayer un autre programme qui fonctionne très bien sous linux (mandriva) et il me donne les même erreurs alors que mon programme fonctionne bien sous linux.
Merci pour votre aide.
P.S: le prog_1 c'est le programme qui fonctionne
le prog_2 c'est le programme que je suis en train de réaliser.
/***********************************************/
/****************PROG 1*************************/
/***********************************************/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define LIGNES nbre_valeurs
#define COLONNES 3
void calibration_accelero (void)
{
/**************************************/
/*[Xmax X0g Xmin]=[] */
/*[Ymax Y0g Ymin]=[] */
/*[Zmax Z0g Zmin]=[] */
/**************************************/
}
double** conversion_en_g (double **valeurs_saisies, int nbre_valeurs)
{
double x_adc_val=0, y_adc_val=0, z_adc_val=0;
double **g_val_tmp, **g_val;
int i,j,k;
g_val=((double **)malloc (nbre_valeurs*sizeof (int *)));
for(i=0;i<nbre_valeurs;i++)
g_val[i]=((double*)malloc(3*sizeof(int)));
g_val_tmp=((double **)malloc (nbre_valeurs*sizeof (int *)));
for(i=0;i<nbre_valeurs;i++)
g_val[i]=((double*)malloc(3*sizeof(int)));
/**************************************/
/*ACQUISITION DES VALEURS DE X, Y ET Z*/
/**************************************/
for(i=0; i<nbre_valeurs; i++)
{
for(k=0; k<nbre_valeurs; k++)
{
x_adc_val += valeurs_saisies[k][0];
y_adc_val += valeurs_saisies[k][1];
z_adc_val += valeurs_saisies[k][2];
}
printf(" adc_val X=%d Y=%d Z=%d ",x_adc_val, y_adc_val, z_adc_val);
/*************************************/
/* STOCKAGE DES VALEURS DE X, Y ET Z */
/* DANS UN TABLEAU AFIN DE CONVERTIR */
/* EN g ET CALCULER LES INTEGRALES */
/**************************************/
for(j=0; j<=2; j++)
{
g_val_tmp[i][j] = x_adc_val/20;
g_val_tmp[i][j] = y_adc_val/20;
g_val_tmp[i][j] = z_adc_val/20;
}
}
/******************************************/
/*** CONVERSION EN g ***/
/*g_val= (adc_val-count_at_0g)/count_per_g*/
/*count_at_0g = 512 */
/*sensibilité de 300mV/g => count_per_g = (0.3/3)*1024=102.4*/
/*[Xmax X0g Xmin]=[] */
/*[Ymax Y0g Ymin]=[] */
/*[Zmax Z0g Zmin]=[] */
/**************************************/
for(i=0; i<=nbre_valeurs; i++)
{
for(j=0; j<=2; j++)
{
g_val[i][j] = (g_val_tmp[i][j] -512)/102.4;
g_val[i][j+1] = (g_val_tmp[i][j+1] -512)/102.4;
g_val[i][j+2] = (g_val_tmp[i][j+2] -512)/102.4;
}
}
printf(" X=%d Y=%d Z=%d ",g_val[i][j], g_val[i][j+1], g_val[i][j+2]);
return g_val;
}
void integraleRect (int nbre_valeurs, double **g_val)
{
int a, b, n, i, j;
double dt, x, y, z;
double aire, aire_x, aire_y, aire_z; //float pr les nbres a virgule
printf("Donnez les valeurs des bornes a et b de l'intégrale:\n");
scanf("%d %d", &a, &b);
printf("Donnez le nombre de rectangles:\n");
scanf("%d", &n);
dt = (b-a)/n;
for(i=0; i<nbre_valeurs; i++)
{
for(j=0; j<2; j++)
{
x = g_val[i][j];
y = g_val[i][j+1];
z = g_val[i][j+2];
//for(x=a; x<b; x+=dt) //x=1 au lieu de a
aire_x = x*dt; // ou aire_x += x*dt; normalement non
//init dt???
//dt = (b-a)/n;
//for(y=a; y<b; y+=dt)
aire_y = y*dt; // ou aire_y += y*dt;
//dt = (b-a)/n;
//for(z=a; z<b; z+=dt)
aire_z = z*dt; // ou aire_z += z*dt;
}
}
aire = aire_x + aire_y + aire_z;
printf("La vitesse est de %d m/s avec methode des rect\n", aire);
}
void integraleTrap (int nbre_valeurs, double **g_val)
{
int a, b, n, i, j;
double dt, x, y, z; //passer le tableau avec les valeurs de x_g_val, y_g_val, z_g_val
double aire, aire_approx_x, aire_approx_y, aire_approx_z, aire_x, aire_y, aire_z; //float pr les nbres a virgule
printf("Donnez les valeurs des bornes a et b de l'intégrale:\n");
scanf("%d %d", &a, &b);
printf("Donnez le nombre de rectangles:\n");
scanf("%d", &n);
dt = (b-a)/n;
for(i=0; i<=nbre_valeurs; i++)
{
for(j=0; j<=2; j++)
{
x = g_val[i][j];
y = g_val[i][j+1];
z = g_val[i][j+2];
aire_approx_x = (dt * (x + x+1))/2;
aire_approx_y = (dt * (y + y+1))/2;
aire_approx_z = (dt * (z + z+1))/2;
//for(x=a; x<b; x+=dt) //x=1 au lieu de a
aire_x = x*dt; // ou aire_x += x*dt; normalement non
//init dt???
//dt = (b-a)/n;
//for(y=a; y<b; y+=dt)
aire_y = y*dt; // ou aire_y += y*dt;
//dt = (b-a)/n;
//for(z=a; z<b; z+=dt)
aire_z = z*dt; // ou aire_z += z*dt;
}
}
aire = aire_approx_x + aire_x + aire_approx_y + aire_y + aire_approx_z + aire_z;
printf("La vitesse est de %d m/s avec methode des trap\n", aire);
}
double** read_adc_channel ()
{int nbre_valeurs=0;
int i, j, k=0;
double **valeurs_saisies=(malloc (sizeof *valeurs_saisies * LIGNES));
for(i=0;i<nbre_valeurs;i++)
valeurs_saisies[i]=(malloc(sizeof **valeurs_saisies * COLONNES));
printf("Veuillez saisir le nbre de valeurs de l'accelerometre :");
scanf("%d",&nbre_valeurs);
for(i=1; i<=nbre_valeurs; i++)
{
for(j=0;j<3;j++)
{
if(k==0)
{
printf("Veuillez saisir les valeurs n%d de x:",i);
k=1;
}
else if(k==1)
{
printf("Veuillez saisir les valeurs n%d de y:",i);
k=2;
}
else if(k==2)
{
printf("Veuillez saisir les valeurs n%d de z:",i);
k=0;
}
scanf("%d",&valeurs_saisies[j]);
}
nbre_valeurs++;
printf("i=%d\n",i);
}
return valeurs_saisies;
}
int main ()
{
double **valeurs_saisies=0, **g_val=0, **b;
int nbre_valeurs=0;
read_adc_channel ();
b = conversion_en_g (valeurs_saisies, nbre_valeurs);
integraleRect (nbre_valeurs, g_val);
integraleTrap (nbre_valeurs, g_val);
while (1) {};
return 0;
}
/***********************************************/
/****************PROG 2*************************/
/***********************************************/
#include <stdio.h>
#include <stdlib.h>
typedef struct arbre arbre;
struct arbre
{
int valeur;
arbre *gauche;
arbre *droite;
};
arbre *insere (arbre *a, int val)
{
if(a==NULL)
{
a=((arbre *)malloc(sizeof(arbre))); //CR??ATION DE L'ESPACE M??MOIRE POUR L'ARBRE
a-> valeur = val;
a-> gauche= a -> droite = NULL; //INITIALISATION DES VALEURS DES FILS A NULL
}
else if (a-> valeur < val) //INSERTION DES DIFF??RENTES VALEURS DE L'ARBRE A DROITE OU A GAUCHE
a-> droite = insere (a-> droite, val);
else
a-> gauche = insere (a-> gauche, val);
return a;
}
arbre *miroir (arbre *a)
{
arbre *b;
if(a==NULL) return NULL;
b=((arbre *)malloc(sizeof(arbre))); //CR??ATION DE L'ESPACE M??MOIRE POUR L'ARBRE
b-> valeur = a->valeur;
b->gauche=miroir(a->droite);
b->droite=miroir(a->gauche);
return b;
}
void affiche(arbre *a) //AFFICHE LES VALEURS DE L'ARBRE
{
if(a == NULL) return;
affiche(a->gauche);
printf("%d",a->valeur);
printf("(");
if(a->gauche!=NULL)
printf("%d",a->gauche->valeur);
printf(" - ");
if(a->droite!=NULL)
printf("%d",a->droite->valeur);
printf(")\n");
affiche(a->droite);
}
arbre* supprime (arbre* a, int v_sup)
{
arbre* b, *c;
if(a==NULL)
{
printf("valeur inexistante\n");
return NULL;
}
if (v_sup==a->valeur)
{
if(a->gauche==NULL)
{
b=a->droite;
free(a);
return b;
}
if(a->droite==NULL)
{
b=a->gauche;
free(a);
return b;
}
else
{
b=a->droite;
if(b->gauche!=NULL)
{
while(b->gauche!=NULL)
{
c=b;
b=b->gauche;
}
a->valeur=b->valeur;
c->gauche=b->droite;
free(b);
}
else
{
a->valeur=b->valeur;
a->droite=b->droite;
}
}
}
else if (v_sup>a->valeur)
a->droite=supprime(a->droite,v_sup);
else if (v_sup<a->valeur)
a->gauche=supprime(a->gauche,v_sup);
return a;
}
int main ()
{
int i, nbre_valeurs, valeurs_saisies,v_sup;
arbre* a;
char quit='c';
printf("Veuillez saisir le nombre de valeurs de l'arbre :");
scanf("%d",&nbre_valeurs);
for(i=0; i<nbre_valeurs; i++)
{
printf("Veuillez saisir la valeur n??%d :",i+1);
scanf("%d",&valeurs_saisies);
a=insere(a, valeurs_saisies);
}
affiche(a);
a=miroir(a);
printf("\n");
affiche(a);
while(quit != 'A' && quit !='a')
{
printf("Valeur a supprime ? ");
scanf("%d",&v_sup);
a=supprime(a,v_sup);
affiche(a);
nbre_valeurs=nbre_valeurs-1;
if(nbre_valeurs==0)
{
printf("Plus de tableau\n");
quit='a';
}
else
{
printf("Pour arreter la suppression appuyer sur a: ");
scanf(" %c",&quit);
printf("\n");
}
}
return 0;
}
