Discussion :

[regma]

Bonjour,

Débutant en C , j'ai plusieurs incompréhensions au niveau des pointeurs et fonctions avec pointeurs en paramètre.

En parcourant la FAQ C, je suis tombé sur cette fonction unsigned dix_puissance_n(unsigned n);

J'ai mis mettre cette fonction dans un .h et un .c puis de la tester dans un fichier test.c
J'ai également refait la fonction avec un pointeur.

fct_maths.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <stdlib.h>
#include <stdio.h>
#include "fct_maths.h" 
 
unsigned ui_dix_puissance_n(unsigned n) 
{ 
    unsigned i, res = 1; 
 
    for(i = 0; i < n; i++) 
        res *= 10; 
 
    return res; 
}
 
void v_dix_puissance_n(unsigned *pn) 
{ 
    unsigned i, res = 1; 
 
    for(i = 0; i <*pn; i++) 
        res *= 10; 
	printf("%d", res);
} 
 
/*
int addition(int c, int d) {
	return (c+d);
} 
*/
 
/* 
double arrondi(const double x, unsigned n) 
{ 
    unsigned N = dix_puissance_n(n); 
    return floor(x * N + 0.5) / N; 
}
*/

fct_maths.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef _FCT_MATHS_H_
#define _FCT_MATHS_H_
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
 
unsigned ui_dix_puissance_n(unsigned n);
void v_dix_puissance_n(unsigned *pn);
//int addition(int c, int d);
//double arrondi(const double x, unsigned n);
 
 
#endif

test.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include "fct_maths.h"
 
int main(int argc, char *argv[]) {
 
	double a = 1;
	int b = ui_dix_puissance_n(a);
	printf("valeur de b\n%d\n", b);
 
	printf("\n__________\n\n");
 
	int c = 1;
	int *pc = &c;
	printf("valeur de c\n");
	v_dix_puissance_n(pc);
 
	return(0);
}

Mais quelle différence entre une fonction qui ne renvoie rien et modifier la variable directement en mémoire et une fonction qui renvoie un int dont on affecte le résultat dans une variable.
Ce que j'ai compris c'est que en général, l'utilisation d'une fonction avec pointeur (donc void fonction(int *pn)) est plus rapide que l'affectation du résultat à une variable (int fonction(int n), du fait de la manipulation de la variable directement par son adresse mémoire.

Mes interrogations:

-Quelles sont tous les avantages d'utiliser une fonction avec pointeur plutôt que l'autre avec un type de retour ?
-J'ai tendance à penser que l'utilisation d'une variable pointeur rajoute une variable au programme, tandis que sans pointeur on s'affranchit d'une variable, dans mon test.c ce n'est pas vrai car j'utilise une variable b pour stocker le résultat de la fonction mais si on utilisait directement ce résultat pour d'autre traitement.
-Existe t il un moyen mémo-technique pour savoir quand utiliser *pointeur ou pointeur ou &pointeur ? surtout le &pointeur.
-Pourriez vous me corriger si j'ai faux :
si je fais :
int variable = 1;
int *pvariable = &variable;
*pvariable --> c'est une variable qui stocke l'adresse mémoire de la variable, une fois " *pointeur = &variable " fait; si je l'affiche c'est l'adresse mémoire que je verrai
pvariable --> c'est la valeur de la variable pointé, donc la valeur de 'variable', si je l'affiche c'est la valeur de 'variable' que je verrai
&variable --> si je l'affiche, j'affiche l'adresse mémoire de la référence donc l'adresse mémoire de &variable

désolé pour ce pavé mais j'ai du mal, même en lisant et relisant le concept des pointeurs.

merci à vous, bonne journée

[Matt_Houston]

Mais quelle différence entre une fonction qui ne renvoie rien et modifier la variable directement en mémoire et une fonction qui renvoie un int dont on affecte le résultat dans une variable.

Ton exemple est erroné : ta seconde fonction ne modifie pas la variable dont la référence est passée en paramètre puisqu'il s'agit de l'exposant, pas du résultat.

-Quelles sont tous les avantages d'utiliser une fonction avec pointeur plutôt que l'autre avec un type de retour ?

La question est à la fois :

• technique : quelle est la différence entre passage par valeur et passage par référence ? C'est une interrogation classique traitée en long, en large et en travers dans la littérature, je te laisse te renseigner. Mais le TL;DR en est : par valeur pour les petits objets, par référence pour les gros (« petit » et « gros » étant subjectifs et fonction de l'architecture cible).
• Et sémantique : doit-on écrire le traitement sous forme de fonction ou de procédure ? C'est assez subjectif. Il existe toutefois un consensus pour écrire les traitements mathématiques sous forme de fonction, afin de pouvoir les utiliser au sein d'expressions proches des notations en usage dans les sciences mathématiques.

En tous les cas, une méthode n'est pas meilleure que l'autre dans le cas général : tout dépend du contexte d'utilisation. On lit souvent « use the right tool for the job » .

