Allocation dynamique d´un tableau

j´ai un probleme avec les indices d un tableau. En effet je dois utiliser plusieurs parametres( 14 au total) mais j en choisi que 10 pour chaque experience donc pour voir lequel est selectionne je fait ca:
Code:

1 2 3 4 5 6 7 8 9 10 for (i4=0; i4<14; i4++) { if(glParam[i4].Active) { data1[i4] = Parameters[i4].Low; data2[i4] = Parameters[i4].High; fprintf(out,"test in the %d loop : parameter low %d paramter high %d data1 %d data 2 %d \n", i4, Parameters[i4].Low, Parameters[i4].High, data1[i4],data2[i4] ); } }
mais le probleme c est que dans mes tableaux j ai des trous.
Moi je voudrais avoir mes tableaux avec tous les parametres actives avec pour indice 0 1 2 3 4 5 6 7 8 9 et ne pas en avoir un au numero 2 par exemple et rien au numero 3.
Peut on y arriver avec des changements d indice ou dois je redefinir un nouveau tableau?

Citation:

mais le probleme c est que dans mes tableaux j ai des trous.
Moi je voudrais avoir mes tableaux avec tous les parametres actives avec pour indice 0 1 2 3 4 5 6 7 8 9 et ne pas en avoir un au numero 2 par exemple et rien au numero 3.

Je n'ai pas bien compris ton problème.
Est-ce que c'est quelque chose comme ça ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 for (i4=0; i4<14; i4++) { if(glParam[i4].Active) { switch(i4) { case 2 : case 3 : break; default : data1[i4] = Parameters[i4].Low; data2[i4] = Parameters[i4].High; fprintf(out,"test in the %d loop : parameter low %d paramter high %d data1 %d data 2 %d \n", i4, Parameters[i4].Low, Parameters[i4].High, data1[i4],data2[i4] ); } } }

En faite je rempli data1 et data2 avec les donnees parametres low and high mais j´ai le meme indice i4 et donc quand j ai un parametre qui n est pas active il y aura un trou dans le tableau.

je veux dire si paramtres[0] est active et parametres[1] n est pas active et parametre[3] est active
quand j ecris dans data1 et 2
data1[0] vaudrait bien la bonne valeur
data1[2] aussi
mais il n yaura rien dans data1[1]

et moi jai besoin d un tableau avec les donnees dans data[0],data[1],
data[2],data[3],data[4]... juste pour les parameters actifs.

voila ce que j ai fait:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 void order(int data[14], int data1[10]) { int i=0, j=0; for(i=0; i<14; i++) { if (data[i]=0) { i++ ; } else { data1[j]=data[i]; j++; } } }
afin d´ordonner les elements dans un autre tableau.Et avant j ai ecrit que quand le parameter n est pas actif j ecris 0 dans la case i4 correspondante.
mais je pense c est un bourrin comme methode.

Je pourrais pitetre le faire avec la fonction switch mais je ne pense pas que ce soit le plus simple.
Je veux juste que les donnees que je met dans data soit indexe de 0 a 10 alors que je teste 14 parametres.

Je n'ai pas du tout compris ta question. Mais dans ton code, il y a déjà un problème :

Code:

if (data[i]=0)

Citation:

Envoyé par jeroman

Je n'ai pas du tout compris ta question....

Moi non plus

Oups desole if(data[i]==0)

En faite je rentre les parametres que je veux utiliser:
param1 10 active
param2 non actif
param3 20 active
param4 25 active
param5 30 active
param6 non actif
param7 non actif
param8 40 active
param9 40 active
param10 40 active
param11 40 active
param12 40 active
param13 50 active
param14 non actif

ensuite je verifie s´ils ont ete actives avec une boucle for pour parcourir tout les parametres et un if pour verifier s ils sont actives ou non.

Citation:

for (i4=0; i4<14; i4++)
{

if(glParam[i4].Active)
{

data1[i4] = Parameters[i4]

}
else
{
data1[i4] = 0;

}
}

