Les fonctions / pointeurs

Version imprimable

06/12/2008, 15h13
Delnir

Les fonctions / pointeurs

Bonjour,
j'ai une question concernant les fonctions/pointeurs:
dans une fonction je fait int x;
j'alloue un espace de la mémoire, disons en imageant que l'adresse est la case 16 ( pour simplifié)
x=10; la case 16 contient l'entier 10

maintenant dans une autre fonction je passe en paramètre int x
et je dit dedans que x=12
la l'entier x sera donc alloué localement dans un espace de la mémoire différente disons que l'adresse est la case 96
donc cela induit que toutes variables déclarer dans une fonction est définit localement (occupe un espace mémoire spécifique)
C'est pour cela qu'on passe en paramètre l'adresse, pour pouvoir directement travaillé sur l'espace de la mémoire où est stocker la variable.(je parle dans le cas où on a besoin de la modifié)
Est ce bien comme cela que sa fonctionne?

Merci d'avance pour votre aide.

Mais voilà une contradiction à ce que j'ai dit avant:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
#include<stdio.h>
void saisie(char *mot){
  printf("saisir un mot:");
  scanf("%s",mot);
}
 
void affiche(char *mot){
  printf("%s\n",mot);
}
int size(char *mot){
  int i=0,cpt=0;
  while(mot[i]!='\0'){
    cpt++;
    i++;
  }
  return cpt;
}
 
void transforme(char *mot){
  int i;
  for(i=0;i<size(mot);i++){
    if(mot[i]==(tolower(mot[i])))
      mot[i]=toupper(mot[i]);
    else
      mot[i]=tolower(mot[i]);
  }
}
 
int main(void){
  char mot[50];
  saisie(mot);
  affiche(mot);
  transforme(mot);
  printf("size=%d\n",size(mot));
  affiche(mot);
  return 0;
}

Pour la fonction transforme et saisie je modifie "mot" sans passer l'adresse et je l'est bien modifié dans le main...
Je ne comprend plus du tout :?
Les chaînes de caractères ne sont pas définit localement?

06/12/2008, 16h59
diogene

Citation:

j'ai une question concernant les fonctions/pointeurs:
....
Est ce bien comme cela que sa fonctionne?

Oui

Citation:

Pour la fonction transforme et saisie je modifie "mot" sans passer l'adresse et je l'est bien modifié dans le main...

mot est un tableau. L'identificateur d'un tableau (hors le cas des opérateurs sizeof et & (adresse de)) est interprété comme "adresse du premier élément du tableau". Donc tu passes bien l'adresse !

Ok merci , j'essaye de faire apparaitre avec les équivalences, mais je n'arrive pas pour size(mot) (pour le définir localement) :? (la paramètre aussi qui devrai être un pointeur de pointeur)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 void transforme(char *(&(*mot))){ int i; for(i=0;i<size(mot);i++){ if(*(mot+i)==(tolower(*(mot+i)))) *(mot+i)=toupper(*(mot+i)); else *(mot+i)=tolower(*(mot+i)); } } int main(void){ char mot[50]; transforme(&(mot[0])); return 0; }
mot=mot+0=&(mot[0])
*mot=mot [0]
*(mot+i)=mot[i]

Citation:

Envoyé par Delnir

Ok merci , j'essaye de faire apparaitre avec les équivalences, mais je n'arrive pas pour size(mot) (pour le définir localement) :? (la paramètre aussi qui devrai être un pointeur de pointeur)

Que de complications...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
#include <ctype.h>
#include <stdio.h>
 
void transforme (char *mot)
{
   int i;
   for (i = 0; mot[i] != 0; i++)
   {
      if (islower (mot[i]))
      {
         mot[i] = toupper (mot[i]);
      }
      else
      {
         mot[i] = tolower (mot[i]);
      }
   }
}
 
int main (void)
{
   char mot[50] = "Hello world !";
 
   printf ("'%s'\n", mot);
   transforme (mot);
   printf ("'%s'\n", mot);
 
   return 0;
}

Code:

1
2
3
4
5
6
 
'Hello world !'
'hELLO WORLD !'
 