-J'ai tendance à penser que l'utilisation d'une variable pointeur rajoute une variable au programme, tandis que sans pointeur on s'affranchit d'une variable, dans mon test.c ce n'est pas vrai car j'utilise une variable b pour stocker le résultat de la fonction mais si on utilisait directement ce résultat pour d'autre traitement.

On s'en fout :

• une variable sur la pile, c'est pratiquement gratuit (en temps d'exécution, pas en espace mémoire, et encore faut bourriner pour smasher la pile..) ;
• le compilateur passera tellement ton code à la moulinette que tu ne peux absolument rien prédire des caractéristiques de l'exécutable final à partir du nombre de variables présentes dans le code source.

-Existe t il un moyen mémo-technique pour savoir quand utiliser *pointeur ou pointeur ou &pointeur ? surtout le &pointeur.

Je n'ai pas saisi ta question : ces expressions ne sont pas interchangeables, on utilise celle dont on a besoin !

-Pourriez vous me corriger si j'ai faux :
si je fais :
int variable = 1;
int *pvariable = &variable;
*pvariable --> c'est une variable qui stocke l'adresse mémoire de la variable, une fois " *pointeur = &variable " fait; si je l'affiche c'est l'adresse mémoire que je verrai
pvariable --> c'est la valeur de la variable pointé, donc la valeur de 'variable', si je l'affiche c'est la valeur de 'variable' que je verrai
&variable --> si je l'affiche, j'affiche l'adresse mémoire de la référence donc l'adresse mémoire de &variable

variable, de type int : identifie le contenu d'un bloc mémoire de taille sizeof(int), alloué lors de la définition de variable.
&variable et pvariable, de type int * : identifient l'adresse du premier octet du bloc de taille sizeof(int) alloué lors de la définition de variable.
*pvariable, de type *(int *), soit int : identifie la valeur pointée par pvariable, soit le contenu du bloc de taille sizeof(int) dont l'adresse du premier octet en mémoire est stockée dans pvariable.
&pvariable, de type (int *)*, soit int ** : identifie l'adresse de pvariable, soit l'adresse d'un bloc mémoire de taille sizeof(int *), alloué lors de la définition de pvariable et dont le contenu correspond à l'adresse de variable (ouf !).

Attention, * et & sont des opérateurs. En conséquence *pvariable et &pvariable sont des expressions, pas des variables à part entière.

[vertebre]

Ton exemple est erroné : ta seconde fonction ne modifie pas la variable dont la référence est passée en paramètre puisqu'il s'agit de l'exposant, pas du résultat.

Je ne m'en était pas rendu compte, mais je l'ai refait pour être sur d'avoir sompris.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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>
 
void pplusdeux(int *pa) ;
int plusdeux(int a);
 
int main() {
 
    int a =0;
    int *pa = &a;
    plusdeux(a); // ne modifie pas a
    pplusdeux(pa); // modifie a
    printf("%d", a);
 
    return(0);
 
}
 
/* Ajoute 2 à la variable */
void pplusdeux(int *pa) 
{
    *pa = *pa+2;
}
int plusdeux(int a) {
    return (a+2);
}

Citation Envoyé par regma
-Quelles sont tous les avantages d'utiliser une fonction avec pointeur plutôt que l'autre avec un type de retour ?

Ok pour l'utilisation petits objets, gros objets ainsi pour que pour écrire les traitements mathématiques [...]
Mais est ce que on peut dire que: si on souhaite garder toutes les valeurs lors de multiples traitements on préfère passer par valeur et dans le cas où seul le résultat final nous intéresse on préfère passer par référence ?

Citation Envoyé par regma
-J'ai tendance à penser que l'utilisation d'une variable pointeur rajoute une variable au programme, tandis que sans pointeur on s'affranchit d'une variable, dans mon test.c ce n'est pas vrai car j'utilise une variable b pour stocker le résultat de la fonction mais si on utilisait directement ce résultat pour d'autre traitement.

Dans le cas d'un programme qui contient beaucoup beaucoup de traitements, et que seul le résultat final nous intéresse, l'économie de variables est il justifiée ou on ne s'en préoccupe toujours pas ?

Citation Envoyé par regma
-Existe t il un moyen mémo-technique pour savoir quand utiliser *pointeur ou pointeur ou &pointeur ? surtout le &pointeur.

euh en fait ma question était mal posée;
quand est ce que j'utilise &var ? mise à part lorsque je fais *pointeur=&var; (déréférencement du pointeur si je me trompe pas )

Envoyé par Matt_Houston
variable, de type int : identifie le contenu d'un bloc mémoire de taille sizeof(int), alloué lors de la définition de variable.
&variable et pvariable, de type int * : identifient l'adresse du premier octet du bloc de taille sizeof(int) alloué lors de la définition de variable.
*pvariable, de type *(int *), soit int : identifie la valeur pointée par pvariable, soit le contenu du bloc de taille sizeof(int) dont l'adresse du premier octet en mémoire est stockée dans pvariable.
&pvariable, de type (int *)*, soit int ** : identifie l'adresse de pvariable, soit l'adresse d'un bloc mémoire de taille sizeof(int *), alloué lors de la définition de pvariable et dont le contenu correspond à l'adresse de variable (ouf !).

