Discussion :

[UrSuS AmErIcAnUs]

Bonjour,

J'ai fait un petit programme ayant le comportement suivant:

Boucle for

Fait des calculs

Enregistre les résultat dans une table à deux dimensions

Modifie les conditions initiales

Répète

Je voudrais savoir comment faire pour enregistrer les résultats successifs de la boucle, car évidemment, pour chaque boucle les données de la précédente table sont écrasées.

Il faudrait que j'arrive à créer une table hors de la boucle et y insérer les résultats à chaque "tour", mais je ne vois pas comment faire (pour le moment, je contourne le problème en l'enregistrant dans un fichier texte avec l'option a, mais j'aimerais que le tout reste sous la forme d'une table en mémoire et pas sous forme d'un fichier).

Merci de votre aide

[souviron34]

tu fais une table a trois dimensions :

tes 2 dimensions + 1 pour les resultats si tu veuix garder la matrice utilisee pour chacun, ou sinon tu sauvegardes le resultat et le moyen de le retrouver (numero de boucle, equation des coeffs, ou quoi que ce soit qui te permettent de revenir directement a la bonne matrice).

[UrSuS AmErIcAnUs]

Ok pour la table en trois dimensions (Souviron34), mais elle doit être créée en dehors de la boucle, sinon elle sera recréée à chaque "tour".

Mon problème vient du fait que dans ma boucle il y a une fonction à laquelle j'envoie une table et dont le résultat est une table ...


-------------------------------------------------------
Main

Creation Table 1

******ici il faudrait créer la Table synthèse*****

Boucle for

fonction X à laquelle j'envoie la Table 1

Calculs

Résultat dans une Table 2

**** ici il faudrait enregistrer les résultats de Table 2 dans la Table synthèse ****

Répéte

Fin Main
-------------------------------------------------------

La théorie ça va, c'est la pratique que je ne connais pas !

Merci d'avance

[souviron34]

ben est-ce que ta table synthese doit contenir TOUTES les tables resultat2 a chaque tour ?

Si oui pas trop de problemes..

ta matrice :

mat[n][m]

ta table mat_res[n][m][nb]

fonction X

resultat = mat_res[n][m][i]

[UrSuS AmErIcAnUs]

ben est-ce que ta table synthese doit contenir TOUTES les tables resultat2 a chaque tour ?

Si oui pas trop de problemes..

ta matrice :

mat[n][m]

ta table mat_res[n][m][nb]

fonction X

resultat = mat_res[n][m][i]

Ce que je vois comme problème c'est que pour remplir la table mat_res, il faut la mettre dans les paramètres de la fonction X, mais je ne peux pas étant donné que je lui fourni déjà la table mat et quatre autres variables.

Il me semble qu'on est limité à cinq paramètres pour les fonctions, n'est ce pas ?

Ce que tu appelles résultat est dans mon cas une table qui est créée dans fonction X ... peux-t-on faire sortir une table d'une fonction ? (je sais la passer à une autre fonction, mais je ne sais pas comment la retourner au main (par exemple).

Je suis pas sûr d'être clair...

[souviron34]

Il me semble qu'on est limité à cinq paramètres pour les fonctions, n'est ce pas ?

Pas du tout...

Ce que tu appelles résultat est dans mon cas une table qui est créée dans fonction X ... peux-t-on faire sortir une table d'une fonction ? (je sais la passer à une autre fonction, mais je ne sais pas comment la retourner au main (par exemple).

Je suis pas sûr d'être clair...

bien sur :

par exemple

Code :

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

1
2
3
4
5
6
 
double T[10][10] ;
double Res[10][10] ;
int error ;
 
error = fonction( T, Res);

ou

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
double T[10][10] ;
double **Res ;
 
Res = fonction( T);
 
....
 
double **Fonction( double mat[10][10] )
{
  double **Res ;
  int i ;
 
  res = malloc (...);
  ...
  for ( i = 0 ; i < n ; ....)
    res[i] = malloc (...);
 
  return res ;
}

[untipy]

Boucle for
Fait des calculs
Enregistre les résultats dans une table à deux dimensions
Modifie les conditions initiales
Répète

Avant de rentrer dans la boucle for, créer un tableau du type qui correspond aux données a sauvegarder.

Dans la boucle for, dans « Enregistre les résultats dans une table à deux dimensions »
*sauvegarde les résultats tab[index de la boucle][]= résultat calcul
*Ensuite vérifier si la capacité max du tableau est atteinte par rapport a l'index de la boucle : si oui realloc pour étendre le tableau et continuer a sauvegarder.