Process returned 0 (0x0)   execution time : 0.061 s
Press any key to continue.

06/12/2008, 17h57
diogene
Citation:

Ok merci , j'essaye de faire apparaitre avec les équivalences, mais je n'arrive pas pour size(mot) (pour le définir localement) (la paramètre aussi qui devrai être un pointeur de pointeur)

Pourquoi un pointeur de pointeur ? Je ne comprend pas ton problème

Code:

void transforme(char *(&(*mot))){

ça ne compile pas ce truc !
Code:

1 2 3 void transforme(char *mot){ int i; for(i=0;i<size(mot);i++){
Pourquoi appeler la fonction à chaque boucle ? Ca coûte cher en temps de reparcourir la chaîne à chaque fois et c'est inutile.

Ici cpt ne sert à rien :
Code:

1 2 3 4 5 6 7 int size(char *mot){ int i=0; while(mot[i]!='\0'){ i++; } return i; }
06/12/2008, 18h09
Delnir

Pour les complications, c'est mon tp qui me demande sa :)
Mais en faite mon erreur c'est de mélanger les pointeurs et tableau ce qui est complètement différent.
Sinon si j'ai bien comprit les variables locales par rapport à mon 1er poste sa n'existe pas avec les tableaux? (car on va toujours passer l'adresse)

Citation:

Envoyé par Emmanuel Delahaye

Que de complications...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
#include <ctype.h>
#include <stdio.h>
 
void transforme (char *mot)
{
   int i;
   for (i = 0; mot[i] != 0; i++)
   {
      if (islower (mot[i]))
      {
         mot[i] = toupper (mot[i]);
      }
      else
      {
         mot[i] = tolower (mot[i]);
      }
   }
}
 
int main (void)
{
   char mot[50] = "Hello world !";
 
   printf ("'%s'\n", mot);
   transforme (mot);
   printf ("'%s'\n", mot);
 
   return 0;
}

Code:

1
2
3
4
5
6
 
'Hello world !'
'hELLO WORLD !'
 
Process returned 0 (0x0)   execution time : 0.061 s
Press any key to continue.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
 
static void transforme (char * const mot)
{
   size_t i;
   for (i = 0; mot[i] != 0; i++)
   {
      if (islower ((unsigned char) mot[i]))
      {
         mot[i] = toupper ((unsigned char) mot[i]);
      }
      else
      {
         mot[i] = tolower ((unsigned char) mot[i]);
      }
   }
}
 
int main (void)
{
   char mot[] = "Hello world !";
 
   puts (mot);
   transforme (mot);
   puts (mot);
 
   return 0;
}

Autre exo de mon tp:
écrire une fonction prenant un argument n et qui renvoie un pointeur vers l'adresse d'un tableau dynamique de n entiers

écrire une fonction permettant d'initialiser le tableau précédent en affectant à chacune de ses cases la valeur de son indice
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 #include<stdio.h> #include<stdlib.h> int *init(int *tab,int n){ int i; for(i=0;i<n;i++){ tab=malloc(sizeof(int)+1); tab[i]=i; } return tab; } int *pointe(int n) { int *tab; tab=init(tab,n); return tab; } int main(void){ int n=4; int *tab; tab=pointe(n); printf("%d",tab[1]); return 0; }
Toute les cases de mon tableau sont à 0 je ne comprend pas l'erreur

ha c'est bon j'ai trouvé c'est

Code:

1
2
3
4
5
6
7
8
9
 
int *init(int *tab,int n){
  int i;
  tab=malloc(sizeof(int *)*n);
  for(i=0;i<n;i++){
    tab[i]=i;
  }
  return tab;
}

Code:

1
2
3
4
5
6
7
8
9
 
int *init(int *tab,int n){
  int i;
  for(i=0;i<n;i++){
    tab=malloc(sizeof(int *)+i); 
    tab[i]=i;
  }
  return tab;
}

Citation:

Sinon si j'ai bien comprit les variables locales par rapport à mon 1er poste sa n'existe pas avec les tableaux? (car on va toujours passer l'adresse)

Si, on peut avoir des tableaux en variables locales (si ils sont définis à l'intérieur d'une fonction). La caractéristique des variables locales (automatiques) est qu'elles sont automatiquement créées et automatiquement détruites en sortie de la fonction.
Par contre, il est exact que lorsqu'on passe un tableau en argument à une fonction, c'est en fait son adresse qui est transmise. Ceci fait que la fonction peut modifier le tableau; toutefois, si la fonction ne doit pas modifier le tableau, on peut lui attribuer la caractéristique de pointeur sur des éléments constants :
Code:

1 2 void f1( int * tab) // f1 peut modifier les éléments du tableau d'adresse tab void f2( const int * tab // f2 ne le peut pas
Code:

1 2 3 4 5 int *pointe(int n) { int *tab; tab=init(tab,n); return tab; }
Un compilateur bien réglé émettra un avertissement : tab est utilisé sans avoir été initialisé. Il n'y a aucune raison de passer tab en argument (non initialisé par ailleurs) puisque init doit créer le tableau :
Code:

1 2 3 int *pointe(int n) { return init(n); }
Alors init devient :
Code:

1 2 3 4 5 6 int *init(int n){ int i; tab=malloc(n*sizeof(int)); // demander de la mémoire pour placer UN tableau de n int for(i=0;i<n;i++) tab[i]=i; return tab; // et renvoyer l'adresse du tableau créé }
Dans cette fonction, tab et i sont des variables locales en allocation automatique (elles n'existent plus lorsque la fonction est terminée) , mais la zone mémoire allouée survit à la fin de la fonction : elle est en allocation dynamique et sera détruite que sur la demande du programmeur ( fonction free)

Citation:

Envoyé par nicolas.sitbon

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
 
static void transforme (char * const mot)
{
   size_t i;
   for (i = 0; mot[i] != 0; i++)
   {
      if (islower ((unsigned char) mot[i]))
      {
         mot[i] = toupper ((unsigned char) mot[i]);
      }
      else
      {
         mot[i] = tolower ((unsigned char) mot[i]);
      }
   }
}
 
int main (void)
{
   char mot[] = "Hello world !";
 
   puts (mot);
   transforme (mot);
   puts (mot);
 
   return 0;
}

Oui, c'est mieux.

Ok merci.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 #include<stdio.h> #include<stdlib.h> int *init(int n){ int i; int *tab=NULL; for(i=0;i<n;i++){ tab=malloc(sizeof(int *)+i); tab[i]=i; } return tab; } int *pointe(int n) { return init(n); } int main(void){ int n=4; int *tab=NULL; tab=pointe(n); printf("%d\n",tab[3]); return 0; }
Je doit toujours initialiser un tableau à NULL, mais quand par exemple je déclare sans allocation dynamique tab[50] je devrai parcourir chaque case est la mettre à NULL?

07/12/2008, 13h36
Emmanuel Delahaye

Citation:

Envoyé par Delnir

Je doit toujours initialiser un tableau à NULL,

Pourquoi ? L'important est de donner tout de suite une valeur valide. Par exemple :

Code:

int *tab = pointe (n);

Citation:

mais quand par exemple je déclare sans allocation dynamique tab[50] je devrai parcourir chaque case est la mettre à NULL?

Si c'est un tableau de pointeur, pourquoi pas, mais on peut aussi mettre la bonne valeur directement. Disons, que si on ne sait pas quoi mettre, on met NULL, parce que c'est une valeur valide qui signifie clairement 'pointeur invalide' et que c'est testable.

Rappel : NULL ne concerne que les pointeurs.

J'ai comprit pour le cas du tableau mais la je ne saisie pas du tout pour les listes chaînées, la fonction pop et popR(même mais récursif), je ne passe pas l'adresse dans le main donc logiquement je ne devrai pas modifié ma liste chaînée?
Pourtant quand je compile la liste est modifié 8O
Pourquoi?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#include<stdlib.h>
#include<stdio.h>
typedef struct _file{
  int Elt;
  struct _file *suivant;
}file;
 
void init(file **p){
  *p=NULL;
}
 
void push(file **p,int val){
  file *p2=malloc(sizeof(file));
  p2->Elt=val;
  p2->suivant=*p;
  *p=p2;
}
 
void popR(file *p){
  if(p==NULL)
    return;
  if(p->suivant==NULL){
    free(p);
    return;
  }
  if((p)->suivant->suivant==NULL){
    free(p->suivant);
    p->suivant=NULL;
    return;
  }
  popR(p->suivant);
}
 
 
void pop(file *p){
  if(p==NULL)
    return;
  if((p)->suivant==NULL){
    free(p);
    return;
  }
  file *p2=p;
  file *p3=(p)->suivant;
  while(p3->suivant!=NULL){
    p2=p2->suivant;
    p3=p3->suivant;
  }
  p2->suivant=p3->suivant;
  free(p3); 
} 
 
void affiche(file *p){
  while(p!=NULL){
    printf("%d\n",p->Elt);
    p=p->suivant;
  }
}
int main(void){
  file *p;
  init(&p);
  push(&p,5);
  push(&p,3);
  affiche(p);
  pop(p);
  printf("REMOVE\n");
  affiche(p);
  return 0;
}

Tu passes l'adresse du premier chainon, donc le chaînon et tous les suivants peuvent être modifiés.
La seule chose que tu ne peux pas modifier, c'est le pointeur vers le premier chaînon.

Une meilleure nomenclature devrait t'aider à comprendre:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#include<stdlib.h>
#include<stdio.h>
 
typedef struct chainon {
  int Elt;
  struct chainon *pSuivant;
} chainonFile;
 
void init(chainonFile **pp) {
  chainonFile * pNull = NULL;
  *pp = pNull;
}
 
void push(chainonFile **pp, int val) {
  chainonFile *p2 = malloc(sizeof(chainonFile));
  p2->Elt = val;
  p2->pSuivant = *pp;
  *pp = p2;
}
 
/* Detruit tous les chainons,
   mais ne modifie pas le pointeur vers le premier */
void detruireFile(chainonFile *p) {
  /* Correction */
  while(p != NULL)
  {
    chainonFile *pDel = p;
    p = p->pSuivant;
    free(pDel);
  }
}
 
 
/* Correction: Il faut pouvoir modifier la file entière, 
   donc passer un pointeur de pointeur;
   on le mettra à NULL si on vide completement la pile */
chainonFile ** getDernierPtr(chainonFile **pp)
{
  if(pp==NULL) {
    return NULL;
  }
  if((*pp)==NULL) {
    return NULL;
  }
  while((*pp)->pSuivant != NULL)
  {
    pp = &( (*pp)->pSuivant; );
  }
  return pp;
}
 
void pop(chainonFile **pp) {
  chainonFile **ppDernier = getDernierPtr(pp);
  /* Note: Ici, ppDernier PEUT être égal à pp */
  if(ppDernier==NULL) {
    return;
  }
  free((*ppDernier));
  (*ppDernier) = NULL;
} 
 
void affiche(chainonFile const *p) {
  while(p!=NULL) {
    printf("%d\n",p->Elt);
    p = p->pSuivant;
  }
}
 
int main(void) {
  chainonFile *p;
  init(&p);
  push(&p,5);
  push(&p,3);
  affiche(p);
  pop(&p);
  printf("REMOVE\n");
  affiche(p);
  return 0;
}

p (dans main) contient l'adresse du premier maillon (ou NULL si il n'y en a pas).
On va passer l'adresse de p, &p , en argument si l'adresse du premier maillon est susceptible de changer, comme dans init, push et ce devrait être le cas dans pop et popR :
Code:

1 2 3 4 5 6 7 8 9 10 11 void pop(file *p){ if(p==NULL) return; // liste vide if((p)->suivant==NULL){ // liste avec 1 maillon free(p); // suppression de ce maillon : la liste est maintenant vide // pourtant, la valeur de p dans la programme appelant n'a pas changé // et correspond maintenant à une adresse illégale. // Elle aurait du être mise à NULL return; } .....
Citation:

je ne passe pas l'adresse dans le main donc logiquement je ne devrai pas modifié ma liste chaînée?

Si on a l'adresse du premier maillon, on peut modifier tous les maillons les uns après les autres, puisque chaque maillon comporte l'adresse du suivant.

Merci pour l'aide, alors tous d'abord concernant le message de médinoc:
Code:

1 2 3 4 5 void init(chainonFile **pp) { chainonFile * pNull = NULL; *pp = pNull; }
pourquoi ne pas directement mettre *pp=NULL?
Code:

1 2 3 4 5 6 7 8 9 10 void detruireFile(chainonFile *p) { /* Correction */ while(p != NULL) { chainonFile *pDel = p; p = p->pSuivant; free(pDel); } }
Sa c'est pour qu'il n'y est pas de fuite mémoire ok, mais pourquoi ne pas supprimé le 1er chainon (je suppose qu'on met sa avant la fin du programme donc on en a plus besoin)?

La je comprend pas du tout:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 chainonFile ** getDernierPtr(chainonFile **pp) { if(pp==NULL) { return NULL; } if((*pp)==NULL) { return NULL; } while((*pp)->pSuivant != NULL) { pp = &( (*pp)->pSuivant; ); } return pp; }
Sa te permet d'avoir l'adresse du dernier maillon c'est sa?
Code:

1 2 3 4 if(pp==NULL) { return NULL; }
Alors ici pp c'est une adresse donc tu test si une adresse est null, je ne savais pas que c'était possible.( sa marche comment sa?)

Je sait que quand on a une adresse en paramètre d'une fonction on met pointeur de pointeur pour les listes chaînées mais je n'est pas vraiment comprit pourquoi?

Citation:
Envoyé par Delnir
Code:

1 2 3 4 5 void init(chainonFile **pp) { chainonFile * pNull = NULL; *pp = pNull; }
pourquoi ne pas directement mettre *pp=NULL?
Juste dans un but pédagogique, pour être plus clair: Ça montre bien les deux niveaux de pointeurs.
Citation:
Code:

1 2 3 4 5 6 7 8 9 10 void detruireFile(chainonFile *p) { /* Correction */ while(p != NULL) { chainonFile *pDel = p; p = p->pSuivant; free(pDel); } }
Sa c'est pour qu'il n'y est pas de fuite mémoire ok, mais pourquoi ne pas supprimé le 1er chainon (je suppose qu'on met sa avant la fin du programme donc on en a plus besoin)?
Mais ce code supprime bien le premier chaînon. C'est juste qu'il ne change pas le pointeur dessus, qui doit alors être remis à NULL manuellement:
Code:

1 2 detruireFile(pPremier); pPremier = NULL;
J'aurais pu faire comme pour les autres fonctions et passer un pointeur de pointeur, cela aurait été plus propre.
Citation:
La je comprend pas du tout:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 chainonFile ** getDernierPtr(chainonFile **pp) { if(pp==NULL) { return NULL; } if((*pp)==NULL) { return NULL; } while((*pp)->pSuivant != NULL) { pp = &( (*pp)->pSuivant; ); } return pp; }
Sa te permet d'avoir l'adresse du dernier maillon c'est sa?
Non, il permet d'avoir l'adresse du pointeur sur le dernier maillon.
C'est-à-dire, l'adresse du pointeur qu'il faudra modifier.
Et s'il n'y a pas de dernier maillon, on retourne NULL, mais en fait j'aurais dû retourner pp à la place.
Citation:
Code:

1 2 3 4 if(pp==NULL) { return NULL; }
Alors ici pp c'est une adresse donc tu test si une adresse est null, je ne savais pas que c'était possible.( sa marche comment sa?)
Ce n'est pas l'adresse qui peut être nulle, mais le pointeur. C'est juste une vérification, normalement pp ne devrait jamais être nul. En temps normal, je mets une assertion plutôt qu'un test, mais je ne sais pas si tu connais les assertions, donc j'ai préféré ne pas compliquer les choses.

Citation:

Je sait que quand on a une adresse en paramètre d'une fonction on met pointeur de pointeur pour les listes chaînées mais je n'est pas vraiment comprit pourquoi?

Pour que la fonction puisse modifier le pointeur, il faut passer son adresse. Donc, un pointeur de pointeur.