Passer un pointeur dans les parametres d'une

Résolu/Fermé
dali81 - 24 avril 2005 à 18:57
crabs
Messages postés
908
Date d'inscription
lundi 18 avril 2005
Statut
Membre
Dernière intervention
3 août 2008
- 25 avril 2005 à 17:36
salut,

j'ai ecrit une fonction f qui retourne un pointeur p1

elle calcule aussi un autre pointeur p2

comment je pourrais avoir p2 dans main??

4 réponses

crabs
Messages postés
908
Date d'inscription
lundi 18 avril 2005
Statut
Membre
Dernière intervention
3 août 2008
506
24 avril 2005 à 21:10
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.
0
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;
}
0
donc la le pointeur calculé dans la fonction sRWA et dont j'ai besoin dans main c'est
*routedLIGHTPATHdemans
0
kij_82
Messages postés
4088
Date d'inscription
jeudi 7 avril 2005
Statut
Contributeur
Dernière intervention
30 septembre 2013
856
25 avril 2005 à 14:30
sql mais j'met pas le nez la dedans...
0
crabs
Messages postés
908
Date d'inscription
lundi 18 avril 2005
Statut
Membre
Dernière intervention
3 août 2008
506
25 avril 2005 à 17:36
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.
0