voilou ... une idée

bon courage

[souviron34]

j'ai juste édité mon post car le premier morceau de code était mal placé....

[UrSuS AmErIcAnUs]

Merci Souviron34.
Je me suis livré à un petit test pour essayer de l'appliquer à mon programme.
Ce premier code correspond à l'application de ta proposition.

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
#include <stdio.h>
#include <stdlib.h>
 
// variables
 
double T[10][10];
double **Res ;
int i,j;
 
 
int main()
{
// ************ Initialise T *************
 
    for (i=0; i<10; i++)
    {
        for (j=0; j<10; j++)
        {
            T[i][j] = 5;
 
        }
    }
 
 
//***************Fonction 1************************
 
 
    double **Fonction(double mat[10][10])
    {
    double **ResFonction ;
    //double **Res3;
    int i ;
 
 
        //
        ResFonction = malloc(3 * sizeof(double *));
        if(ResFonction == NULL)
            {
            fprintf(stderr, "out of memory\n");
            system("PAUSE");
            exit(0);
            }
        for(i = 0; i < 3; i++)
            {
            ResFonction[i] = malloc(3 * sizeof(double));
            if(ResFonction[i] == NULL)
                {
                fprintf(stderr, "out of memory\n");
                system("PAUSE");
                exit(0);
                }
            }
 
        ResFonction[1][2] = mat[1][2] + 10; // Un petit calcul
 
 
    return ResFonction ;
    }
 
// ****************** Fin Fonction 1 *******************    
 
    Res = Fonction(T);
 
    printf("resultat [1][2] : %lf",Res[1][2]);
 
 
return(0);
}

Ça ça fonctionne !! J'ai même mis le résultat dans un tableau d'une taille différente de celle d'entrée pour voir si ça fonctionnait aussi, et ça marche.
Bref parfait ... enfin presque...

En fait, dans mon programme, j'ai une fonction qui appelle une autre fonction.
Chacune d'elle fait un calcul à partir de la table d'entrée et l'enregistre dans une autre. J'aimerais ramener la table avec le résultat jusque dans le Main.

J'ai reproduit le cas avec le code suivant :

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
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
 
#include <stdio.h>
#include <stdlib.h>
 
// variables
 
double T[10][10];
double **Res ;
int i,j;
 
 
int main()
{
// ************ Initialise T *************
 
    for (i=0; i<10; i++)
    {
        for (j=0; j<10; j++)
        {
            T[i][j] = 10;
 
        }
    }
 
//***************Fonction 2************************
 
    double **Fonction2(double test[10][10])
    {
        double **ResFonction2;
        int i ;
 
        ResFonction2 = malloc(10 * sizeof(double *));
        if(ResFonction2 == NULL)
            {
            fprintf(stderr, "out of memory\n");
            system("PAUSE");
            exit(0);
            }
        for(i = 0; i < 10; i++)
            {
            ResFonction2[i] = malloc(10 * sizeof(double));
            if(ResFonction2[i] == NULL)
                {
                fprintf(stderr, "out of memory\n");
                system("PAUSE");
                exit(0);
                }
            }
        printf ("contenu de test[1][2] : %lf\n",test[1][2]);//Pour voir si le contenu est bien passé
 
        ResFonction2[1][2] = test[1][2] * 2; // Calcul 2
 
        return ResFonction2;
    }
 
 
//***************Fonction 1************************
 
 
    double **Fonction(double mat[10][10])
    {
    double **ResCalc_1 ;
    double **ResCalc_2;
    int i ;
 
 
        //
        ResCalc_1 = malloc(10 * sizeof(double *));
        if(ResCalc_1 == NULL)
            {
            fprintf(stderr, "out of memory\n");
            system("PAUSE");
            exit(0);
            }
        for(i = 0; i < 10; i++)
            {
            ResCalc_1[i] = malloc(10 * sizeof(double));
            if(ResCalc_1[i] == NULL)
                {
                fprintf(stderr, "out of memory\n");
                system("PAUSE");
                exit(0);
                }
            }
 
        ResCalc_1[1][2] = mat[1][2] + 10; // Un petit calcul
 
 
        ResCalc_2 = malloc(10 * sizeof(double *));
        if(ResCalc_2 == NULL)
            {
            fprintf(stderr, "out of memory\n");
            system("PAUSE");
            exit(0);
            }
        for(i = 0; i < 10; i++)
            {
            ResCalc_2[i] = malloc(10 * sizeof(double));
            if(ResCalc_2[i] == NULL)
                {
                fprintf(stderr, "out of memory\n");
                system("PAUSE");
                exit(0);
                }
            }
 
        ResCalc_2 = Fonction2(Res);
 
    return ResCalc_2 ;
    }
 
    Res = Fonction(T);
 
    printf("resultat final [1][2] : %lf",Res[1][2]);
 
 
return(0);
}