Le probleme c´est les que j´ai des 0 dans le tableau data1 et j´aimerais avoir seulement un tableau avec les 10 elements qui correspondent aux parametres actives.

J´ai solutionne mon probleme avec un methode un peu barbare mais bon ca marche:

Code:

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
for (i4=0; i4<NUMBER_OF_PARAMS; i4++)
        {
 
 
                        if(glParam[i4].Active)
                        {
 
                        data1[i4] = Parameters[i4].Low;
                        data2[i4] = Parameters[i4].High;
 
                        }
                        else
                        {
                        data1[i4] = -1;
                        data2[i4] = -1;
 
                        }
                                        switch(i4)
                                        {
                                case 0:
                                        if((data1[i4]!=-1)&&(data2[i4]!=-1))
                                        {
                                        data11[i5]=data1[i4];
                                        data22[i5]=data2[i4];
                                        i5++;
                                        }
                                break;
                                case 1:
                                        if((data1[i4]!=-1)&&(data2[i4]!=-1))
                                        {
                                        data11[i5]=data1[i4];
                                        data22[i5]=data2[i4];
                                        i5++;
                                        }
                                break;
                                case 2:
                                        if((data1[i4]!=-1)&&(data2[i4]!=-1))
                                        {
                                        data11[i5]=data1[i4];
                                        data22[i5]=data2[i4];
                                        i5++;
                                        }
                                break;
                                case 3:
                                        if((data1[i4]!=-1)&&(data2[i4]!=-1))
                                        {
                                        data11[i5]=data1[i4];
                                        data22[i5]=data2[i4];
                                        i5++;
                                        }
                                break;
                                case 4:
                                        if((data1[i4]!=-1)&&(data2[i4]!=-1))
                                        {
                                        data11[i5]=data1[i4];
                                        data22[i5]=data2[i4];
                                        i5++;
                                        }
                                break;
                                case 5:
                                        if((data1[i4]!=-1)&&(data2[i4]!=-1))
                                        {
                                        data11[i5]=data1[i4];
                                        data22[i5]=data2[i4];
                                        i5++;
                                        }
                                break;
                                case 6:
                                        if((data1[i4]!=-1)&&(data2[i4]!=-1))
                                        {
                                        data11[i5]=data1[i4];
                                        data22[i5]=data2[i4];
                                        i5++;
                                        }
                                break;
                                case 7:
                                        if((data1[i4]!=-1)&&(data2[i4]!=-1))
                                        {
                                        data11[i5]=data1[i4];
                                        data22[i5]=data2[i4];
                                        i5++;
                                        }
                                break;
                                case 8:
                                        if((data1[i4]!=-1)&&(data2[i4]!=-1))
                                        {
                                        data11[i5]=data1[i4];
                                        data22[i5]=data2[i4];
                                        i5++;
                                        }
                                break;
                                case 9:
                                        if((data1[i4]!=-1)&&(data2[i4]!=-1))
                                        {
                                        data11[i5]=data1[i4];
                                        data22[i5]=data2[i4];
                                        i5++;
                                        }
                                break;
                                case 10:
                                        if((data1[i4]!=-1)&&(data2[i4]!=-1))
                                        {
                                        data11[i5]=data1[i4];
                                        data22[i5]=data2[i4];
                                        i5++;
                                        }
                                break;
                                case 11:
                                        if((data1[i4]!=-1)&&(data2[i4]!=-1))
                                        {
                                        data11[i5]=data1[i4];
                                        data22[i5]=data2[i4];
                                        i5++;
                                        }
                                break;
                                case 12:
                                        if((data1[i4]!=-1)&&(data2[i4]!=-1))
                                        {
                                        data11[i5]=data1[i4];
                                        data22[i5]=data2[i4];
                                        i5++;
                                        }
                                break;
                                case 13:
                                        if((data1[i4]!=-1)&&(data2[i4]!=-1))
                                        {
                                        data11[i5]=data1[i4];
                                        data22[i5]=data2[i4];
                                        i5++;
                                        }
                                break;
                                } //end of switch
 
 
        }//enf of for

