Struct vs Class

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy — leçon 37 sur 104.

En C++, struct et class sont presque identiques. Les deux peuvent avoir des variables membres, des fonctions membres, des constructeurs et supporter l'héritage. La seule différence est leur niveau d'accès par défaut.

Dans une class, les membres sont privés par défaut. Dans une struct, les membres sont publics par défaut :

struct Point {
    int x;    // public par défaut
    int y;    // public par défaut
};

class Circle {
    double radius;    // privé par défaut
    
public:
    double getRadius() { return radius; }
};

Cela s'applique également à l'héritage. Une structure (struct) hérite publiquement par défaut, tandis qu'une classe (class) hérite de manière privée :

struct DerivedStruct : Base {};    // héritage public
class DerivedClass : Base {};      // héritage privé

Au-delà de ces valeurs par défaut, il n'y a aucune différence technique. Cependant, la convention est importante.

La plupart des programmeurs C++ utilisent struct pour de simples conteneurs de données avec des membres publics (comme une coordonnée ou une configuration), et class lorsque l'encapsulation et le comportement sont importants. Suivre cette convention rend l'intention de votre code plus claire pour les autres développeurs.

Défi

Facile

Construisons un système de configuration simple qui démontre quand utiliser struct par rapport à class selon les conventions C++. Vous allez créer une struct pour des données simples destinées à être librement accessibles, et une class pour des données nécessitant une encapsulation et un accès contrôlé.

Vous allez créer deux fichiers pour organiser votre code :

Config.h : Définissez à la fois une structure et une classe qui représentent différents types de données de configuration.
Tout d'abord, créez une struct appelée Dimensions — un simple conteneur de données pour la largeur (width) et la hauteur (height) (toutes deux de type int). Comme les structures ont des membres publics par défaut, ceux-ci doivent être directement accessibles sans getters. Incluez une méthode area() qui retourne le produit de la largeur et de la hauteur.

Ensuite, créez une class appelée AppConfig qui gère les paramètres de l'application avec une encapsulation appropriée. Elle doit stocker un nom d'application (string) et un objet Dimensions pour la taille de la fenêtre. Comme les membres d'une classe sont privés par défaut, vous devrez rendre explicitement votre interface publique accessible. Fournissez :
- Un constructeur qui prend le nom de l'application, la largeur et la hauteur
- Un getter getAppName() qui retourne le nom
- Un getter getWindowSize() qui retourne les Dimensions
- Une méthode displayConfig() qui affiche : "App: <name>, Window: <width>x<height>, Area: <area>"
main.cpp : Démontrez la différence entre l'utilisation d'une structure et d'une classe. Lisez un nom d'application, une largeur et une hauteur à partir de l'entrée (trois lignes distinctes), puis :
- Créez une struct Dimensions directement avec les valeurs de largeur et de hauteur — accédez directement à ses membres pour afficher : "Direct struct access: <width> x <height>"
- Créez un objet AppConfig avec les trois valeurs
- Appelez displayConfig() pour afficher la configuration complète
- Utilisez le getter pour récupérer les dimensions de la fenêtre et affichez : "Via getter - Area: <area>"

Ce défi met en évidence la convention suivante : utilisez struct lorsque vous avez des données simples et transparentes (comme des coordonnées ou des dimensions), et utilisez class lorsque vous souhaitez contrôler l'accès et ajouter un comportement autour de vos données.

Convertissez les entrées de largeur et de hauteur de chaînes de caractères en entiers en utilisant std::stoi(). N'oubliez pas les gardes d'inclusion (header guards) dans votre fichier d'en-tête.

Aide-mémoire

En C++, struct et class sont presque identiques, avec une différence clé : leur niveau d'accès par défaut.

Dans une struct, les membres sont publics par défaut :

struct Point {
    int x;    // public par défaut
    int y;    // public par défaut
};

Dans une class, les membres sont privés par défaut :

class Circle {
    double radius;    // privé par défaut
    
public:
    double getRadius() { return radius; }
};

Cela s'applique également à l'héritage :

struct DerivedStruct : Base {};    // héritage public par défaut
class DerivedClass : Base {};      // héritage privé par défaut

Convention : Utilisez struct pour les conteneurs de données simples avec des membres publics, et class lorsque l'encapsulation et le comportement sont importants.

Essayez vous-même

#include <iostream>
#include <string>
#include "Config.h"

using namespace std;

int main() {
    // Lire l'entrée
    string appName;
    string widthStr;
    string heightStr;
    
    getline(cin, appName);
    getline(cin, widthStr);
    getline(cin, heightStr);
    
    int width = stoi(widthStr);
    int height = stoi(heightStr);
    
    // TODO: Créer une struct Dimensions avec width et height
    // Accéder directement à ses membres pour afficher : "Direct struct access: <width> x <height>"
    
    // TODO: Créer un objet AppConfig avec appName, width et height
    
    // TODO: Appeler displayConfig() sur l'objet AppConfig
    
    // TODO: Utiliser le getter getWindowSize() pour obtenir les dimensions et afficher : "Via getter - Area: <area>"
    
    return 0;
}