Discussion :

[SofC++]

Bonjour,
je souhaite stocker créer une fonction qui calcule la profondeur de N objets, N étant calculé précédemment dans mon programme, et stocke cette profondeur pour chaque objet dans une structure (qui comporte la profondeur et la longueur de l'objet).

Je pense donc faire un truc genre

définition :

Code :

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

1
2
3
4
5
6
7
8
9
10
/*Définition de la structure*/
struct layer
{
float depth;
float length;
}
 
/*définition du tableau*/
 
struct layer layertable [N];/*1er problème : N est calculé dans le main donc encore inconnu lors de la déclaration*/

Puis définition de la fonction :

Code :

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

1
2
3
4
5
6
7
8
layertable REINFORCEMENTDEPTH (float def.H,int N) /*la fonction doit me retourner un tableau de N structures layer, et prend comme arguments le nombre d'objet N et un parametre H defini avant*/
{
for (i=0;i<N,i++)
{if (i!=0)
tableau[i]=def.H*sqrt((i-1)/N);/*2eme problème : la je crée un tableau avec les profondeurs mais je veux que ces profondeurs soient affectées a chaque objet layer1,layer2 (dont le nombre est variable selon la valeur de N)*/
else if (i=0)
tableau [i]=0,5*layer2.depth;
}

Bon j'ai essayé d'être la plus claire possible mais je sais pas si c'est clair ....
de votre aide

[Kryptonaute]

Salut,
Pour assigner les valeurs à ton tableau de structures je vois pas pourquoi tu les assignes pas directement ;

Code :

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

1
2
3
4
5
6
7
8
9
10
 
layertable REINFORCEMENTDEPTH (float def.H,int N,struct layertable *mytable) /*la fonction doit me retourner un tableau de N structures layer, et prend comme arguments le nombre d'objet N et un parametre H defini avant*/
{
mytable = malloc(sizeof(N * struct layertable));
for (i=0;i<N,i++)
{if (i!=0)
mytable[i]->depth =def.H*sqrt((i-1)/N);/*2eme problème : la je crée un tableau avec les profondeurs mais je veux que ces profondeurs soient affectées a chaque objet layer1,layer2 (dont le nombre est variable selon la valeur de N)*/
else if (i=0)
mytable[i]->depth]=0,5*layer2.depth;
}

Dans ton main.c avant d'appeler ta fonction;
struct layertable *my_table ; //par ex

Enfin ça ce serait une solution avec un N fixe je crois..
Oriente toi vers les listes chaînées pour un tableau dynamique de quoi que ce soit.. si tu veux un exemple hésite pas.

[SofC++]

Aiiiiiie

Je pensais pouvoir m'en sortir sans pointeurs (je ne maitrise pas du tout)
Et en plus tu me parles de listes chainées et de tables dynamiques !!!!
Je connais pas tout ça moi ...
Je cherche une solution, meme si elle est lourde en calculs et moche , qui soit pas trop compliquée pour ma petite tete ...

[muad'dib]

struct layer layertable [N];/*1er problème : N est calculé dans le main donc encore inconnu lors de la déclaration*/

Pour cela il faut que tu fasses une allocation dynamique ! On ne peut donner la dimension des tableaux lors de leur déclaration qu'avec des valeurs fixes!

Code :

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

1
2
3
struct layer *layertable = malloc(sizeof(struct layer) * N)
// ... 
free(layertable);

Ne pas oublier le free ensuite !

[zooro]

Aiiiiiie

Je pensais pouvoir m'en sortir sans pointeurs (je ne maitrise pas du tout)
Et en plus tu me parles de listes chainées et de tables dynamiques !!!!
Je connais pas tout ça moi ...
Je cherche une solution, meme si elle est lourde en calculs et moche , qui soit pas trop compliquée pour ma petite tete ...

Dans ce cas, une solution serait de sur-dimensionner ton tableau (par exemple, tu décides que N vaudra au plus 1000, et donc tu fais un tableau de 1000).
Si tu fais comme ça, quand tu calcules la valeur de N, n'oublies pas de vérifier qu'elle ne dépasse pas 1000.

C'est quand même moins propre que l'allocation dynamique à mon avis.

[SofC++]

Question subsidiaires :

mytable[i]->depth =def.H*sqrt((i-1)/N);

cette ligne veut dire que je mets def.H*sqrt((i-1)/N) dans layer.depth de la ieme ligne de mon tableau ?

Comment l'ordi sait-il que je veux créer N structures de type layers avec chacune leur depth et leur length ?

Comment ensuite afficher la liste de mes layers avec leur depth et leur structure ?

J'ai pas l'impression de bien expliquer mon probleme alors si vous comprenez pas je peux tout reprendre du début .....
Parce que la je vois vraiment pas comment m'en sortir avec cette fonction ce tableau cette structure ....

[zooro]

Code :

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

mytable[i]->depth =def.H*sqrt((i-1)/N);

cette ligne veut dire que je mets def.H*sqrt((i-1)/N) dans layer.depth de la ieme ligne de mon tableau ?

Cette ligne veut dire que tu calcules def.H (donc l'élément H de la structure def) multiplié par la racine carrée de ((i-1) divisé par N), et que tu mets le résultat dans l'élément depth de la ligne i du tableau de structures mytable.

Pour afficher tout ton tableau, tu peux utiliser une boucle :

Code :

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

1
2
3
4
5
 
int i = 0;
for (i=0; i<N; i++) {
  printf("element %i: depth=%.2f; length=%.2f\n", i, mytable[i].depth, mytable[i].length);
}

[droggo]

Jio,

Aiiiiiie

Je pensais pouvoir m'en sortir sans pointeurs (je ne maitrise pas du tout)
Et en plus tu me parles de listes chainées et de tables dynamiques !!!!
Je connais pas tout ça moi ...
Je cherche une solution, meme si elle est lourde en calculs et moche , qui soit pas trop compliquée pour ma petite tete ...

Dans ce cas, il faut probablement commencer par apprendre cela, sinon tu seras très rapidement bloquée dans tes programmes.

Le côté "meme si elle est lourde en calculs et moche" n'est pas une solution viable.

[SofC++]

Ok donc si je récapitule,

je commence par définir une structure

Code :

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

1
2
3
4
5
struct layer
{
float depth;
float length;
}

puis mon tableau (que je surdimensionne je veux pas me prendre la tete avec les pointeurs et les malloc)

Code :

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

struct layer layertable [1000];

puis l'expression de ma fonction est

Code :

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

1
2
3
4
5
6
7
8
layertable REINFORCEMENTDEPTH (float def.H,int N)
{
for (i=0;i<N,i++)
{if (i!=0)
layertable[i]->depth =def.H*sqrt((i-1)/N;
else if (i=0)
layertable[i]->depth]=0,5*layer2.depth;
}

Et si je veux imprimer pour la layer 1 par exemple je mets

Code :

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

printf("layer %i: depth=%.2f; length=%.2f\n", 0, mytable[0].depth, mytable[0];

Et puis sinon droggo je ne veux pas passer trop de temps a apprendre le code (je fais ce programme dans le cadre d'un stage (qui finit dans un mois et demi) dont le but principal n'est pas de programmer, loin de la). Je sais que mon approche ne plaira pas a tout le monde et je comprendrai que tu ne veuille plus m'aider mais je peux pas apprendre tout la théorie (sinon mon stage sera fini avant que j'ai commencé a programmer...). Je sais que les pointeurs sont une notions tres importante en C (a l'époque je savais m'en servir) mais je pense pouvoir m'en passer pour ce programme assez simple. J'ai peut etre tort... mais c'est comme ça, je suis tetue !

[zooro]

Voici un exemple de code qui compile sans erreur :

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
43
44
45
46
47
48
49
50
51
52
53
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
 
/* Taille du tableau */
#define MAX_LAYER 100
 
/* Définition de la structure */
typedef struct
{
    float depth;
    float length;
} layer;
 
/* Fonction utilitaire d'affichage d'un élément du tableau */
void print_layer(layer *l) {
    if (l!=NULL) {
        printf("[depth=%.2f; length=%.2f]\n", l->depth, l->length);
    }
}
 
void REINFORCEMENTDEPTH(float defH, int n, layer* tableau) /*la fonction doit me retourner un tableau de N structures layer, et prend comme arguments le nombre d'objet N et un parametre H defini avant*/
{
    int i = 0;
 
    for (i=0; i<n; i++)
    {
        if (i == 0)
            tableau[i].depth = 0.5;
        else /* (i!=0) */
            tableau[i].depth = defH * sqrt(100 * (i-1) / n);
    }
}
 
int main(void)
{
    int i = 0;
    int n = 10; /* n doit être inférieur à MAX_LAYER */
    layer layertable[MAX_LAYER];
 
    /* initialisation du tableau */
    memset(layertable, '\0', sizeof(layertable));
 
    REINFORCEMENTDEPTH(0.5, n, layertable);
 
    for (i=0; i<n; i++) {
        printf("--> element %d: ", i);
        print_layer(&layertable[i]);
    }
 
    return EXIT_SUCCESS;
}

La fonction REINFORCEMENTDEPTH est bizarre, je n'arrive pas comprendre ta formule. Pour la demo, j'ai multiplié par 100 la valeur de i, histoire d'avoir autre chose que des 0 dans le tableau final.

Il faut que tu écrives clairement l'algo (ou la formule), et ensuite que tu la transformes en code C. Sinon, tu n'y arriveras pas.

[SofC++]

Merci pour ton code,
en fait je veux que

pour i de 0 a N

zi (profondeur de l'élement i) = H*racine((i-1)/N);
sauf pour le premier élément ou z1 (profondeur du premier element)=0,5*z2; (profondeur du deuxıeme element)

je veux que la profondeur zi soit affectée a une structure élémenti qui comportera et la longueur, et la profondeur de l'élément i.
Je veux pouvoir sortir au choix la profondeur ou la longueur d'un élément que je choisis.

Merci ^^

[zooro]

pour i de 0 a N

zi (profondeur de l'élement i) = H*racine((i-1)/N);
sauf pour le premier élément ou z1 (profondeur du premier element)=0,5*z2; (profondeur du deuxıeme element)

Voilà :

Code :

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

1
2
3
4
5
for(i=1; i<N; i++) 
{
  tableau[i].depth = H * sqrt((i-1) / N);
}
tableau[0].depth = 0.5 * tableau[1].depth;

Il faut juste s'assurer que N est plus grand que 2.

je veux que la profondeur zi soit affectée a une structure élémenti qui comportera et la longueur, et la profondeur de l'élément i.
Je veux pouvoir sortir au choix la profondeur ou la longueur d'un élément que je choisis.

Mais tu ne calcules jamais la longueur d'un élément, avec cette formule. Elle restera donc à 0...

[SofC++]

En fait je comptais faire une autre fonction pour calculer la longueur ... plus tard ... Pour l'instant elle peut donc rester a 0 je m'en fiche.
Merci de ton aide

[SofC++]

Le porbleme c'est que la fonction que tu m'as donnée ne calcule pas les bonne valeurs .... comment ce fait-ce ? J'ai fait un tableau excel pour comparer et normalement on devrait trouver

z1 1 0
z2 2 1,885618083
z3 3 2,666666667
z4 4 3,265986324
z5 5 3,771236166
z6 6 4,216370214
z7 7 4,618802154
z8 8 4,988876516
z9 9 5,333333333
z10 10 5,656854249
z11 11 5,96284794
z12 12 6,25388768
z13 13 6,531972647
z14 14 6,798692685
z15 15 7,05533683
z16 16 7,302967433
z17 17 7,542472333
z18 18 7,774602526


(en prenant la meme expression pour toutes les couches y compris la premiere : zi=H*racine ((i-1)/N))
Merci de votre aide...

[SofC++]

Bon alors maintenant c'est tout bon j'ai les bonnes profondeurs c'était un porbleme de déclaration du type de N.

Mainteant je voudrais savoir comment appeler la profondeur (depth) d'une couche (layer) i pour faire des actions dessus.

En fait je veux que si la profondeur de la couche i n'est pas un multiple d'un nombre donné (genre 0,2) le programme remplace la profondeur théorique par le multiple de 0,2 inférieur le plus proche. Je pense me servir du reste de la division par 0,2 ....