8O ! Tu peux largement simplifier tout ton switch en 6 lignes seulement. Vu que toutes les conditions du switch sont associées au même code, pourquoi se compliquer ?
Tu peux remplacer tout ça par :
Code:

1 2 3 4 5 6 if (i4>=0 && i4<=13 && data1[i4]!=-1 && data2[i4]!=-1) { data11[i5]=data1[i4]; data22[i5]=data2[i4]; i5++; }

merci,
je me disais bien qu´il y avait plus simple.

J´ai une autre question.
Est ce qu´il est possible de creer un tableau de cette maniere

Code:

int* tab=malloc(n*sizeof(double))

dans une boucle for et de changer la taille de mon tableau en meme temps que l´indice de mon tableau.
parce qu´ en faite j´ai quelque chose de la forme
int n;
Code:

1 2 3 4 for(i=0;i<N;i++) int* tab=malloc((n+10*i)*sizeof(double))//delaration d´un tableau de n doubles remplissage du tableau ...
Est ce que je dois supprimer tous les elements a chaque fois et les reecrire dans mon tableau.Parce qu´en faite je dois rajouter des valeurs dans mon tableau a chaque iteration.

il y a realloc() pour cela qui permet d'agrandir un bloc attribué par malloc()

Mais en faite j´ai N points et chaque points a 10 parametres.

moi je recupere tous les parametres de mes points dans par exemple tab[N*10].

Donc j ai tab[0]= premiere coordonnee du premier point

tab[1]=premiere coordonne du deuxieme point

tab[2]=premiere coordonne du troisieme point

...

...

tab[N]=deuxieme coordonnee du premier point

tab[N+1]=deuxieme coordonnee du deuxieme point

tab[N+2]=deuxieme coordonnee du troisieme point

...

tab[9*N]=dixieme coordonnee du premier du point

tab[9*N+1]=dixieme coordonnee du deuxieme point

tab[9*N+2]=dixieme coordonnee du troisieme point

...

tab[9*N+9]=dixieme coordonnee du Nieme point

et moi j´ai besoin d´avoir ces donnees sous la forme

tab1={tab[0],tab[N],tab[2*N],tab[3*N],....,tab[9*N],tab[1],tab[1+N],...,tab[9*N+9]}

Donc des que je recupere un nouveau point j´ai a chaque fois besoin de reorganiser mon tableau. Realloc renvoie un pointeur vers le block de memoire realloue. Donc ce que je dois faire c´est utilise realloc pour ajouter mes valeurs dans mes donnees et apres les retrier mais je n´ai pas encore trouve comment organiser mes donnees comme montre au dessus.

Pourquoi ne pas utiliser plutôt un tableau du genre tab[N][10] ?
tab[0][0] est la premiere coordonnee du premier point
tab[0][1] est la deuxieme coordonnee du premier point
....
tab[1][0] est la premiere coordonnee du deuxième point
tab[1][1] est la deuxieme coordonnee du deuxième point
....

Pour l'allocation dynamique de ce tableau, tu déclares (si les coordonnées sont des doubles) :
Code:

1 2 3 4 5 6 7 8 // pour simplifier l'écriture du code on définit Coordonnees // comme le type "tableau de 10 double". typedef double Coordonnees [10]; Coordonnees * tab = malloc(N*sizeof *tab ); if(tab != NULL) { tab[0][0] = .... ....

Merci diogene, en effet tab[N][10] convient tout a fait avec ce que je veux faire et avec l´allocation dynamique c´est parfait.

Une autre question quelle est la difference entre :

int* tab=malloc(n * sizeof(int))
et
int* tab=(int*)malloc(n * sizeof(int))

je ne vois pas tres bien la difference.

Les 2 formes sont identiques et font la même chose.

Dans la 2eme forme, on aide le compilateur en lui disant de transformer le pointeur obtenu en int * pour supprimer le warning.

Je crois que la 1ere forme est la bonne pour un programme C, le 2eme est utilisée en C++ (son compilateur est un peu plus chatouilleux ?)

merci.