pointeur:utiliser une variable hors de sa portée

Le 24/01/2010 18:09, zydraf a écrit :

bonjour,

Je suis débutant en C et j'ai vu l'intérêt des pointeurs était,entre
autre,de pouvoir utiliser l'objet(variable,fonction,...) vers lequel
ils pointent hors de la portée de la fonction où il a été défini.
Peut-on m'écrire la juste syntaxe pour illustrer ceci?

Je ne sais pas ce que vous voulez-dire, mais ceci est illégal :

//-----------8<-----------------------------
#include <stdio.h>

char *f()
{
char string[] = "bonjour";

return string;
}

int main(void)
{
printf("%sn", f());
}
-----------8<-----------------------------

Par contre ceci est ok:

//-----------8<-----------------------------
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char *g()
{
char string[] = "bonjour";
int l = strlen(string);
char *s = malloc(l + 1);
memcpy(s, string, l + 1);

return s;
}

int main(void)
{
char *z = g();
printf("%sn", z);
free(z);

return 0;
}
//---------8<---------------------------------

--
Richard

Bonjour,

le 24/01/2010 à 18:09, zydraf a écrit dans le message
<e03f5921-a06a-4b4a-9c43-af17020ab9e2@n7g2000yqb.googlegroups.com> :

Je suis débutant en C et j'ai vu l'intérêt des pointeurs était,entre
autre,de pouvoir utiliser l'objet(variable,fonction,...) vers lequel
ils pointent hors de la portée de la fonction où il a été défini.
Peut-on m'écrire la juste syntaxe pour illustrer ceci?

#include <stdio.h>

void f1(int);
void f2(int *);

int
main(void)
{
int a = 1;

printf("a vaut : %dn", a);
f1(a);
printf("après f1(a), a vaut : %dn", a);
f2(&a);
printf("après f2(a), a vaut : %dn", a);

return 0;
}

void
f1(int n)
{
n++;
}

void
f2(int *n)
{
(*n)++;
}


--
Benoit Izac

Bonsoir,

Richard Delorme a écrit :

Je ne sais pas ce que vous voulez-dire, mais ceci est illégal :

Si les flics te choque en train de le faire, tu vas au trou illico presto...

Matt...

Le 24/01/2010 19:23, Matt... a écrit :

Bonsoir,

Richard Delorme a écrit :

Je ne sais pas ce que vous voulez-dire, mais ceci est illégal :

Si les flics te choque en train de le faire, tu vas au trou illico
presto...

Si seulement c'était vrai...

--
Richard

In article <e03f5921-a06a-4b4a-9c43-af17020ab9e2@n7g2000yqb.googlegroups.com>,
zydraf <vee-18i54@kaspop.com> wrote:

bonjour,

Je suis débutant en C et j'ai vu l'intérêt des pointeurs était,entre
autre,de pouvoir utiliser l'objet(variable,fonction,...) vers lequel
ils pointent hors de la portée de la fonction où il a été défini.

Oui, entre autres. Ca necessite de faire une distinction entre portee et
duree de vie, qui sont deux notions differentes.

Peut-on m'écrire la juste syntaxe pour illustrer ceci?

Par exemple, tu as parfaitement le droit de faire ceci:


void f(int *t)
{

/* faire des trucs avec t */

}


void g()
{
int k[50];
f(k);
}

ce qui te permet d'acceder aux valeurs stockees dans k depuis f, en toute
legalite, puisque l'espace memoire correspondant a k est valide pendant
toute la duree de l'appel de f.

Par contre, du code tel que:

int *h()
{
int z = 42;
return &z;
}

est illegal, puisque z finit d'exister a la fin de l'execution de h.

On peut passer outre en utilisant static:

int *h2()
{
static int z = 42;
return &z;
}

mais ca presente peu d'interet le plus souvent, parce qu'on a alors une
seule variable z quel que soit l'appel de h2 concerne...

Ca marche donc mieux avec de l'allocation dynamique:

int *h3()
{
int *p = malloc(sizeof(int));
/* ici verifier que p != 0 */
*p = 42;
return p;
}

ou alors, en faisant les choses "a l'envers: allouer l'espace/gerer la
memoire dans l'appelant, et prendre un pointeur en parametre:

void h3(int *p)
{
*p = 42;
}

qui s'appellera par exemple avec:

int i;
h3(&i);




Voila. Dans mon experience, le point-cle, c'est cette distinction: duree de
vie/portee. Si tu comprends ca, la suite, ben c'est juste trouver les
idiomes qui fonctionnent, et se mefier des autres...

zydraf a écrit :

bonjour,

Je suis débutant en C et j'ai vu l'intérêt des pointeurs était,entre
autre,de pouvoir utiliser l'objet(variable,fonction,...) vers lequel
ils pointent hors de la portée de la fonction où il a été défini.
Peut-on m'écrire la juste syntaxe pour illustrer ceci?

C'est pas tellement la portée "syntaxique" (le scope pour les
anglophiles) qui compte que la durée de vie de l'espace mémoire que
représente ta variable. Le pointeur contient l'adresse de cet espace
mémoire et tant que l'espace mémoire est valide, tu peux y accéder, et
cela de toute les façons que tu veux: utilisation de la variable
d'origine, ou utilisation d'un pointeur sur cette zone mémoire.

La vraie question a te poser est donc: quelle est la durée de vie de
l'espace mémoire pointé?

Une variable locale "auto" représente un espace mémoire qui n'est
valable que tant qu'on a pas quitté le bloc dans lequel elle a été
déclarée. Une variable globale (i.e. déclarée en dehors de tout bloc) ou
une locale "static" représente un espace mémoire qui dure le temps de
l'exécution de ton programme, donc tu peux y accéder quand tu veux.
Enfin une zone mémoire allouée dans le tas via malloc() (et ses amies),
est valable tant qu'on a pas appelé free() dessus.

Avec ceci bien en tête tu devrais te faire une idée assez exacte de la
durée de validité d'un pointeur dans l'une de ces zones mémoires.

sam.

On 24 jan, 18:09, zydraf <vee-18...@kaspop.com> wrote:

Je suis débutant en C et j'ai vu l'intérêt des pointeurs était,en tre
autre,de pouvoir utiliser l'objet(variable,fonction,...) vers lequel
ils pointent hors de la portée de la fonction où il a été défin i.
Peut-on m'écrire la juste syntaxe pour illustrer ceci?

merci.

#include <stdio.h>

int *f(void)
{
static int S_count = 0;

return &S_count;
}

int main (void)
{
int *pi = f();

(*pi)++;

printf ("*pi = %dn", *pi);
return 0;
}

mais ce genre de pratique est déconseillée (les variables statiques
modifiables sont une plaie ...)