Bien que ton explication soit très complète, j'ai du mal à saisir plusieurs choses:

-un bloc mémoire de taille sizeof(int)

La valeur de sizeof(int) correspond t elle à la taille en bits ou en octet ?
Comment affiché cette valeure ? Ou plutôt quel type de valeur çà me renvoie ?
J'ai essayé d'afficher la valeur de sizeof(int) mais je ne sais pas quel format utilisé dans le printf(), j'ai tenté le %d qui me renvoie 4 et le %f mais bon.

-*(int *) = int
Pourrais tu m'expliquer littéralement le type *(int *) stp ?

-L'adresse du premier octet du bloc de taille sizeof(int)
J'ai encore du mal à saisir cette ligne même si je sais que 1 octet = 8 bits

-int **
Peux tu me confirmer que c'est un type pointeur de pointeur et que ce dernier pointe sur une variable entière ?

merci d'avance

[Matt_Houston]

Mais est ce que on peut dire que: si on souhaite garder toutes les valeurs lors de multiples traitements on préfère passer par valeur et dans le cas où seul le résultat final nous intéresse on préfère passer par référence ?

Ce n'est pas vraiment lié, non. Et puis grâce à la forme fonction on peut écrire cela : i = h(g(f(e(d(c(b(a))))))); .

Dans le cas d'un programme qui contient beaucoup beaucoup de traitements, et que seul le résultat final nous intéresse, l'économie de variables est il justifiée ou on ne s'en préoccupe toujours pas ?

Non, toujours pas. Comme je l'évoquais, le nombre de variables déclarées (toutes proportions gardées) ne préjuge en rien des performances du programme. Considère que c'est gratuit. Un exemple, la fonction suivante n'a au final besoin de disposer de ressources que pour deux variables alors qu'elle en déclare trois :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void foobar() {
    int a = 3,
        b = -8;
 
    a += a * b;
    printf("a: %d\n", a); // à partir d'ici, 'b' n'est plus utilisé mais toujours déclaré
 
    int c = 483197; // le compilateur peut décider d'utiliser l'espace mémoire alloué à 'b' pour stocker 'c', 'b' est alors effectivement "détruit"
    a /= c;
    printf("a: %d\n", a);
 
    // décommenter la ligne suivante force le compilateur à conserver la variable 'b'
    //printf("b: %d\n", b);
}

Le seul souci engendré par un grand nombre de variables, c'est la difficulté de relecture.

quand est ce que j'utilise &var ? mise à part lorsque je fais *pointeur=&var; (déréférencement du pointeur si je me trompe pas )

Non, c'est soit pointeur = &var; (référencement puis affectation d'adresse), soit *pointeur = var; (déréférencement puis affectation de valeur). En supposant que si var est de type TYPE alors pointeur est de type TYPE * évidemment.

Tu utilises l'opérateur & lorsque tu as besoin de récupérer l'adresse d'une variable, non sa valeur. Afin de la passer par référence par exemple : pplusdeux(&a); si je reprends ton code plus haut.

La valeur de sizeof(int) correspond t elle à la taille en bits ou en octet ?
Comment affiché cette valeure ? Ou plutôt quel type de valeur çà me renvoie ?
J'ai essayé d'afficher la valeur de sizeof(int) mais je ne sais pas quel format utilisé dans le printf(), j'ai tenté le %d qui me renvoie 4 et le %f mais bon.

sizeof renvoie la taille d'un type ou d'un objet en octets sous la forme d'une valeur entière de type size_t qui se formate grâce à "%zu".

Pourrais tu m'expliquer littéralement le type *(int *) stp ?

En fait ce type n'existe pas, j'essayais de décomposer le typage pour que tu saisisses le rôle de l'opérateur de déréférencement * : déréférencer un pointeur de type TYPE * renvoie un TYPE (on « retire un astérisque »).

-L'adresse du premier octet du bloc de taille sizeof(int)
J'ai encore du mal à saisir cette ligne

La mémoire système d'un ordinateur est adressable au niveau de l'octet, char en C. L'adresse d'un objet en mémoire correspond donc à l'adresse de son premier octet (on ne va pas commencer au milieu ! ). [ Accessoirement pour un entier cet octet contient soit les CHAR_BIT (voir ci-après) bits de poids fort sur une architecture big endian, soit les CHAR_BIT bits de poids faible sur une architecture little endian. ]
La taille d'un objet de type TYPE en mémoire est égale à sizeof(TYPE). L'objet TYPE foo; s'étend donc en mémoire de &foo à (char *)&foo + sizeof(TYPE) - 1 inclus (tu comprendras pourquoi on caste l'adresse initiale en char * lorsque tu verras l'arithmétique sur les pointeurs ).

