Programmation C++/Les structures

Programmation C++

• Avant-propos
• Introduction
• Compilation
• Un premier programme
• Les commentaires
• Le préprocesseur
• Les types de base et les déclarations
  • Exercices
• Les opérations de base
• Les entrées-sorties
• Les pointeurs
  • Exercices
• Les références
• Les tableaux
  • Exercices
  • Exercices sur les tableaux statiques
  • Exercice : Tris des tableaux à une dimension
  • Solution : Tris des tableaux à une dimension
• Les structures de contrôle
  • Exercices
  • Exercices if...else et switch
• Les fonctions
  • Exercices
• Les structures
  • Exercices
• Les classes
  • Exercices
  • Exercices de développement
• Les espaces de noms
• Les exceptions
• Les templates
  • Exercices
• Conventions d'appel
• Les fichiers
• La librairie standard
• Expressions rationnelles
• Interfaces graphiques
• Bibliographie et liens

Annexes

• Dessiner des formes : les bibliothèques graphiques

Anciennes pages

• Opérateurs
• Héritage
• Polymorphisme

Les structures

Présentation

Les structures permettent de regrouper plusieurs variables dans une même entité. Ainsi il est possible de construire de nouveaux types plus complexes.

Syntaxe

struct identificateur
{
    // liste des différents champs constituant notre structure
    // utilise la même syntaxe que la déclaration de variables
} [variables];

identificateur identifie le nouveau type de données. Une variable de ce type est donc précédé de struct identificateur ou identificateur car le mot struct est optionnel.

[variables] est optionnel et permet de déclarer une ou plusieurs variables de ce nouveau type.

Exemple

L'exemple ci-dessous illustre l'utilisation d'une structure nommée Point comportant deux champs (appelées également variables membres) x et y de type double.

#include <iostream>
#include<cmath>
using namespace std;

struct Point
{
    double x;       
    double y; 
};

int main()
{
    Point A, B;
    double dx, dy, distance;
 
    cout << "Tapez l'abscisse de A : "; cin >> A.x;
    cout << "Tapez l'ordonnée de A : "; cin >> A.y;
    cout << "Tapez l'abscisse de B : "; cin >> B.x;
    cout << "Tapez l'ordonnée de B : "; cin >> B.y;
 
    dx = A.x - B.x;
    dy = A.y - B.y;
    distance = sqrt( dx*dx + dy*dy );
   
    cout << "La distance AB vaut : " << distance << endl;
 
    return 0;
}

Les variables A et B sont deux structures de type Point. L'accés à un champ d'une structure se fait par l'opérateur point ( . ) séparant la variable structure du nom du membre accédé.

Pointeur vers une structure

On peut écrire naturellement

    Point* pA;
    cout << "Tapez l'abscisse de A : "; cin >> (*pA).x;
    cout << "Tapez l'ordonnée de A : "; cin >> (*pA).y;

Pour faciliter la lecture et éviter les erreurs, on utilise l'opérateur ->. On peut écrire pA->x à la place de (*pA).x. Attention, *pA.x donne une erreur de compilation, à cause de la priorité des opérateurs.