Et là il me dit "warning: passing arg 1 of `Fonction2' from incompatible pointer type".

Et donc, ça ne fonctionne pas !

Où est le problème ?

Merci d'avance

[UrSuS AmErIcAnUs]

En fait, le même message apparait quand la Table T est créée à l'aide de malloc.

Le code suivant est identique au premier code de mon message précédent, mais T est défini à l'aide de malloc et pas seulement sous la forme T[10][10].

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
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
 
#include <stdio.h>
#include <stdlib.h>
 
// variables
 
double **T;
double **Res ;
int i,j;
 
 
int main()
{
 
        T = malloc(10 * sizeof(double *));
        if(T == NULL)
            {
            fprintf(stderr, "out of memory\n");
            system("PAUSE");
            exit(0);
            }
        for(i = 0; i < 10; i++)
            {
            T[i] = malloc(10 * sizeof(double));
            if(T[i] == NULL)
                {
                fprintf(stderr, "out of memory\n");
                system("PAUSE");
                exit(0);
                }
            }
// ************ Initialise T *************
 
    for (i=0; i<10; i++)
    {
        for (j=0; j<10; j++)
        {
            T[i][j] = 5;
 
        }
    }
 
    printf("T[1][2]: %lf", T[1][2]);
 
//***************Fonction 1************************
 
 
    double **Fonction(double mat[10][10])
    {
    double **ResCalc_1 ;
    int i ;
 
 
 
        ResCalc_1 = malloc(10 * sizeof(double *));
        if(ResCalc_1 == NULL)
            {
            fprintf(stderr, "out of memory\n");
            system("PAUSE");
            exit(0);
            }
        for(i = 0; i < 10; i++)
            {
            ResCalc_1[i] = malloc(10 * sizeof(double));
            if(ResCalc_1[i] == NULL)
                {
                fprintf(stderr, "out of memory\n");
                system("PAUSE");
                exit(0);
                }
            }
 
        ResCalc_1[1][2] = mat[1][2] + 10; // Un petit calcul
 
 
    return ResCalc_1 ;
    }
 
    Res = Fonction(T);
 
    printf("resultat final [1][2] : %lf",Res[1][2]);
 
 
return(0);
}

Bref, c'est pas si simple que ça en a l'air ... en tout cas pour moi !!

Une idée pour solutionner le problème ?

[diogene]

1- En C, tu n'as pas la possibilité de définir une fonction à l'intérieur d'une fonction. Tu dois sortir les fonctions Fonction et Fonction2 de l'intérieur de la fonction main.

2-

Code :

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

1
2
3
4
5
double **T;
double **Res ;
double **Fonction(double mat[10][10])....
....
Res = Fonction(T);

Tu as un argument (T) du type double ** alors que la fonction attend un argument du type double (*)[10]

Code :

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

1
2
3
4
5
double T[10][10];
double **Res ;
double **Fonction2(double test[10][10])....
....
ResCalc_2 = Fonction2(Res);

Même remarque.

Ces paramètres devraient être du type double**, puisque tu construis tes tableaux par l'intermédiaire de tableaux de pointeurs

3- Supprime ces horrrrrribles variables globales

[UrSuS AmErIcAnUs]

Merci de ta réponse Diogene.

1- Je me suis mal expliqué encore une fois, en fait, j'appelle une première fonction (externe) depuis le main, et ensuite j'appelle une autre fonction (elle aussi externe) depuis la première fonction. Je ne défini pas une fonction dans une autre.

2- J'ai réussi à résoudre mon problème ... effectivement il suffisait de modifier les paramètres de la fonction pour accepter double**mat au lieu de double mat[10][10]. Merci d'avoir mis le doigt sur le problème !

3- Désolé, juste une histoire de copier coller mal placé. Les variables fautives allaient à l'origine sous int main () !!!!!