Je voudrais savoir comment utiliser un pointeur alloué dans une fonction main au sein d´une fonction quelquoncque en vue de réallouer de la mémoire avec realloc ou de la libérer avec free.
Exemple : ( j´utilise des parenthèses pour les guillemet car je poste sur un mac )

void allocation( int * ptr )
(
ptr = malloc( sizeof( int ) ) ;
)

int main( void )
(
int * pointeur;
allocation( pointeur ) ;
printf( " %d", *pointeur ) ;
return 0;
)

Dans ce cas, l´allocation ne fonctionne pas et il m´est impossible d´utiliser le pointeur.
En effet, si j´utilise sizeof sur ptr, il me retourne la taille de ptr et non celle de pointeur.

Comment faire pour allouer manipuler de la mémoire en C en passant par des fonctions ( en sortant de la fonction ou le pointeur a été déclaré )

Deja, le passage par parametre de ta fonction est fausse. Tu modifie la variable dans ta fonction, donc il faut lui donner l´adresse de cette variable.
Si jamais tu travaillais avec des int simples, tu devrais faire :
fct(int* a)

• a=1;

et ds ton main
fct(&)

ca je suppose que tu sais faire. Ben la c´est pareil, la fct malloc modifie la valeur de ptr...
Donc tu dois passer l´adresse d´un pointeur sur un entier ( int**) a ta fonction.

Ensuite, je comprends pas comment tu peux compiler, car il faut faire un " cast" du malloc :
( int*)malloc(sizeof(int))

donc pour resume change ton code en

allocation(int** ptr)
{

• ptr=(int*)malloc(sizeof(int))

}
et ds ton main
allocation(&)

sinon, plus simplement, ta fonction allocation tu la fais comme ca :
int* allocation()
{
return ( int*)malloc(sizeof(int))
}

Pour finir, avec ton pb de sizeof, si tu fais sizeof(pointeur) tu obtiendras la taille en memoire d´un pointeur, et si tu fais sizeof(*pointeur), la taille d´un element pointe par ce pointeur. En aucun cas tu ne pourras connaitre la taille de la zone memoire allouee, il faudra stocker ca d´une maniere ou d´une autre ( je sais pas si c´etait ton pb avec le sizeof, mais en general ca pose bcp de pb au debut dc j´en ai parle)

Merci, mais ma question porte sur l´allocation et la gestion de la mémoire dans différentes fonctions.
Dans le programme suivant, tout va bien :

int main()
(
short *pointeur;
pointeur = malloc( sizeof( short ) * 10 ) ;

// etc . ..

free( pointeur ) ;

return 0;
)

Leprogramme est monolythique et ne pose pas de problèmes.
Mais ici :

void allocation( short * ptr )
(
ptr = malloc( sizeof( short ) * 10 ) ;
)

void clean( short * ptr )
(
free( ptr ) ;
)

int main( void )
(
short * pointeur;

allocation( pointeur ) ;
clean( pointeur ) ;

return 0;
)

Sur ce programme la, pointeur n´est pas initialisé correctement ( je vois a peu près pourquoi ) .
Comment faire pour faire ce que je veux ( c´est à dire gérer de la mémoire dynamiquement dans plusieures fonctions, et ce sans passer par des variables globales )

ben je te l´ai dit

void allocation(short** ptr)
{

• ptr=(short*)malloc(sizeof(short)*10));

}

et ds ton main tu fais

short * pointeur
allocation(&)

relit l´explication sur la raison de faire comme ca.
Et sinon, pense a mettre avant ton malloc le type
( short*)malloc(..)
( int*)malloc(..)
etc