Apprendre à programmer les pointeurs en C et en C++

Version imprimable

27/02/2016, 21h12
Community Management

Apprendre à programmer les pointeurs en C et en C++

Chers membres du club,
je vous présente ce tutoriel de CGi pour apprendre à programmer les pointeurs en C et en C++.

Citation:

Les pointeurs vous harcèlent, vous hantent, vous terrorisent, ce tutoriel est fait pour vous. Il a pour but d'aider les débutants en C et C++ à aborder les pointeurs avec le moins d'appréhension possible. Avant de rentrer dans le vif du sujet, nous ferons un rappel sur la définition d'une variable.

Bonne lecture ;)
28/02/2016, 06h56
Luc Hermitte

L’appellation C/C++ est malheureuse. :(

Sinon, ce tuto de 2005 ne fait qu'effleurer le côté C++ des pointeurs. Sans parler des dernières directions prises avec les CppCoreGuidelines, et le C++17 en préparation, qui poussent vers l'emploi de types tels que span/string_view/... pour faire circuler des tableaux à la C (pointeur + taille), il eut-été intéressant de noter que le C++ permet d'avoir des fonctions qui n'acceptent que des tableaux (statiques) et qui refusent des pointeurs. C'est d'ailleurs un des angles d'attaque de Dan Saks lorsqu'il veut vanter les avantages du C++.

i.e. la fonction suivante accepte uniquement des tableaux de 10 éléments exactement, et pas des pointeurs. Si on veut pouvoir reconnaitre la taille automatiquement, il faut passer par des templates.

Code:

int max(int (&tab)[10])

Après, on ne préfère pas vraiment utiliser new et delete en C++, on préfère les cacher derrière des capsules RAII -- pour ne jamais appeler delete/free/fclose/unlock/... (ailleurs que dans des destructeurs) -- comme std::vector<>, std::auto_ptr<>, boost::scoped_ptr<>, boost::shared_ptr<> à l'époque du tuto, std::array, std::unique_ptr<> et std::shared_ptr<> aujourd'hui. Voire aussi gsl::owner<> et gsl::not_null<> si on veut suivre les recommandations des CppCoreGuidelines. En C++14, on va pouvoir pousser le vice jusqu'à s'interdire toute utilisation explicite de new grâce à std::make_unique() -- oui, oui il y a bien un intérêt en termes de robustesse des programmes produits.

PS: pour afficher la valeur d'un pointeur en C, on est censés caster le pointeur en void*: http://www.developpez.net/forums/d47...s/#post2832109 -> printf ("%p", (void*)&x);
29/02/2016, 10h16
stendhal666
Dans la lignée de ce que dit Luc Lhermitte, il y a quelques pointeurs particulièrement flippants en C++, comme les pointeurs sur les fonctions membres d'une classe, qui ne sont pas évoqués.
Il manque, mais c'est vrai aussi pour C, les syntaxes pour les tableaux de pointeurs et les pointeurs sur les tableaux statiques à plusieurs dimensions. De même il manque les notions sur les pointeurs constants, les pointeurs sur variables constantes, et les pointeurs constants sur des variables constantes.
Pour le C++, on peut aussi mentionner le mot-clé auto qui peut éviter de pétocher pour les types compliqués. Ainsi:
Code:

1 2 int(*pmax)(int*, int); pmax = max;
devient:

Code:

auto pmax = max;

Peut-être pour les débutants faudrait-il également un rappel sur:
Code:

1 2 int* i, j; // déclare un pointeur sur int et un int int *i, *j // décalre deux pointeurs sur int
29/02/2016, 15h27
Luc Hermitte

Disons que pour les pointeurs de fonction membre, c'est comme pour new/delete, on va leur préférer autre chose: std::function en C++11, et boost::function avant -- ou équivalents.
Il y a tellement de choses que c'est vite difficile d'être exhaustif, surtout si on veut couvrir un large panel de public: C, C++, débutant, développeur lambda (ou average Joe en VO), avancé, etc.

C'est un tuto sur les pointeurs en C et encore ... il manques quelques notions très utile.
Le peu que l'on voit sur le C++ est trop incomplet, (et je ne parle pas de C++17 )

Je vais me concentrer sur le partie "C" du tuto.

Il y fait un rapprochement entre le type tableau et le type pointeur.
Mais ils ont des différences !
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 int tab[10]={1,9,8,7,6,3,5,4,2,0}; int* pTab=tab; printf("%x\n",tab); printf("%x\n",&tab); printf("---------\n"); printf("%x\n",pTab); printf("%x\n",&pTab); printf("---------\n"); printf("%u\n",sizeof(tab)); printf("%u\n",sizeof(pTab)); tab++;//erreur compilation pTab++;//ok on décale le pointeur d'une case /* ff937b8c ff937b8c --------- ff937b8c ff937b88 --------- 40 4 */
et encore, on parle du passage de pointeur dans les fonctions sans montrer le soucis du passage par recopie ( dans le cas de l’échange par exemple )
Du coup ça fait : il faut des pointeur PARCE QUE !
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 mettreMajuscule(char* str) { *str='M'; } int main() { char str[]="ma super phrase !"; //remplacer <<char str[]>> par <<char* str>> et executer cette horreur ! mettreMajuscule(str); printf("%s",str); return 0; }
et au niveau du mot clef const ce sera montré plus tard ?
faire la différence entre

Type*
const Type*
Type const*
Type *const
etc...

voir pour aller plus loin...
Expliquer au niveau de la sécurité ce que peut donner un dépassement de tableau
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 <stdio.h> #include <string.h> typedef struct Perso { char name[4]; int nbVie; }Perso; void afficherPerso(const Perso* p) { printf("nom =%s , nbVie=%d",p->name,p->nbVie); } void changerNom(Perso* p,const char* nom) { strcpy(p->name,nom); } int main() { Perso p; p.nbVie=1; changerNom(&p,"bob_0000");//pour faire simple afficherPerso(&p); return 0; } /* nom =bob_0000 , nbVie=808464432 */
Bon après est-ce moi qui suis trop exigent ?

Propreté...

Je cite:

Code:

1
2
3
4
5
6
7
8
9
int max(int *tab, int n) 
{
  int x;
  int nmax;
  nmax = 0;
  for(x=0; x<n; x++)
    if(tab[x]>nmax) nmax=tab[x];
       return nmax;
}

Vous voulez dire:

Code:

1
2
3
4
5
6
7
8
9
int max(int *tab, int n) 
{
  int x;
  int nmax;
  nmax = 0;
  for(x=0; x<n; x++)
    if(tab[x]>nmax) nmax=tab[x];
  return nmax;
}

On a l'impression que le return est dans la boucle.