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. ..., I think Slackware sounds better than 'Microsoft,'
-- Patrick Volkerding - founder and maintainer of Slackware

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;
}