même si je sais que 1 octet = 8 bits

Attention : un octet regroupe CHAR_BIT bits, pas obligatoirement huit. C'est pourquoi il est parfois préférable de parler de byte qui n'a pas d'équivalent en français. Il est peu probable que tu rencontres un jour une architecture où CHAR_BIT == 8 ne soit pas vérifié, mais il faut le savoir.

Peux tu me confirmer que c'est un type pointeur de pointeur et que ce dernier pointe sur une variable entière ?

Je te le confirme.

[vertebre]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void foobar() {
    int a = 3,
        b = -8;
 
 
    a += a * b;
    printf("a: %d\n", a); // à partir d'ici, 'b' n'est plus utilisé mais toujours déclaré
 
    int c = 483197; // le compilateur peut décider d'utiliser l'espace mémoire alloué à 'b' pour stocker 'c', 'b' est alors effectivement "détruit"
    a /= c;
    printf("a: %d\n", a);
 
    // décommenter la ligne suivante force le compilateur à conserver la variable 'b'
    //printf("b: %d\n", b);
}

oh je comprend maintenant, le programme peut réutiliser l'emplacement mémoire d'une variable pour une autre si cette première ne sert plus. D'où ton 'c'est gratuit'

J'ai 2 questions à ce propos qui ne sont peut être pas de mon niveau mais qui m'intéresse néanmoins ...

-Lorsque le compilateur compile le code c (gcc pgr.c), il traduit le code en assembleur, mais il va également exécuter le programme ? de tel façon que les variables vont être mis en mémoire et les fonction exécutées, etc ... ?

-Comment fais le compilateur pour savoir qu'il doit conserver 'b' (ou dans le cas général quelles variables il doit garder ou détruire) ? il fait un premier passage de vérification et ensuite compile le programme ? ce doit être plus compliqué que çà bien sur mais dans l'idée ce pourrait être une façon de le voir ?

Non, c'est soit pointeur = &var; (référencement puis affectation d'adresse), soit *pointeur = var; (déréférencement puis affectation de valeur). En supposant que si var est de type TYPE alors pointeur est de type TYPE * évidemment.

ah mince j'avais oublié le int *pointeur = $var; dans ma question mais bon je pense ne pas avoir bien compris alors.

En fait ce type n'existe pas, j'essayais de décomposer le typage pour que tu saisisses le rôle de l'opérateur de déréférencement * : déréférencer un pointeur de type TYPE * renvoie un TYPE (on « retire un astérisque »).

oups je ne comprend plus bien le référencement et déréférencement de pointeur du coup.
je pensais que cela correspondait à çà :

int a;
int *pa; // On référence un pointeur donc on réserve un emplacement mémoire vide
*pa = &a // on déréférence un pointeur donc on met l'adresse de a dans cette emplacement mémoire

ai je compris de travers encore une fois ?


Encore une fois thanks pour ces explications je suis un peu collant intéressé je sais mais bon ...

---

@jopopmk

regma/verterbre, c'est la même personne ?

oh comment remarques tu la similarité ? on nous dit souvent que l'on a la même voix mais là sur un forum . mais oui dans l'idée nous sommes pratiquement les mêmes
Bien qu'il y en a encore 2 autres un plus grand et un plus petit qui ne va pas tardé à s'inscrire. Pourtant on dit souvent que les plus petits passent inaperçu par rapport au plus grand, pas cette fois çi Je devrais me taire.

Là j'ai quelque souci à imaginer le cas que tu nous présentes.
Si tu as un exemple précis en tête expose le, je pourrais peut-être te répondre.

je viens de comprendre mon erreur d'expression, je voulais dire entre utiliser une procédure qui renvoie void et une fonction qui a un type de retour.
Oui parceque le passage par valeur ou référence c'est pour les pramètres

Ce que je voulais dire c'est plutôt que de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
// on veut garder les valeurs après chaque traitement
int ajouteDeux(int a);
int calculSavant(int a);
int trifouilleFortement(int a);
 
int a,b,c,d;
 
b = ajouteDeux(a);
c = calculSavant(b);
d = trifouilleFortement(c);
etc ...

on pourrait faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
// on ne veut conserver que le résultat final
void ajouteDeux(int *pa);
void calculSavant(int *pa);
void trifouilleGrave(int *pa);
int a,b;
int *pa;
trifouilleGrave(pa);
 
void trifouilleGrave (int *pa) {
ajouteDeux(pa);
calculSavant(pa);
// +les traitements de trifouilleGrave
}

L'opérateur & va permettre d'obtenir l'adresse ne mémoire de la variable associée.
Il est très utile justement quand tu utilies une fonction qui utilise des références pour sortie, ex.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
void mezy_trois(int *i) {
  *i = 3;
}
void main(void) {
  int i;
  mezy_deux(&i);
  printf("%d\n", i); // affiche 3 dans la sortie standard
}

Comment peux t on utilisé le &i sans faire le int *pi=&i; ?
Ce que j'ai tendance à penser c'est que pour toute variable 'var', la référence &var existe automatiquement ?

Pour vraiment mieux comprendre j'ai testé de faire çà :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
 
int main() {
 
	int i=0;
	int *pi = &i;
	printf("%p", &i); // affiche l'adresse mémoire de la variable i
	printf("\n%p\n", pi); // affiche l'adresse mémoire de la  variable i au format hexa
	printf("%d\n", pi); // affiche l'adresse mémoire de la  variable i au format entier
 
	printf("\n%p\n", *pi); // affiche l'adresse mémoire de rien ?
	return(0);
 
}

@Sve@r
Je devrais répondre au fur et à mesure plutôt que de tout faire en même temps
Tu as vu ma première erreur entre paramètres et types de retour, et tu répond en partie à ma 2eme question sur les pointeurs. mercii à toi .

@All
une dernière chose, maintenant quand je dis &var je dis référence, alors que lorsque je l'affiche j'ai une adresse mémoire. que dois je penser svp ?

Merci à vous tous !

[sambia39]

Bonsoir,

Débutant en C , j'ai plusieurs incompréhensions au niveau des pointeurs et fonctions avec pointeurs en paramètre.
En parcourant la FAQ C, je suis tombé sur cette fonction unsigned dix_puissance_n(unsigned n);

J'ai mis mettre cette fonction dans un .h et un .c puis de la tester dans un fichier test.c
J'ai également refait la fonction avec un pointeur.

Mais quelle différence entre une fonction qui ne renvoie rien et modifier la variable directement en mémoire et une fonction qui renvoie un int dont on affecte le résultat dans une variable.
Ce que j'ai compris c'est que en général, l'utilisation d'une fonction avec pointeur (donc void fonction(int *pn)) est plus rapide que l'affectation du résultat à une variable (int fonction(int n), du fait de la manipulation de la variable directement par son adresse mémoire.

Dans le domaine informatique (où algorithmique), toute fonction (routine) réalisant une action dont son utilisation joue le rôle d'une instruction est appelée procédure. Et toute routine (si je peux dire) qui réalise une tâche ou calcule en suivant une séquence d'instruction est appelée fonction.

Le cas du langage C :
Toute fonction qui a pour type "void" ou qui ne renvoie aucune valeur sont des procédures. L’inverse est dit fonction. Cependant, certaines fonctions du langage C qui a pour rôle d'instruction renvoyons une valeur considérer (la plupart du temps) "négligeable" sont également appelées procédures Exemple: les procédures de lecture de flux d'entrée ou sortie (scanf/printf).

Quelque précisions:
On dit passage par valeur quand une fonction obtient qu'une copie des variables utilisées par l'appelant. Les paramètres de la fonction sont alors considérés comme des variables locales qui sont initialisées automatiquement avec les valeurs des variables indiquées lors d'un appel. À l'intérieur de la fonction, on peut changer les valeurs des paramètres sans influencer les valeurs originales dans les fonctions appelantes.

On dit passage par référence lorsque l’on n’utilise pas la valeur de l’argument dans le corps de la fonction, mais l’argument en tant qu’objet. Ainsi donc, l’ensemble des modifications effectué sur l’objet persisterons même en dehors de la fonction. Cette définition n’est valable qu’on langage C++, car on est dans une notion qui est dit objet. En langage C on dit passage par adresse (plutôt que passage par référence). Lorsque l’on utilise les pointeurs donnant ainsi à la fonction un accès complet aux contenues de la variable grâce aux variables pointeurs comme paramètre de fonction. Ainsi donc la seule façon pour simuler le passage par référence en langage C C'est le passage par adresse. Mais il faut également comprendre qu’il y a une différence importante entre l'appel par référence de C++ et l'appel par adresse en langage C.

Mes interrogations:
-Quelles sont tous les avantages d'utiliser une fonction avec pointeur plutôt que l'autre avec un type de retour ?
-J'ai tendance à penser que l'utilisation d'une variable pointeur rajoute une variable au programme, tandis que sans pointeur on s'affranchit d'une variable, dans mon test.c ce n'est pas vrai car j'utilise une variable b pour stocker le résultat de la fonction mais si on utilisait directement ce résultat pour d'autre traitement.
-Existe t il un moyen mémo-technique pour savoir quand utiliser *pointeur ou pointeur ou &pointeur ? surtout le .......

Les passages par adresse ou par référence sont plus rapides et économes en espace mémoire que les passages par valeur, tout simplement parce que, la création de la variable locale et la copie de la valeur de celle-ci, ne sont pas faites. D’ailleurs il est conseillé de ne pas utiliser le passage par valeur dans les cas d'appels récursifs de fonction (par exemple). D’un autre côté le passage par valeurs permet d'éviter la destruction ou la modification de la variable d’origine passée en paramètre. On peut toute fois utilisée le mots clé "const" pour interdire toute modification de la variable dans la fonction, ce qui oblige que le développeur effectuer une copie de la valeur dans une variable locale dans la fonction.

J'ai 2 questions à ce propos qui ne sont peut être pas de mon niveau mais qui m'intéresse néanmoins ...

-Lorsque le compilateur compile le code c (gcc pgr.c), il traduit le code en assembleur, mais il va également exécuter le programme ? de tel façon que les variables vont être mis en mémoire et les fonction exécutées, etc ... ?

-Comment fais le compilateur pour savoir qu'il doit conserver 'b' (ou dans le cas général quelles variables il doit garder ou détruire) ? il fait un premier passage de vérification et ensuite compile le programme ? ce doit être plus compliqué que çà bien sur mais dans l'idée ce pourrait être une façon de le voir ?

Le compilateur a seulement pour rôle la traduction du langage source en langage cible (machine) de façon indépendante. Je veux dire par là que le compilateur compile indépendamment chacun des fichiers source et pour chacun de ces fichiers source, il le traduit en langage machine le tout avec ce que l’on appelle la table des symboles qui est le fichier objet possédant l’extension « .o»
Plus exactement, le compilateur, après avoir traduit le langage source en langage machine, va spécifier à quel endroit précis de la mémoire les instructions vont être placées et spécifie également que les instructions sont placées à partir de l’adresse (exemple) « 0x01 » ajouté au langage machine et génère la table des symboles qui contient tous les endroits où une adresse est utilisée par le compilateur, mais également ceux que le compilateur ne connaît pas. Exemple avec l'adresse de la fonction « scanf, fprintf, etc..» qui n'est pas définie dans le code et ce, pour la simple raison que le programme, après avoir été compilé, fait appel à ces fonctions qu’il n’a pas définies lui-même, mais qui le sont dans des bibliothèques. Donc, l’éditeur de lien va se charger de récupérer l’ensemble des codes qui correspond aux fonctions citées précédemment et l’ajouter.
L'exécution du résultat du compilateur se fait après la phase compilation.

Ok pour l'utilisation petits objets, gros objets ainsi pour que pour écrire les traitements mathématiques [...]
Mais est ce que on peut dire que: si on souhaite garder toutes les valeurs lors de multiples traitements on préfère passer par valeur et dans le cas où seul le résultat final nous intéresse on préfère passer par référence ?

Le langage C n’est pas un langage orienté objet et à ne pas confondre avec le langage C++ qui lui est orienté objet. Il faut dissocier les deux.
Si vous optez pour des notions d’objets alors il faut s’orienter vers le langage C++. La notion d’objet petit ou gros est uniquement du domaine de la programmation orienté objet en utilisant le langage de programmation adapté (le langage C++). C’est une erreur de le confondre avec le langage C .

Mais est ce que on peut dire que: si on souhaite garder toutes les valeurs lors de multiples traitements on préfère passer par valeur et dans le cas où seul le résultat final nous intéresse on préfère passer par référence ?
......
Dans le cas d'un programme qui contient beaucoup beaucoup de traitements, et que seul le résultat final nous intéresse, l'économie de variables est il justifiée ou on ne s'en préoccupe toujours pas ?

L’informatique est une science qui traite des informations automatiquement à l'aide de l'ordinateur. Pour manipuler ses différentes informations, on utilise les variables qui nous permettent de stocker le résultat d’un calcul ou autres. De ce fait, le choix d’utiliser par exemple une variable pointeur plutôt qu’une variable typée dépend de ce que vous comptez faire et le but recherché (sans oublié le côté algorithme qui est doit être pris en compte).

Bien que ton explication soit très complète, j'ai du mal à saisir plusieurs choses:
-un bloc mémoire de taille sizeof(int)
La valeur de sizeof(int) correspond t elle à la taille en bits ou en octet ?

"sizeof" sert à calculer la taille de n'importe quel type de données, expression ou d'un objet en mémoire (comme: une variable, variable a virgule flottante , des types de variables pointeurs ou des types de données composées complexes (unions et structures par exemple)). Mais attention "sizeof" tient compte de la représentation physique et intègre des zones inutilisées du cadrage sur un mot machine (padding). De plus "sizeof" sur une autre architecture donne pas le même résultat si vous êtes sur une architechire 64 ou 32 bits.

à bientôt

[Sve@r]

Lorsque le compilateur compile le code c (gcc pgr.c), il traduit le code en assembleur, mais il va également exécuter le programme ? de tel façon que les variables vont être mis en mémoire et les fonction exécutées, etc ... ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
int main()
{
    int i=0;
    while (1) {
        printf("i=%d\n", i);
        i++;
   }
}

Ouais super, compile moi ça. Mais exécute-le bien entièrement surtout, avant de le compiler...

-Comment fais le compilateur pour savoir qu'il doit conserver 'b' (ou dans le cas général quelles variables il doit garder ou détruire) ? il fait un premier passage de vérification et ensuite compile le programme ? ce doit être plus compliqué que çà bien sur mais dans l'idée ce pourrait être une façon de le voir ?

Bah, à priori il a un code entre "{" et "}", à secondiori il a des lignes terminées par un point-virgule donc à tiertiori si à partir de la ligne 10 la variable "b" n'est plus mentionnée c'est qu'elle n'est plus utilisée...

oups je ne comprend plus bien le référencement et déréférencement de pointeur du coup.

Tu utilises des mots qui ne sont pas adaptés et qui ne sont appliquables qu'en C++.

je pensais que cela correspondait à çà :

int a; // On déclare une variable "a" prévue pour recevoir un type "entier"
int *pa; // On référence un pointeur donc on réserve un emplacement mémoire vide // On déclare une variable "pa" prévue pour recevoir un type "adresse"
*pa = &a // on déréférence un pointeur donc on met l'adresse de a dans cette emplacement mémoire // Non, ça ne veut rien dire (enfin si, ça veut dire quelque chose mais rien de bien sensé). C'est pa=&a qu'il faut écrire => je stocke l'adresse de a dans la variable destinée à stocker une adresse
*pa=1234; // On stocke la valeur "1234" dans la variable "a" - A ce sujet donc, "*pa=&a" fonctionne mais ça stocke "l'adresse de a" dans "a" ce qui reste correct (une adresse reste quand-même un entier) mais a peu de signification d'un point de vue algo

Mes remarques en rouge dans tes exemples. Plus un 3°

Ce que je voulais dire c'est plutôt que de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
// on veut garder les valeurs après chaque traitement
int ajouteDeux(int a);
int calculSavant(int a);
int trifouilleFortement(int a);
 
int a,b,c,d;
 
b = ajouteDeux(a);
c = calculSavant(b);
d = trifouilleFortement(c);
etc ...

on pourrait faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
// on ne veut conserver que le résultat final
void ajouteDeux(int *pa);
void calculSavant(int *pa);
void trifouilleGrave(int *pa);
int a,b;
int *pa;
trifouilleGrave(pa);
 
void trifouilleGrave (int *pa) {
ajouteDeux(pa);
calculSavant(pa);
// +les traitements de trifouilleGrave
}

C'est selon tes besoins/désirs. Mais sinon c'est correct du point de vue syntaxe (les fonctions qui doivent recevoir une adresse reçoivent bien une adresse).

Ce que j'ai tendance à penser c'est que pour toute variable 'var', la référence &var existe automatiquement ?

Exact

Pour vraiment mieux comprendre j'ai testé de faire çà :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>

int main() {
	
	int i=0;
	int *pi = &i;
	printf("%p", &i); // affiche l'adresse mémoire de la variable i
	printf("\n%p\n", pi); // affiche l'adresse mémoire de la  variable i au format hexa  // Affiche le contenu de "pi" au format hexa. Même si, pour le moment, le contenu de pi c'est l'adresse de i, c'est quand-même plus conforme à la vérité
	printf("%d\n", pi); // affiche l'adresse mémoire de la  variable i au format entier   // Idem remarque ci-dessus
	
	printf("\n%p\n", *pi); // affiche l'adresse mémoire de rien ?  // Affiche le contenu de "ce qui est pointé par pi" (donc pour l'instant "i") au format hexa
	return(0);
	
}

Idem

une dernière chose, maintenant quand je dis &var je dis référence, alors que lorsque je l'affiche j'ai une adresse mémoire. que dois je penser svp ?

Tu penses de la façon qui t'aide à comprendre. Perso pour moi c'est une adresse. Le mot "référence" s'applique plutôt à certaines écritures de passage de paramètre du C++ (passage par recopie, par adresse ou par référence) qu'on n'a pas en C (enfin on a juste le passage par recopie et par adresse).

[jopopmk]

Salut,

regma/verterbre, c'est la même personne ?
Pour tes questions Matt_Houston a plutôt bien répondu à tout, on va voir si je peux compléter :

Mais est ce que on peut dire que: si on souhaite garder toutes les valeurs lors de multiples traitements on préfère passer par valeur et dans le cas où seul le résultat final nous intéresse on préfère passer par référence ?

Là j'ai quelque souci à imaginer le cas que tu nous présentes.
Si tu as un exemple précis en tête expose le, je pourrais peut-être te répondre.

Dans le cas d'un programme qui contient beaucoup beaucoup de traitements, et que seul le résultat final nous intéresse, l'économie de variables est il justifiée ou on ne s'en préoccupe toujours pas ?

L'économie de variables intermédiaire sera toujours utile pour limiter les ressources nécessaires pour le fonctionnement de ton programme, par contre ça amène parfois à écrire des algo qui grêveront les performances. Quoi qu'il en soit, et en-dehors d'exemple précis, je ne vois pas bien le rapport avec ta première question (ref vs ret).

euh en fait ma question était mal posée;
quand est ce que j'utilise &var ? mise à part lorsque je fais *pointeur=&var; (déréférencement du pointeur si je me trompe pas )

L'opérateur & va permettre d'obtenir l'adresse ne mémoire de la variable associée.
Il est très utile justement quand tu utilies une fonction qui utilise des références pour sortie, ex. :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
void mezy_trois(int *i) {
  *i = 3;
}
void main(void) {
  int i;
  mezy_deux(&i);
  printf("%d\n", i); // affiche 3 dans la sortie standard
}

Bien que ton explication soit très complète, j'ai du mal à saisir plusieurs choses:

-un bloc mémoire de taille sizeof(int)

La valeur de sizeof(int) correspond t elle à la taille en bits ou en octet ?

sizeof renvoie une taille en octet.

Comment affiché cette valeure ? Ou plutôt quel type de valeur çà me renvoie ?

sizeof renvoie un size_t, qui est un unsigned int. Tu peux l'afficher avec un simple printf et le format %d comme tu l'as fait.
La taille de 4 est logique (ça fait un int sur 32 bits).

-*(int *) = int
Pourrais tu m'expliquer littéralement le type *(int *) stp ?

il faut comprendre (int*) comme un type, dans ce cas "pointeur sur int".
Avec une variable ça te parlera mieux :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
int *ptr; // ceci est une déclaration de pointeur sur int
ptr; // ceci est toujours un pointeur sur int
*ptr; // ceci est la valeur de l'entier enregistré à l'adresse contenue dans ptr

-L'adresse du premier octet du bloc de taille sizeof(int)
J'ai encore du mal à saisir cette ligne même si je sais que 1 octet = 8 bits

L'adressage mémoire se fait octet par octet. Et pour récupérer une donnée en mémoire il faut :
- la position de son début (l'adresse dudit premier octet),
- le nombre total d'octet à lire (dans ton cas, un int32, soit 4 octets).

-int **
Peux tu me confirmer que c'est un type pointeur de pointeur et que ce dernier pointe sur une variable entière ?

T'as bon dans l'idée.

Voilà, j'espère que ça t'aura un peu aidé.

Bon apprentissage.

[Sve@r]

mise à part lorsque je fais *pointeur=&var; (déréférencement du pointeur si je me trompe pas )

Bonjour

Je crois qu'ici il y a une petite ambiguïté mal comprise.
Si tu pars de int var=1234, tu as alors ensuite la possibilité d'écrire int *pt=&var. Mais attention à la façon de lire cette instruction car elle se lit en 2 étapes

1. je déclare un pointeur "pt" de type "int *" => int *pt
2. j'affecte l'adresse de "var" au pointeur "pt" => pt=&var

En aucun cas tu ne dois lire/dire "j'affecte l'adresse de var au contenu pointé par pt" (*pt=&var) car c'est totalement inexact et augmentera ta confusion.

Pour le reste, savoir si tu dois écrire int carre(int x) { return x*x } ou bien void carre(int *x) { (*x)=(*x)*(*x) } ben non seulement la seconde écriture part du principe qu'elle va modifier ce qu'elle reçoit (et ça c'est pas forcément la volonté de tout le monde) mais en plus, toujours avec cette seconde écriture, tu ne pourras pas faire des trucs simples style int var=carre(9)...

L'économie de variables intermédiaire sera toujours utile pour limiter les ressources nécessaires pour le fonctionnement de ton programme, par contre ça amène parfois à écrire des algo qui grêveront les performances

C'est plutôt le contraire qui se passe: pour améliorer les performances on crée des variables justement pour mémoriser des résultats intermédiaires au lieu de les recalculer à chaque fois
Exemple: for (i=0; i < strlen(chaine); i++) ... par rapport à int len=strlen(chaine); for (i=0; i < len; i++) ......

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void main(void) { ... }

Mouais. "main()" est quand-même de type "int"...

[ternel]

Bonjour, le reste ayant été assez discuté pour que je n'apporte rien dessus, je souhaite répondre à cette questio:

Existe t il un moyen mémo-technique pour savoir quand utiliser *pointeur ou pointeur ou &pointeur ? surtout le &pointeur.

Oui, mais ca demande une astuce.
Le C est un langage, il n'y a pas de raison qu'on ne puisse pas le transcrire en français.
Par exemple, int c = 2, d, e = 3; peux se lire "Soient de type entier c initialisé avec la valeur de 2, d, et e initialisé avec la valeur de 3.".
C'est simple, et clair.

Pour s'en sortir avec les pointeurs, il suffit de systématiquement lire * comme "ce que désigne" et & comme "la désignation de".

• int a; soit de type entier a
• int * pa; soit de type entier ce que désigne pa. pa n'est pas un entier, il permet d'en désigner un
• pa = &a; pa contient maintenant la désignation de a
• *pa = 2; ce que désigne pa contient maintenant 2
• int j = **&*&pa; soit de type entier j initialisé avec la valeur de ce que désigne ce que désigne la désignation de ce que désigne la désignation de pa.

Cette dernière ligne sert seulement à enfoncer le clou, ca n'existe pas dans du code. Par contre, tu vois clairement que *& peut se simplifier "ce que désigne la désignation de" truc, c'est toujours truc.