Passer un pointeur dans les parametres d'une [Résolu]

salut
c'est quel langage ? 4 chance sur 5 que ça doit être du C ou du C++
On va partir du principe que les pointeurs sont typés void.
tu ecrit donc ta foncton f de cette manière :

int f( void** p1, void** p2, [les autres arguments] )
   {
    /* tous les traitements */
    *p1 = la_valeur_de_P1 ;
    *p2 = la_valeur_de_P2 ;
    return le_compte_rendu ;
    }

/* Le main */
int main( int argc, char **argv )
    {
    void *p1, *p2 ;
    int ret ;
     ...
    ret = f( &p1, &p2, ..., ... ) ;
     ...
    return 0 ;
    }

Les pointeurs c'est comme les autres arguments, quand on veut les
modifier dans une fonction, on passe leurs adresses à la fonction.

merci pour votre reponse, mais j'ai essayé et ça marche toujours pas, voici la fonction et main

unsigned int sRWA(float *matrice, unsigned int D, unsigned int columns, unsigned int W, unsigned int U, unsigned int K,
LIGHTPATH *spra, unsigned int spraFILE_LENGTH, edge *TOPOLOGY, arc *GRAPH, unsigned int TOPOLOGYLENGTH,
unsigned int FLAG, unsigned int *sRWArejectedLDs, unsigned int *sRWArequiredWDMCH,unsigned int** routedLIGHTPATHdemands)
{
unsigned int i=0;
unsigned int j=0;
unsigned int p=0;
unsigned int q=0;
unsigned int u=0;
unsigned int l=0;
unsigned int m=0;
unsigned int v=0;
unsigned short int drapeau=0;
unsigned short int commonLINK=0;
unsigned int MAXrouteLENGTH=0;
unsigned int routedLIGHTPATHdemandsLENGTH=0;
unsigned int *rejectedLightpathDemands=0;
unsigned int rejectedLightpathDemandsLENGTH=0;

*sRWArequiredWDMCH=0;


for (v=0;v<spraFILE_LENGTH;v++)
{
for(q=0;q<W;q++)
*((spra+v)->cost+q) = 0;
}

for (p=0; p<spraFILE_LENGTH; p++)
{
if ((spra+p)->LENGTH > MAXrouteLENGTH)
{
MAXrouteLENGTH = (spra+p)->LENGTH;
}
}

rejectedLightpathDemands = (unsigned int *) calloc(D, sizeof(unsigned int));
if (rejectedLightpathDemands == NULL)
{
printf("impossible d'allouer de la memoire pour rejectedLightpathDemands");
exit(1);
}


routedLIGHTPATHdemands = (unsigned int **) calloc((3*D), sizeof(unsigned int));
if (routedLIGHTPATHdemands == NULL)
{
printf("impossible d'allouer de la memoire pour routedLIGHTPATHdemands");
exit(1);
}

for (i=0;i<D;i++)
{
p=0;
q=0;
j=0;
drapeau=0;
while ((p<spraFILE_LENGTH) && (drapeau == 0))
{
if (((unsigned int) *(matrice+i*columns+2) == (spra+p)->origin) && ((unsigned int) *(matrice+i*columns+3) == (spra+p)->destination))
{
q=0;
j=j+1;
while ((q<W) && (drapeau == 0))
{
if (*((spra+p)->cost+q) < FLAG)
{
drapeau = 1;
*((spra+p)->cost+q) = FLAG;

u=0;
while (u<spraFILE_LENGTH)
{
commonLINK = commonLINKpaths((spra+p)->route, (spra+p)->LENGTH, (spra+u)->route, (spra+u)->LENGTH);

if (commonLINK >= 1)
{
*((spra+u)->cost+q) = FLAG;
}
u=u+1;
}
// GRAPH = updateGRAPH((spra+p)->route, (spra+p)->LENGTH, (unsigned int) *(matrice+i*columns+0), 1, W, U, TOPOLOGYLENGTH, GRAPH, q);
*(routedLIGHTPATHdemands+routedLIGHTPATHdemandsLENGTH) = (unsigned int) *(matrice+i*columns+0);
routedLIGHTPATHdemandsLENGTH = routedLIGHTPATHdemandsLENGTH + 1;
*(routedLIGHTPATHdemands+routedLIGHTPATHdemandsLENGTH) = p;
routedLIGHTPATHdemandsLENGTH = routedLIGHTPATHdemandsLENGTH + 1;
*(routedLIGHTPATHdemands+routedLIGHTPATHdemandsLENGTH) = q;
routedLIGHTPATHdemandsLENGTH = routedLIGHTPATHdemandsLENGTH + 1;

*sRWArequiredWDMCH = *sRWArequiredWDMCH+(spra+p)->LENGTH-1;



}
q = q+1;
}
if ((drapeau == 0) && (j == (spra+p)->exist))
{

*(rejectedLightpathDemands+rejectedLightpathDemandsLENGTH) = (unsigned int) *(matrice+i*columns+0);
rejectedLightpathDemandsLENGTH = rejectedLightpathDemandsLENGTH + 1;

}



}
p=p+1;

}

}


free(rejectedLightpathDemands);
rejectedLightpathDemands = NULL;





return rejectedLightpathDemandsLENGTH;
}







/***************************************************************************
main.c - description


#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <rngs.h>
#include <rvgs.h>
#include <time.h>
#include <clprs.h>
#include <ctype.h>
#include <spra.h>
#include <utils.h>
#include <ts.h>
#include <routing.h>



#define columns 8
#define MAXunsignedINT 65535
#define nbreITERATIONS 1
#define epsilon 0.00001
#define U 1


int main(int argc, char *argv[])
{
unsigned int TOPOLOGYLENGTH=0;
unsigned int spraFILE_LENGTH=0;
LIGHTPATH *spra = NULL;
unsigned int N;
unsigned int D;
unsigned int W;
unsigned int K;
unsigned int mu;
unsigned int nu;
unsigned int L;
unsigned int k=0;
// unsigned int q=0;
unsigned int tailleNEIGHBERHOOD;
unsigned int tailleTABUList;
unsigned int rows;
unsigned int i=0;
unsigned int n=0;
unsigned int rlpdmin=10000;
unsigned int rwdm=10000;
unsigned int *routedLIGHTPATHdemands;



double sreroutingrejectedrequiredLightpathsratio=0;
//double rejectedLightpathDemandsLENGTH ;
// time_t t0, t1;
float *matrice;
float *MatriceOptimale;
edge *TOPOLOGY;
arc *GRAPH;
;
unsigned int numberofSLDs=0;
unsigned int numberofRLDs=0;
//unsigned int sRWArejectedLDss;
unsigned int sRWArejectedLDs;
unsigned int sRWArequiredWDMCH;
//unsigned int sRWAexecutionTime;
// unsigned int *routeNODES;



// routedLIGHTPATHdemands = (unsigned int *) calloc((3*D), sizeof(int));

if (argc != 13)
{
ERRORmessage(argv[0]);
}
N = atoi(argv[1]);
D = atoi(argv[2]);
W = atoi(argv[4]);
K = atoi(argv[5]);
mu = atoi(argv[6]);
nu = atoi(argv[7]);
L = atoi(argv[8]);
tailleNEIGHBERHOOD = atoi(argv[9]);
tailleTABUList = atoi(argv[10]);


TOPOLOGYLENGTH = TOPOFILE_LENGTH(argv[11]);
TOPOLOGY = LoadGRAPHTop(argv[11], W);
GRAPH = LoadGRAPH(argv[11], W, U);

spra = spraFILE(argv[12], &spraFILE_LENGTH, W);


rows = 2*D;
matrice = Loadtraffic(argv[3], rows, columns);


matrice = generate_action_matrix(matrice,D ,columns);
matrice = ordreSLDtrafficdemands(matrice,D, columns);



sreroutingrejectedrequiredLightpathsratio=0;
for (i=0; i<D; i++)
{

if (((unsigned int) *(matrice+i*columns+5) == 0) && (*(matrice+i*columns+1) == 1))
{
numberofSLDs = numberofSLDs + 1;
}
else if (((unsigned int) *(matrice+i*columns+5) == 0) && (*(matrice+i*columns+1) == 0))
{
numberofRLDs = numberofRLDs + 1;
}
sreroutingrejectedrequiredLightpathsratio = sreroutingrejectedrequiredLightpathsratio + (unsigned int) *(matrice+i*columns+4);
}



MatriceOptimale=(int*)malloc(D*columns*sizeof(int));



for(n=0;n<100;n++)
{
vectaleatoire(matrice,columns,D);


sRWArejectedLDs = sRWA(matrice, D, columns, W, U, K, spra, spraFILE_LENGTH, TOPOLOGY, GRAPH, TOPOLOGYLENGTH, MAXunsignedINT, &sRWArejectedLDs, &sRWArequiredWDMCH, &routedLIGHTPATHdemands);



if(sRWArejectedLDs<rlpdmin)
{
rlpdmin=sRWArejectedLDs;
rwdm=sRWArequiredWDMCH;
for(k=0;k<(D*columns);k++)

*(MatriceOptimale+k)=*(matrice+k);
}

if(sRWArejectedLDs==rlpdmin)
{
if(sRWArequiredWDMCH<rwdm)
{
rwdm=sRWArequiredWDMCH;
for(k=0;k<(D*columns);k++)
*(MatriceOptimale+k)=*(matrice+k);
}
}

}

sRWArejectedLDs = sRWA(MatriceOptimale, D, columns, W, U, K, spra, spraFILE_LENGTH, TOPOLOGY, GRAPH, TOPOLOGYLENGTH, MAXunsignedINT, &sRWArejectedLDs, &sRWArequiredWDMCH, &routedLIGHTPATHdemands);

printf( "%u\t%u\t", sRWArejectedLDs, sRWArequiredWDMCH);


printf("%u\t",*(routedLIGHTPATHdemands));









free(matrice);
matrice = NULL;
free(GRAPH);
GRAPH = NULL;
free(TOPOLOGY);
TOPOLOGY = NULL;
free(spra);
spra = NULL;

return EXIT_SUCCESS;
}

sql mais j'met pas le nez la dedans...

Je suis pas sur que tu ais bien vu le bout code que je donne.
Dans le corps de la fonction si tu veux modifier la valeur du pointeur
il faut utiliser la notation *p. Dans ton source tu continues à utiliser
p en modifiant en plus le type du calloc(), certainement pour éviter
un warning ou une erreur de compil...
Au vue de ce que tu codes, fait des exemples simples de manip des
pointeurs en langage C.