Discussion :

[luckyalan]

Bonjour,
je sais que cette question paraîtra triviale, voire déplacée pour les avertis, mais je suis un débutant et je m'arrache les cheveux avec les pointeurs !
je voudrais que plusieurs fonctions de mon programme aient accès à la variable "int nbLignes" sans pour autant avoir besoin de la modifier, juste lire la valeur.
je ne souhaite pas passer cette variable dans l'appel à la fonction car je passe déjà plein de variables dans l'appel.
une solution serait que ma variable soit globale, mais on lit partout que c'est interdit, alors que faire ? je n'arrive pas à utiliser les pointeurs, j'aimerais une solution alternative
merci de votre indulgence pour le vieux débutant (59 ans)
Bonne journée à tous

[Médinoc]

Généralement, si tu as à passer "plein de variables dans l'appel", c'est souvent que plusieurs de ces variables gagneraient à être regroupées au sein d'une même structure.

Par exemple, il est courant de regrouper dans une structure, un tableau (ou pointeur de tableau) et sa taille (ou ses dimensions s'il y en a plusieurs), car les deux sont indissociables:

Code :

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

1
2
3
4
5
6
struct MonTableauDynamique
{
	/*Pointeur vers premier élément du tableau*/
	int* pTableau;
	unsigned int taille;
};

etc.

Si tu veux que la fonction puisse modifier la structure il faudra passer par un pointeur, sinon tu peux directement la passer normalement: La fonction en obtiendra une copie.

PS: Familiarise-toi avec les tableaux, c'est la clé pour comprendre ensuite comment marchent les pointeurs.

[luckyalan]

merci Medinoc,
aie, évidemment quand je dis que je m'arrache les cheveux avec les pointeurs, les structures je ne les ai même pas abordées.
en fait quand je dis que je mets déjà plein de variables dans l'appel, les voici :
affichEcran(ecran, col, ligne, grille [col][ligne], nbLignes);
col, ligne, nblignes sont des int, et grille est un tableau... aucune de ces variables ne sont modifiées par la fonction appelée (toutes sont en void)
et je dois ajouter dans l'appel une nouvelle variable supplémentaire (int position)
la variable nbLignes ne change plus après qu'elle ait été définie dans le menu, c'est pourquoi je voudrais pouvoir y accéder de partout (ce n'est cependant pas une constante, sinon je l'aurai mise dans dans un fichier constante.h.
que me conseilles tu ?
merci à tous ceux qui partagent leurs connaissances
Cordialement

[Médinoc]

Je ne suis pas sûr. Comment est créé grille? S'agit-il d'un tableau à dimension variable (Variable-Length Array, alias VLA) qui n'est permis que sous les compilateurs C suffisamment récents? Si oui, le problème est que je n'ai jamais regardé ces types de près et j'ignore comment ils se comportent quand on les passe comme paramètre d'une fonction (et donc, j'ignore s'il est possible de les regrouper avec leurs dimensions dans une structure, ce que j'aurais fait avec des tableaux dynamiques "traditionnels").

PS: Qu'est-ce que le paramètre ecran, en fait?

[luckyalan]

Merci encore de ton intérêt
grille est un tableau fixe (50 col & 50 lignes).
ecran est une fenêtre SDL (SDL_Surface *ecran)
Cordialement

[Médinoc]

Là, on arrive à mes limites. Je ne pense pas pouvoir t'aider sans plus d'information sur la fonction (son code, le code qui entoure son appel, les déclarations des variables que tu lui passes en paramètres...)

Au moins, sache que tu n'a pas encore atteint de records quand au nombre de paramètres d'une fonction: StretchBlt() sous Windows en prend 11 (deux objets mémoire, les coordonnées d'un rectangle dans chacun, et un mode).

[Vespiras]

Salut

Bon j'ai peut-être lu le sujet un peu en diagonale mais je ne comprends toujours pas pourquoi tu ne veux pas utiliser de constante ? Ta valeur est amenée à changer ?

Sinon pour le coup un pointeur me semble parfait. Même si j'avoue que son fonctionnement est toujours long et compliqué à assimiler.

[Metalman]

SDL.... ecran....

Tu veux faire dans le graphisme...
L'exemple de Médinoc colle justement avec ton problème :
Dès le moment qu'il y a du graphique à faire, le nombre de paramètres va littéralement exploser (en général).

Le fait d'utiliser des "positions" (contenant une valeur x et y) c'est déjà une structure !
[les structures c'est très très simple]

Dans tous les cas, en règle général, tu auras toujours à passer "au moins" :
- la zone à blitter/adresse mémoire contenant "l'écran"
- la position exacte où blitter (x, y, z...)
- la chose qui va être placée à cet endroit

Comme Vespiras le dit : si tu connais ta taille max et qu'elle ne variera JAMAIS, utilise un define ! Ca optimise même lors du run !

Si tu veux afficher le contenu d'une case d'un tableau que tu gères, ça revient au même que là haut : ecran + position + grille[col][ligne]

Si tu veux afficher l'ensemble des objets de ton tableau... ça va en effet être un peu plus tricky... soit le tableau peut varier en taille et tu devras du coup :
ecran + position + grille + col_max + ligne_max

Ou alors, à la compilation, il a une taille fixe, et tu utilises des valeurs en dur dans ton code, pour en revenir à :
ecran + position + grille

[luckyalan]

merci à tous les 2 pour votre intérêt.
Vespiras, effectivement nbLignes ne peut pas être une constante car elle est modifiée par le menu en début de mon programme.
comme je l'ai dit, j'ai bien une solution simple, c'est de faire une variable globale, mais je lis souvent que c'est développer à l'arrache ! euh... pourquoi ?
les pointeurs, ça fait 20 fois que je relis le sujet et j'avoue que ça ne rentre pas.
voici quelques extraits de mon code : les definitions dans le main, l'appel de la fonction et la fonction qui reçoit l'appel :

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
 
int main(int argc, char *argv[])
{	
	SDL_Surface *ecran = NULL, *VIDE, *JAUNE, *ROUGE, *BLANC, *MAUVE, *PLUS, *MOINS, *texte = NULL; //  le pointeur va stocker la surface de la fenetre ecran
	SDL_Rect position;//definit une case
	SDL_Rect positionEcran;
	SDL_Event event;
 
	int grille[20][20]= {0},
	int continuer = 1, tailleBloc = 30, nbCol = 20, nbLignes = 20, col=0,ligne=0,i=0;
	........./.....
affichEcran(ecran, col, nbLignes-1-ligne, couleur, nbLignes);
.........../.........
}
void affichEcran (SDL_Surface* ecran, int col, int ligne, int couleur, int nbLignes)
{
}

merci à tous pour votre patience et votre dévouement sympathique

[Médinoc]

Ça, c'est typiquement un cas où je mettrais nbLignes et nbCol dans une structure aux côtés de grilleSi j'ai bien compris, couleur correspond à grille[ligne][colonne]?

Code C :

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
struct sGrille
{
	int cases[20][20];
	int nbCol;
	int nbLignes;
};
 
void affichEcran (SDL_Surface* ecran, int col, int ligne, struct sGrille* pGrille)
{
	int couleur = (*pGrille).cases[ligne][colonne];
	/*Syntaxe alternative:
	int couleur = pGrille->cases[ligne][colonne]; */
} 
 
int main(int argc, char *argv[])
{
	SDL_Surface *ecran = NULL, *VIDE, *JAUNE, *ROUGE, *BLANC, *MAUVE, *PLUS, *MOINS, *texte = NULL; // le pointeur va stocker la surface de la fenetre ecran
	SDL_Rect position;//definit une case
	SDL_Rect positionEcran;
	SDL_Event event;
 
	int continuer = 1, tailleBloc = 30, col=0, ligne=0, i=0;
	struct sGrille grille = {0};
	grille.nbCol = 20;
	grille.nbLignes = 20;
........./.....
	affichEcran(ecran, col, nbLignes-1-ligne, &grille);
.........../.........
}

Note: On peut aussi déclarer la fonction ainsi si la fonction ne modifie pas la grille pointée:

Code C :

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

1
2
void affichEcran (SDL_Surface* ecran, int col, int ligne, struct sGrille const * pGrille)
{

[Obsidian]

comme je l'ai dit, j'ai bien une solution simple, c'est de faire une variable globale, mais je lis souvent que c'est développer à l'arrache ! euh... pourquoi ?

Entre autre pour ces raisons-là : http://www.developpez.net/forums/d93...c/#post5271611

En gros, les variables globales ont une existence naturelle aussi bien sur le plan technique que sémantique et permettent de résoudre de façon simple les problèmes comme le tien. Malheureusement, à l'usage, elle introduisent une dette technique qui empêche très vite ton programme d'évoluer et de concevoir des projets plus grands. Étant donné que tu te retrouves alors obligé de te rabattre sur des solutions alternatives (par exemple un pointeur sur un contexte) qui, en plus, deviennent plus ou moins implicites dans d'autres paradigmes de programmation (exemple : le pointeur this), alors on fait en sorte de faire prendre directement les bonnes habitudes aux débutants.

les pointeurs, ça fait 20 fois que je relis le sujet et j'avoue que ça ne rentre pas.
voici quelques extraits de mon code : les definitions dans le main, l'appel de la fonction et la fonction qui reçoit l'appel : merci à tous pour votre patience et votre dévouement sympathique

Je vais jeter un pavé dans la mare mais les pointeurs, c'est facile.

Si tu n'y arrives pas, ce n'est pas parce que tu es mauvais, mais parce que le cours que tu lis ne vas probablement pas au fond des choses.

• Sais-tu ce qu'est une adresse mémoire ?
• Si tu as 59 ans, tu as peut-être fait un peu de BASIC à l'époque où c'était à la mode. As-tu déjà vu PEEK et POKE et te souviens-tu à quoi servaient ces instructions ?

[Médinoc]

Regarde bien ce code qui n'utilise pas de pointeur, et comprends-le:
Il appelle une fonction qui échange deux valeurs d'un tableau, en utilisant leurs indexes.

Code C :

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
#include <stdio.h>
 
float g_tableau[10];
 
void echange(int ixA, int ixB)
{
	float tmp = g_tableau[ixA];
	g_tableau[ixA] = g_tableau[ixB];
	g_tableau[ixB] = tmp;
}
 
int main(void)
{
	g_tableau[0] = 1.1f;
	g_tableau[1] = 2.2f;
	g_tableau[2] = 3.3f;
	g_tableau[3] = 4.4f;
 
	puts("Avant echange:");
	printf("%f\n", g_tableau[0]);
	printf("%f\n", g_tableau[1]);
	printf("%f\n", g_tableau[2]);
	printf("%f\n", g_tableau[3]);
 
	echange(1, 2);
 
	puts("Apres echange:");
	printf("%f\n", g_tableau[0]);
	printf("%f\n", g_tableau[1]);
	printf("%f\n", g_tableau[2]);
	printf("%f\n", g_tableau[3]);
	return 0;
}

Compare avec celui-ci:

Code C :

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
#include <stdio.h>
 
void echange(float* pa, float* pb)
{
	float tmp = *pa;
	*pa = *pb;
	*pb = tmp;
}
 
int main(void)
{
	float val0 = 1.1f;
	float val1 = 2.2f;
	float val2 = 3.3f;
	float val3 = 4.4f;
 
	puts("Avant echange:");
	printf("%f\n", val0);
	printf("%f\n", val1);
	printf("%f\n", val2);
	printf("%f\n", val3);
 
	echange(&val1, &val2);
 
	puts("Apres echange:");
	printf("%f\n", val0);
	printf("%f\n", val1);
	printf("%f\n", val2);
	printf("%f\n", val3);
	return 0;
}

Ça fait la même chose, sans tableau. Voilà, c'est 80% de ce qu'il y a à comprendre sur les pointeurs.

[luckyalan]

merci à tous les 4. vous m'avez tous, chacun à votre façon apporté une aide.
bon alors je vais aller regarder les structures,
par contre pour les pointeurs Obsidian, si tu peux me mettre un lien vers une explication SIMPLE, je suis preneur. oui, j'ai commencé par le basic avec peek et poke et je me souviens que cela ne me posais pas de problème, mais j'avais probablement l'esprit plus vif à l'époque ;o)

Medinoc, merci pour ton explication par l'exemple. ton illustration montre bien comment le pointeur permet de modifier le contenu de la variable envoyée par l'appel de la fonction... ce que je voudrais c'est justement ne pas surcharger mon appel de fonction par des envois de variables que je n'ai pas à modifier, mais juste à lire...
Ceci dit, ta démonstration que j'ai vérifiée en console est très pédagogique, bravo
Metalman, tu dois avoir raison, je me tracasse pour un problème qui n'en est pas un
vraiment c'est chouette sur ce forum d'avoir plusieurs réponses qui sont toutes vraies et complémentaires
Amitiés

[Sve@r]

par contre pour les pointeurs Obsidian, si tu peux me mettre un lien vers une explication SIMPLE, je suis preneur. oui,

Salut
Pourquoi seulement Obsidian ???

Cours de C

[luckyalan]

merci sve@r,
bon à vous 5 vous m'avez donné tous les éléments pour bosser et résoudre mon problème tout en avancant dans mes connaissances et ce vous en remercie
je marque donc ce sujet comme résolu, j'y reviendrai peut-être ultérieurement si j'ai besoin d'infos complémentaires
merci beaucoup à vous tous pour ce forum super

[Obsidian]

(EDIT : crosspost avec celui de Sve@r).

par contre pour les pointeurs Obsidian, si tu peux me mettre un lien vers une explication SIMPLE, je suis preneur. oui, j'ai commencé par le basic avec peek et poke et je me souviens que cela ne me posais pas de problème, mais j'avais probablement l'esprit plus vif à l'époque ;o)

Un pointeur est un objet qui en pointe un autre (comme s'il le pointait du doigt), c'est-à-dire qui en indique l'emplacement en mémoire. Si tu te souviens de PEEK et POKE, tu dois te souvenir qu'on les utilisait par exemple de cette façon : POKE &H5000,128. Le premier paramètre était le numéro de l'octet dans lequel on voulait écrire (son adresse) et le second la valeur que l'on voulait y déposer.

Ça servait à toutes sortes de choses et surtout, c'est uniquement de cette façon que travaille le micro-processeur en langage machine puisqu'il n'est relié au reste de l'ordinateur que par ses bus d'adresse et de données (même si le tout est devenu un poil plus sophistiqué aujourd'hui qu'à l'époque). Donc, le CPU ne sait que lire des données quelque part, leur appliquer un éventuel traitement arithmétique ou logique, et les réécrire ailleurs.

Par ailleurs, en BASIC comme dans les autres langages, on disposait de variables, et celles-ci s'utilisaient comme en C (à ceci près qu'elles étaient toutes globales et qu'on pouvait les déclarer n'importe où). On les manipulait en les incluant dans des expressions et définissait leur valeur avec l'opérateur d'affectation « = ». Rien de nouveau ici. Il est évident que ces variables avaient une existence quelque part en mémoire et certains BASIC proposaient VARPTR pour savoir où exactement. En temps normal, évidemment, on se moquait de savoir où elles étaient et on les manipulait normalement. Cela dit, si on faisait un POKE au bon endroit, on pouvait bien sûr modifier leur contenu et voir leur valeur changer comme par magie.

En BASIC, ce genre de procédé n'était là que pour l'exemple ou pour amuser les codeurs. Il était évident que ce n'était absolument pas une manière de faire en temps normal et que cela était en plus dangereux, dans le sens où on pouvait écraser n'importe quoi. En langage C, par contre, c'est la manière normale de procéder, en dehors de l'opérateur d'affectation. Et ceci, précisément parce que le langage C est conçu pour rester au plus proche de la machine sans avoir à contraindre le programmeur à utiliser de l'assembleur, spécifique à une architecture.

Un pointeur est donc en pratique un entier qui a exactement le format du bus d'adresse de l'architecture cible et dont on sait que le contenu est forcément une adresse, d'une part, et que cette adresse est celle d'un autre objet dont on connait le type, ce qui nous permet de le manipuler directement (sauf si ce type est inconnu a priori, auquel cas on utilise void *). J'insiste sur les mots « en pratique » car le BASIC ne faisait pas la différence. En C, même si ça reste vrai dans les faits, le programmeur n'a absolument pas besoin de savoir qu'une adresse mémoire se représente avec un entier, et l'arithmétique appliquée à ce type n'est pas la même que celles des entiers ordinaires.

Voici un programme d'exemple :

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
#include <stdio.h>
 
int main (void)
{
    int   i;        /* <- Ceci est un entier */
    int * p;        /* <- Ceci est un pointeur sur un entier */
 
    i = 5;          /* <- J'affecte la valeur "5" à i */
 
    printf ("Valeur de i             : %d\n",i);
    printf ("Adresse en mémoire de i : %p\n",&i);
 
    p = &i;         /* J'affecte à p l'adresse en mémoire de la variable i */
    *p = 10;        /* <- J'affecte la valeur "10" à l'entier pointé par p, quel qu'il soit */
 
    printf ("Nouvelle valeur de i    : %d\n",i);
 
    return 0;
}

… et à l'exécution :

Code Shell :

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

1
2
3
4
$ ./programme
Valeur de i             : 5
Adresse en mémoire de i : 0x7fffba1a0f84
Nouvelle valeur de i    : 10

… par contre, les dangers demeurent également : si tu oublies d'initialiser correctement ton pointeur ou si tu dépasses les limites, tu vas aller écrire n'importe où et découvrir les joies des segfaults parce que ce n'est pas le C qui va t'empêcher de le faire.

bon alors je vais aller regarder les structures

Si tu veux te donner à creuser, tu peux essayer de prendre le problème à l'envers : imaginons que tu travailles avec des vecteurs en trois dimensions. Chacun d'eux est défini par ses composantes x, y et z.

En te passant complètement de pointeurs et de structures, comment t'y prendrais-tu pour écrire des fonctions AdditionneVecteurs(), SoustraitVecteurs(), éventuellement pour faire leur produit et pour en stocker un grande quantité ?

[Médinoc]

Au passage, note que pointeur ne veut pas forcément dire modification.
Si tu regarde le prototype de la fonction puts(), tu verras que son paramètre est déclaré comme const char * (char const * est une écriture équivalente; char * const n'est pas équivalent du tout).

Cela veut dire que la fonction, bien que prenant un pointeur en paramètre, n'est pas censé modifier les données pointées.

[luckyalan]

je voulais juste revenir sur ce sujet pour vous remercier tous, grâce à vous j'ai compris le fonctionnement des structures et des pointeurs, et j'ai utilisé les 2.
mon programme marche
merci beaucoup
Amicalement