IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

Allocation dynamique d´un tableau


Sujet :

C

  1. #1
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2009
    Messages
    116
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2009
    Messages : 116
    Par défaut Allocation dynamique d´un tableau
    bonjour,
    j´ai un probleme avec un programme en c que j´essaie d´ecrire.
    Dans mon programme en C je recupere des donnees provenant d´une application ét je voudrais les stocker dans un tableau.J´ai donc creer une fonction mais le probleme c´est que le nombre des donnees que je recupere n´est jamais la meme. Quand je declare ma function, ca me dit qu´il faut que je mette une constante dans mon nombre d´elements du tableau. Mais je ne peux pas savoir le nombre d´elements avant de recevoir les donnees.
    J´ai regarde des infos sur l´allocation dynamique, j´ai vu qu´on pouvait creer ce tableau de taille variable dans le main mais comment faire quand on veut l´utiliser dans une fonction au niveau de la declaration de la fonction?
    Merci de prendre un peu de votre temps pour me repondre.

  2. #2
    Membre Expert
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Octobre 2008
    Messages
    1 515
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Octobre 2008
    Messages : 1 515
    Par défaut
    On fait exactement comme tu ferais avec un tableau automatique, on passe l'adresse du premier élément. Il faut par ailleurs un mécanisme permettant de savoir combien d'éléments le tableau contient.

  3. #3
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2009
    Messages
    116
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2009
    Messages : 116
    Par défaut
    le probleme c´est que je declare ma function avant le main et apres je l´explicite.

    void (tab);

    int main
    {... recuperation des donnees}

    void(tab){...}

    Il me faut connaitre la taille du tableau avant le main et moi je la connais pas.

  4. #4
    Membre Expert
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Octobre 2008
    Messages
    1 515
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Octobre 2008
    Messages : 1 515
    Par défaut
    Tu n'as pas besoin de connaitre la taille du tableau à l'avance. Tu passes simplement à ta fonction le pointeur que tu as initialisé par un appel à malloc(), et tu lui passes en plus la taille du tableau.

  5. #5
    Expert confirmé
    Avatar de diogene
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Juin 2005
    Messages
    5 761
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 5 761
    Par défaut
    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
    T* CreerTableau(size_t N) //crée un tableau de N éléments de type T
    {
       T* tab = malloc(N* sizeof *tab);
       // éventuellement, si tab != NULL, on peut initialiser le tableau
       return tab;
    }
    int main (void)
    {
      .... // je fais des choses
           // je connais maintenant la taille N du tableau
           // Alors je peux créer le tableau
      T* tab = CreerTableau(N); // avec T le type des éléments du tableau
      if(tab != NULL)
      {  
        LireTableau(tab,N,....);  // recuperation des donnees
      ....
    }
    Si la fonction CreerTableau est placée après le main, mettre avant le main son prototype :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    T* CreerTableau(size_t N); // ne pas oublier le ;

  6. #6
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2009
    Messages
    116
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2009
    Messages : 116
    Par défaut
    merci matafan et diogene pour vos reponses,
    c´est exactement ce que j´avais besoin et ca marche.
    Une fois que j´ai creer ce tableau j´arrive a afficher ce qu´il contient mais comment recuperer tous les elements du tableau dans mon int main.
    En faite j´ai besoin d´utiliser ce qu´il y a dans le tableau.

  7. #7
    Expert confirmé
    Avatar de diogene
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Juin 2005
    Messages
    5 761
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 5 761
    Par défaut
    En faite j´ai besoin d´utiliser ce qu´il y a dans le tableau.
    Oui, sinon, ça ne servirait à rien !

    Si tu es sur la trame que j'ai précédemment envoyé, rien de plus simple :
    exemple pour montrer comment accéder aux éléments du tableau :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    int main (void)
    {
      ....
      T* tab = CreerTableau(N); // avec T le type des éléments du tableau
      if(tab != NULL)
      {  
        LireTableau(tab,N,....);  // recuperation des donnees
        // multiplier par 2 les éléments positifs  du tableau :
        for(i=0;i<N;i++)
           if (tab[i] >0 ) tab[i] = 2*tab[i] ;
    }

  8. #8
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2009
    Messages
    116
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2009
    Messages : 116
    Par défaut
    Merci diogene ca marche tres bien, maintenant ce que j´aimerais faire c´est creer une fonction avec mon pointer comme parametre, attribuer des valeurs a tous elements pointes par le pointeur (ca j´arrive a le faire) et pouvoir utiliser ces valeurs dans le int main.
    J´arrive a remplir les elements pointes par mon pointeur et les afficher dans ma fonction mais je n´arrive pas a les reutiliser dans mon main.

    type fde unction utilisé:
    void (mxArray* in,double* ptr)
    je recupere les elements du mxArray et je les mets dans les elements pointes par mon pointer mais je ne peux pas les utiliser en dehors de ma fonction.
    Est ce que c´est possible au moins de faire ca?
    Parce que vu que je rempli mon pointer en me servant d´un autre pointer je sais pas trop.

    Je me demande si quand vous avez commence a programmer vous etiez comme moi (c est a dire un peu perdu) ou si vous etiez plus a laise.

  9. #9
    Expert confirmé
    Avatar de diogene
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Juin 2005
    Messages
    5 761
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 5 761
    Par défaut
    Parce que vu que je rempli mon pointer en me servant d´un autre pointer je sais pas trop.
    Les pointeurs sont des variables tout ce qu'il y a d'ordinaire. Leur particularité est que la valeur d'un pointeur est une adresse. Si deux pointeurs contiennent la même valeur, on peut accéder au contenu des adresses de la même façon en utilisant l'un ou l'autre.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    void MaFonction(mxArray* in,double* ptr)
    - Précise le type mxArray, si tu veux un exemple plus près de ton problème.
    - probablement, il faudrait passer aussi en paramètres le nombre d'éléments du tableau

    Sinon, on va avoir quelque chose du genre :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    void MaFonction(mxArray* in, double* ptr, size_t N)
    {
       size_t i;
       for(i=0; i<N;i++)
         ptr[i] = in[i]; // si l'assignation est possible
                         // ce qui dépend du type mxArray
    }
     
    // Dans main
     
     // tabd un tableau de N doubles
     // array un tableau de mxArray;
        MaFonction(array, tabd, N); // tabd contient les valeurs de array

    Je me demande si quand vous avez commence a programmer vous etiez comme moi (c est a dire un peu perdu) ou si vous etiez plus a laise
    Il y a si longtemps....

  10. #10
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2009
    Messages
    116
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2009
    Messages : 116
    Par défaut
    mxArray is Type for a MATLAB array.
    En faite je dois utiliser un algorithm fait avec matlab dans une application en c.

    voila ma fonction pour afficher:
    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
    void display(const mxArray* in, double* tab)
    {
          int i=0, j=0; /* loop index variables */
          int r=0, c=0; /* variables to store the row and column length of the matrix */
          int k=0;
     
        /* Get the size of the matrix */
          r = mxGetM(in); //number of rows
          c = mxGetN(in); //number of columns
     
     
        /* Get a pointer to the double data in mxArray */
          tab = mxGetPr(in); //Get real data elements in mxArray
     
     
        /* Loop through the data and display the same in matrix format */
          for( i = 0; i < r; i++ )
          {
                   for( j = 0; j < c; j++){
                  //printf("     %04.2f\t",tab[i*c+j]);
                  k=2*i+j;
                  tab[k] = tab[i*c+j];
     
                  printf(" number %d :  %lf \n",k,tab[k]);
                  }
          }
          printf("\n");
    };
    mxArray est rempli dans le main comme une matrice.
    en faite cest le resultat de l´algorithm que j utilise.
    Mais ce que je comprend pas trop c´est que quand je met un tableau avec une taille constante cette methode marche et pas avec un pointeur . Pourtant un tableau constant ca marche comme un pointeur si j´ai bien compris.

    A aussi une autre question, quellle est la difference entre double** et double*.
    double* est pointeur
    double** est un pointeur sur un pointeur??

  11. #11
    Expert confirmé
    Avatar de diogene
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Juin 2005
    Messages
    5 761
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 5 761
    Par défaut
    Dans le code que tu présentes, tab n'a pas à paraitre dans la liste des arguments puisque tu n'utilises pas la valeur passée en argument, et que tu l'écrases par mxGetPr() :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    double* display(const mxArray* in, double* tab)
    {
    ....
        /* Get a pointer to the double data in mxArray */
          tab = mxGetPr(in); //Get real data elements in mxArray
    Apparemment, ton programme modifie les éléments de in et ne modifie pas les données d'un autre tableau.
    ce qui n'est pas compatible avec ta déclaration const :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    double* display(const mxArray* in, double* tab)
    De plus, cette fonction annonce qu'elle renvoie un pointeur sur double et en fait ne renvoie rien.

    Si tu veux lire les éléments de in pour les mettre dans un tableau de double, on aura plutôt :


    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
    void display(const mxArray* in, double* tab)
    {
    .....
        /* Get a pointer to the double data in mxArray */
          double * deb = mxGetPr(in); //Get real data elements in mxArray
     
     
        /* Loop through the data and display the same in matrix format */
          for( i = 0; i < r; i++ )
          {
    ....
                  tab[k] = deb[i*c+j];
    ....
                  }
          }
          printf("\n");
    };
    double* est pointeur
    double** est un pointeur sur un pointeur??
    Oui

  12. #12
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2009
    Messages
    116
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2009
    Messages : 116
    Par défaut
    En faite j´ai essaye en creant :

    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
    double* tab1=NULL;
    tab1=malloc(n * sizeof(double));
     
    void display(const mxArray* in, double* tab)
    {
          int i=0, j=0; /* loop index variables */
          int r=0, c=0; /* variables to store the row and column length of the matrix */
          int k=0;
          double *data; /* variable to point to the double data stored within the mxArray */
     
          //double array [taille];
     
        /* Get the size of the matrix */
          r = mxGetM(in); //number of rows
          c = mxGetN(in); //number of columns
     
     
     
        /* Get a pointer to the double data in mxArray */
          data = mxGetPr(in); //Get real data elements in mxArray
     
     
        /* Loop through the data and display the same in matrix format */
          for( i = 0; i < r; i++ )
          {
          //printf("%d ",i);
               for( j = 0; j < c; j++){
                  //printf("     %04.2f\t",tab[i*c+j]);
                  k=3*i+j;
                  tab[k] = data[i*c+j];
     
                  printf(" number %d :  %lf \n",k,tab[k]);
                  }
          }
          printf("\n");
    };
    et ca marche impeccable.
    Par contre quand je fais la meme chose avec la fonction creertableau j´ai une erreur de compilation et je sais pas pourquoi.
    merci pour ton aide diogene.

  13. #13
    Expert confirmé
    Avatar de diogene
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Juin 2005
    Messages
    5 761
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 5 761
    Par défaut
    Par contre quand je fais la meme chose avec la fonction creertableau j´ai une erreur de compilation et je sais pas pourquoi.
    Poste le code.

  14. #14
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2009
    Messages
    116
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2009
    Messages : 116
    Par défaut
    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
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    #include<stdio.h>
     
    #include "libdavid.h" //include the library with the algorithm method
     
    void display(const mxArray* in, double* tab);
    double* CreerTableau(size_t N);
     
    int main()
    {
        mxArray *in1, *in2, *in3, *in4, *in5; /* Define input parameters 
        mxArray *out = NULL;/* and output parameters to be passed to the library functions */
        float x;
        double* tab1;
        double N=25; //number of points
     
     
     
        double data1[] = {1,2}; //we get the row vector with the lower parameter boundaries, size[Pdim,1]
        double data2[] = {10,20}; //we get the row vector with the upper parameter boundaries, size[Pdim,1]
        double data3[] = {2}; //Dimension of the parameter space, Pdim, size[1,1]
     
     
        tab1 = CreerTableau(N);
     
        if( !mclInitializeApplication(NULL,0) )
        {
            fprintf(stderr, "Could not initialize the application.\n");
        	return -1;
        }
     
     
     
        in1 = mxCreateDoubleMatrix(1,2,mxREAL);  //The desired number of rows, The desired number of columns,Specify either mxREAL or mxCOMPLEX.
        in2 = mxCreateDoubleMatrix(1,2,mxREAL);
        in3 = mxCreateDoubleMatrix(1,1,mxREAL);
     
        memcpy(mxGetPr(in1), data1, 2*sizeof(double)); //on copie ds la partie reelle de tous les elements de  in1 le double data1
        memcpy(mxGetPr(in2), data2, 2*sizeof(double)); //mxGetPr return The address of the first element of the real data
        memcpy(mxGetPr(in3), data3, 1*sizeof(double));
     
     
     
        /* Call the library intialization routine and make sure that the
         * library was initialized properly. */
     
        if (!libdavidInitialize()){
            fprintf(stderr,"Could not initialize the library.\n");
            return -2;
        }
        else
        {
            /* Call the library function */
     
            mlfInitdoe(1, &out, in3, in1, in2);
     
            printf("we have %d points to evaluate \n", mxGetNumberOfElements(out)/2);
     
        /* Display the return value of the library function */
            printf("the points to evaluate are :\n");
            display(out, tab1);
           for(i1=0; i1<N; i1++)
             {
             printf("the point %d to evaluate has for cordinate : %lf %lf \n",i1, tab1[i1], tab1[i1+N]);
             printf("\n");
             }
             printf("      \n ");
     
     
            mxDestroyArray(out); out=0;
     
            printf("End Program : ");
            scanf("%f", &x);
     
     
            libdavidTerminate();
     
            mxDestroyArray(in1); in1 = 0;
            mxDestroyArray(in2); in2 = 0;
            mxDestroyArray(in3); in3 = 0;
        }
     
        mclTerminateApplication();
     
        return 0;
    }
     
    void display(const mxArray* in, double* tab)
    {
          int i=0, j=0; /* loop index variables */
          int r=0, c=0; /* variables to store the row and column length of the matrix */
          int k=0;
          double *data; /* variable to point to the double data stored within the mxArray */
     
     
          //double array [taille];
     
        /* Get the size of the matrix */
          r = mxGetM(in); //number of rows
          c = mxGetN(in); //number of columns
     
     
     
        /* Get a pointer to the double data in mxArray */
          data = mxGetPr(in); //Get real data elements in mxArray
     
     
        /* Loop through the data and display the same in matrix format */
          for( i = 0; i < r; i++ )
          {
          printf("%d ",i);
               for( j = 0; j < c; j++){
                  //printf("     %04.2f\t",data[i*c+j]);
                  k=2*i+j;
                  tab[k] = data[i*c+j];
     
                  printf(" number %d :  %lf \n",k,tab[k]);
     
     
     
                  //add the way to keep each data to can reuse it and evaluate it
     
                  }
               printf("\n");
             }
     
        printf("\n");
     
     
    };
     
    double* CreerTableau(size_t N)
    {
       double* tab = malloc(N* sizeof *tab);
     
       return tab;
    }


    en faite il semble s´affiché un resultat mais ensuite un j ai une error

    debugger exception notification

  15. #15
    Expert confirmé
    Avatar de diogene
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Juin 2005
    Messages
    5 761
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 5 761
    Par défaut
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
     
    ......
        tab1 = CreerTableau(N);
    ......
          for(i1=0; i1<N; i1++)
             {
             printf("the point %d to evaluate has for cordinate : %lf %lf \n",i1, tab1[i1], tab1[i1+N]);
    ......
    tab1 est créé avec N éléments. Or, dans le printf, tu accèdes à tab1[i1+N], donc tu es en dehors du tableau.

    Dans ton code, tu fixes N à 25. Arbitrairement ?
    Probablement, tab1 à un nombre d'éléments qui dépend de la taille de la matrice. Tu ne devrais alors créer tab1 lorsque tu connaitras la valeur à donner à N

    Attention à ne pas confondre les balises [QUOTE] avec les balises [CODE] (bouton #

  16. #16
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2009
    Messages
    116
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2009
    Messages : 116
    Par défaut
    En faite je vais incorporer mon fichier en c dans une application faite en c++ et qui cree un exe .Cet exe cree une fenetre dans laquelle on peut ecrire des choses (pour moi ce sera par exemple le nombre de point et la dimension de l´espace).Ensuite je dois pouvoir recupere ces donnees dans mon fichier c et je definirais mon n comme le produit du nombre de points par la dimension.
    C est pour ca que je voulais un tableau avec une taille variable.

    25 en faite c est juste un exemple avec 13 points et en dimension 2.

    Enfin bon il me reste un mois et demi pour faire marcher tout ca mais a la base je suis pas programmeur donc desole si je pose des questions qui peuvent etre un peu sotes sur le langage c.
    A propos des pointeurs
    par exemple: double* ptr
    double **pti

    int i;
    ptr=&i;
    pti=&ptr;

    i adresse i valeur i
    ptr adresse ptr adresse i
    pti adresse pti adresse ptr

    je vois pas trop a quoi ca sert en faite le pointeur sur un pointeur??

  17. #17
    Expert confirmé
    Avatar de diogene
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Juin 2005
    Messages
    5 761
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 5 761
    Par défaut
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    double* ptr
    double **pti
    
    double  i;   
    ptr=&i;
    pti=&ptr;
     
    valeur de ptr  : adresse i
    valeur de pti  : adresse ptr
    
    *ptr  est l'objet i
    *pti  est l'objet ptr
    **pti  (== * ptr) est l'objet i
    je vois pas trop a quoi ca sert en faite le pointeur sur un pointeur??
    ça viendra quand tu en auras besoin.

  18. #18
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2009
    Messages
    116
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2009
    Messages : 116
    Par défaut
    merci diogene.
    En faite la methode mlfInitdoe me retourne un tableau de double mais moi je dois utiliser seulement des integer dans mon application .

    j´ai essaye en creant un tableau de int a la place de double.
    double* tab -> int*tab
    j´ai donc change mon parametre de la fonction display en consequence.

    et dans la fonction display void display(const mxArray* in, int* tab)
    j´ai ecri
    tab[k]= (int) data[j*c+i];
    pensant que ca allait directement me convertir les elements pointes par le pointeur data dans mon tableau ou je recupere les donnees en integer mais ca ne marche pas.( double *data)
    je ne comprend pas pourquoi?
    je dois gardre un double pour mon pointeur data vu que je vai pointé un tableau avec des doubles.

  19. #19
    Expert confirmé
    Avatar de diogene
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Juin 2005
    Messages
    5 761
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 5 761
    Par défaut
    j´ai ecri
    tab[k]= (int) data[j*c+i];
    pensant que ca allait directement me convertir les elements pointes par le pointeur data dans mon tableau ou je recupere les donnees en integer mais ca ne marche pas.
    Qu'est ce qui ne marche pas? qu'est ce que tu observes d'anormal ?
    Note que le cast (int) est inutile.

    je dois gardre un double pour mon pointeur data vu que je vai pointé un tableau avec des doubles.
    oui, data n'a pas à changer de type et reste un double *

  20. #20
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2009
    Messages
    116
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2009
    Messages : 116
    Par défaut
    A nan c est bon je viens de trouver mon error.
    J´ai pas change les %lf en %d.
    Alala pas facile de devenir un programmeur.

Discussions similaires

  1. allocation dynamique à un tableau
    Par amateurc dans le forum Débuter
    Réponses: 4
    Dernier message: 25/06/2008, 20h24
  2. Réponses: 11
    Dernier message: 11/06/2008, 18h05
  3. Bug sur une allocation dynamique de tableau
    Par Atharendil dans le forum C++
    Réponses: 6
    Dernier message: 15/12/2007, 23h42
  4. Réponses: 9
    Dernier message: 12/06/2007, 14h15
  5. Réponses: 6
    Dernier message: 26/11/2005, 19h55

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo