Passer un pointeur dans les parametres d'une

Résolu

dali81 -
crabs Messages postés 908 Date d'inscription Statut Membre Dernière intervention - 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??

Afficher la suite

A voir également:

Passer un pointeur dans les parametres d'une
Parametres de mon ordinateur - Guide
Paramètres dns - Guide
Passer de qwerty a azerty - Guide
Pointeur souris - Guide
Passer a windows 10 - Accueil - Mise à jour

4 réponses

Réponse 1 / 4

crabs Messages postés 908 Date d'inscription Statut Membre Dernière intervention 507

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.

Réponse 2 / 4

dali81

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

dali81

donc la le pointeur calculé dans la fonction sRWA et dont j'ai besoin dans main c'est
*routedLIGHTPATHdemans

Réponse 3 / 4

kij_82 Messages postés 4089 Date d'inscription Statut Contributeur Dernière intervention 857

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

Réponse 4 / 4

crabs Messages postés 908 Date d'inscription Statut Membre Dernière intervention 507

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.

Discussions similaires

Problème digital wellbeing android

Votre réponse

Discussions similaires