Chapitre 13 · Forme canonique, encapsulation & héritage

Ce qu'Objective-C faisait en coulisse — getters, setters, protected et la forme canonique C++

En Obj-C, @property (nonatomic, strong) générait automatiquement un getter, un setter, et gérait l'ARC. En C++, tu déclares explicitement ce que ton objet sait faire avec lui-même.
C'est plus verbeux — et c'est une très bonne chose.

La forme canonique C++ — Rule of 5

En Obj-C, le compilateur prenait en charge la copie, l'assignation et le cycle de vie des objets. En C++, tu exprimes ces comportements explicitement. Un objet qui gère des ressources GPU doit définir les cinq opérations suivantes :

/// C++ — Exemple — update:18/10/26
class Renderer
{
public:
  // 1. Constructeur — acquiert les ressources
  Renderer(MTL::Device* device,
           const std::string& resourcePath,
           NS::UInteger width, NS::UInteger height,
           MTL::PixelFormat colorPixelFormat, MTL::PixelFormat depthPixelFormat);

  // 2. Destructeur — libère les ressources
  ~Renderer();

  // 3 & 4. Copie — supprimée : un Renderer possède un GPU, on ne le duplique pas
  Renderer(const Renderer&)            = delete;
  Renderer& operator=(const Renderer&) = delete;

  // 5 & 6. Move — supprimé aussi : géré par std::unique_ptr dans ApplicationController
  Renderer(Renderer&&)                 = delete;
  Renderer& operator=(Renderer&&)      = delete;

  void draw(MTK::View* view, double timeStamp, float delta);
  void resizeViewWindow(NS::UInteger width, NS::UInteger height);

private:
  void update(float delta);

  MTL::Device*       m_device;
  MTL::Library*      m_shaderLibrary;
  MTL::CommandQueue* m_commandQueue;
  MTL::PixelFormat   m_pixelFormat;
  MTL::PixelFormat   m_depthPixelFormat;
};
= delete;

Est une décision explicite de conception. En déclarant la copie supprimée, tu empêches à la compilation toute tentative de dupliquer un objet qui possède des pointeurs GPU raw.
std::unique_ptr<Renderer> dans ApplicationController repose précisément sur cette garantie.

La manière propre de l'écrire : créer un fichier que tu inclus quand nécessaire.

/// C++ — NonCopyable.hpp — update:18/10/26
#ifndef NONCOPYABLE_HPP
#define NONCOPYABLE_HPP

class NonCopyable
{
public:
  NonCopyable()                              = default;
  NonCopyable(const NonCopyable&)            = delete;
  NonCopyable(NonCopyable&&)                 = delete;
  NonCopyable& operator=(const NonCopyable&) = delete;
  NonCopyable& operator=(NonCopyable&&)      = delete;
};

#endif // NONCOPYABLE_HPP
/// C++ — Renderer.hpp — update:18/10/26
#include "NonCopyable.hpp"

class Renderer : NonCopyable // Fait le job

L'Objective-C++ pointe vers ta classe, elle ne la copie pas.

Comparaison directe avec Objective-C

/// Objective-C — Exemple — update:18/10/26 — le compilateur génère tout
@interface ApplicationController : NSObject

@property (nonatomic, strong, readonly) MTKView* mtkView; // getter auto
@property (nonatomic, assign) BOOL isPaused;              // getter + setter auto

@end
/// C++ — Exemple équivalent — update:18/10/26 — tu écris ce dont tu as besoin
class Renderer
{
public:
  // getter — const, ne modifie pas l'objet
  MTL::PixelFormat getPixelFormat() const { return m_pixelFormat; }
  NS::UInteger     width()       const { return (NS::UInteger)m_viewport.width; }
  NS::UInteger     height()      const { return (NS::UInteger)m_viewport.height; }
  bool             isPaused()    const { return m_paused; }

  // setter — valide la donnée avant de l'accepter
  void setPaused(bool paused)          { m_paused = paused; }
  void setPreferredFPS(uint32_t fps)
  { // brâces obligatoires dans le header même si une seule instruction
    m_preferredFPS = (fps > 0 && fps <= 240) ? fps : 120;  // validation intégrée
  }

private:
  MTL::PixelFormat m_pixelFormat;
  MTL::Viewport    m_viewport;
  bool             m_paused       = false;
  uint32_t         m_preferredFPS = 120;
};

Un point rapide sur les équivalences ;

  1. @property (strong) → private: + constructeur + destructeur → en Obj-C, strong gérait automatiquement le retain/release via ARC. En C++, tu l'écris une fois dans le constructeur (->retain()) et une fois dans le destructeur (->release()). C'est plus d'écriture, mais tu vois exactement quand la ressource est acquise et libérée.
  2. @property (readonly) → private: membre + public: getter const → en Obj-C, readonly interdisait le setter depuis l'extérieur. En C++, l'équivalent est de mettre le membre en private et de n'exposer qu'un getter marqué const.
  3. @property (assign) → membre trivial sans gestion mémoire → types primitifs
    (BOOL, NSInteger, CGFloat) en Obj-C. Équivalent direct en C++ : bool, int, float — pas de retain, pas de release.
  4. const après la signature → float width() const — le const dit au compilateur que cette méthode ne modifie pas l'état de l'objet. Cela permet de l'appeler sur un objet const Renderer& et active des optimisations du compilateur.

L'ARC en Objective-C vs la gestion manuelle en C++

// ce que tu as écrit en Obj-C — chapitre : application
@property (nonatomic, strong, readonly) MTKView* _Nonnull mtkView;

// ce que le compilateur génère automatiquement (ARC)
- (MTKView*)mtkView               { return _mtkView; }
- (void)setMtkView:(MTKView*)view { [_mtkView release]; _mtkView = [view retain]; }
// Ce que tu écris en C++ dans le constructeur de Renderer
Renderer(MTL::Device* device,
           const std::string& resourcePath,
           NS::UInteger width, NS::UInteger height,
           MTL::PixelFormat colorPixelFormat, MTL::PixelFormat depthPixelFormat)
: m_device(device->retain()),             // retain explicite — tu possèdes le device
  m_commandQueue(m_device->newCommandQueue()),
  m_shaderLibrary(m_device->newDefaultLibrary())
{}

Renderer::~Renderer()
{
    m_shaderLibrary->release();           // release dans l'ordre inverse
    m_commandQueue->release();
    m_device->release();
}
L'ordre du destructeur est important : libère dans l'ordre inverse de la construction. m_shaderLibrary a été créée depuis m_device, donc elle doit partir avant. Libérer le device en premier alors qu'un objet qui en dépend existe encore est un crash silencieux ou un comportement indéfini.

Visibilité : private / protected / public

/*
 *  En Obj-C, l'encapsulation était optionnelle :
 *
 *  @public   → accessible partout (rare, déconseillé)
 *  @protected → accessible dans la classe et ses sous-classes
 *  @private  → accessible dans la classe seulement (par défaut)
 *
 *  La vraie encapsulation se faisait via les @property et
 *  les extensions de classe (@interface Foo ()).
 */
// En C++ — déclaré explicitement dans la classe
class Renderer
{
public:
    // Accessible depuis n'importe où — interface publique
    void draw(MTK::View* view, double timeStamp, float delta);
    void resizeViewAndUpdateViewportWindow(NS::UInteger width, NS::UInteger height);

protected:
    // Accessible dans Renderer ET ses sous-classes — pas depuis l'extérieur
    MTL::Device*        m_device;
    MTL::CommandQueue*  m_commandQueue;
    MTL::Library*       m_shaderLibrary;
    MTL::Viewport       m_viewport;
    MTL::PixelFormat    m_pixelFormat;

private:
    // Accessible uniquement dans Renderer — détail d'implémentation
    uint64_t            m_frame         = 0;
    uint32_t            m_frameIndexBuffer = 0;
    bool               m_paused         = false;
};

protected en pratique — l'héritage de renderer

La vraie utilité de protected apparaît quand tu veux spécialiser le renderer selon la technique de rendu :

/*
 *  Hiérarchie de renderers
 *
 *             Renderer          ← base commune, protected: device, commandQueue
 *                │
 *        ┌───────┴───────┐
 *  ForwardRenderer   DeferredRenderer   ← accès à protected, pas à private
 */

class ForwardRenderer : public Renderer
{
public:
    ForwardRenderer(MTL::Device* device,
                    const std::string& resourcePath,
                    NS::UInteger width, NS::UInteger height,
                    MTL::PixelFormat colorPixelFormat,
                    MTL::PixelFormat depthPixelFormat);

    void draw(MTK::View* view, double timeStamp, float delta) override;

private:
    MTL::RenderPipelineState*   m_pipelineState;    // spécifique au forward
    MTL::DepthStencilState*     m_depthStencilState;
};

void ForwardRenderer::draw(MTK::View* view, double timeStamp, float delta)
{
    // m_device        ✓ protected → accessible depuis ForwardRenderer
    // m_commandQueue  ✓ protected → accessible depuis ForwardRenderer
    // m_frame         ✗ private  → erreur de compilation

    auto* commandBuffer = m_commandQueue->commandBuffer();
    auto* rpd           = view->currentRenderPassDescriptor();
    auto* enc           = commandBuffer->renderCommandEncoder(rpd);

    enc->setViewport(m_viewport);                          // ✓ protected
    enc->setRenderPipelineState(m_pipelineState);          // ✓ private de ForwardRenderer
    enc->setDepthStencilState(m_depthStencilState);
    enc->endEncoding();

    commandBuffer->presentDrawable(view->currentDrawable());
    commandBuffer->commit();
}

Récapitulatif des trois niveaux ;

  1. public → interface que tu exposes au monde. draw(), resize(), getters. ApplicationController appelle ces méthodes directement via le unique_ptr<Renderer>.
  2. protected → ressources GPU partagées entre le renderer de base et ses spécialisations : m_device, m_commandQueue, m_shaderLibrary, m_viewport. Pas de setter nécessaire — les sous-classes les partagent mais ne les remplacent pas.
  3. private → état interne pur : compteur de frames, flags de pause, index de triple buffering. Aucune sous-classe n'a de raison légitime d'y toucher directement.
/*
 *  Tableau de correspondance Obj-C → C++
 *
 *  Obj-C                          C++
 *  ────────────────────────────────────────────────────────
 *  @property (strong)            private: T* m_x; + constructeur/destructeur
 *  @property (weak)              private: T* m_x; (pas de retain/release)
 *  @property (readonly)          private: T m_x; + public: T x() const;
 *  @property (copy) NSString*    private: std::string m_x;
 *  @public                       public:
 *  @protected                    protected:
 *  @private (défaut @impl)       private: (défaut class)
 *  alloc/init                    constructeur
 *  dealloc                       destructeur
 *  ARC retain/release            ->retain() / ->release() + Rule of 5
 *  NSNotification delegate       virtual void onEvent() = 0; (interface)
 */
struct vs class en C++

La seule différence entre struct et class en C++ est la visibilité par défaut : struct démarre en public:, class démarre en private:.

Convention dans ce projet : struct pour les données pures sans logique (SceneUniforms, VertexIn, …), class pour les objets avec comportement et ressources (Renderer, ZoneWT, …).

POO

La Programmation Orienté Objet en détails — les bonnes décisions

Ce chapitre utilise la classe Camera comme fil conducteur. Elle est représentative d'un code C++ moderne : encapsulation stricte, const-correctness, cache paresseux, transitions animées.

1 — La classe

Une classe regroupe des données (membres) et les fonctions qui les manipulent (méthodes). Elle est le building block de la POO en C++.

/// C++ — Exemple — update:19/10/26
class Camera
{
public:
    Camera();
    ~Camera();

    simd::float3 position() const;
    void setAspectRatio(float aspect);

private: // données internes, inaccessibles de l'extérieur
    simd::float3 m_up;
    simd::float3 m_position;
    simd::float3 m_direction;
    float        m_aspectRatio;
};

void Camera::setAspectRatio(float aspect)
{
    m_aspectRatio = aspect;
    m_needRebuild = true;
}

#endif /* Camera_hpp */

En C++, la seule différence entre struct et class est l'accessibilité par défaut : public pour struct, private pour class.

Par convention, struct est utilisé pour les agrégats de données pures sans invariants à protéger.

2 — Encapsulation : public / private

L'encapsulation protège l'état interne. On expose une interface propre et on cache les détails d'implémentation :

/// C++ — Exemple — update:19/10/2026
public:
    // interface publique — stable, documentée
    simd::float3   position()  const;
    simd::float4x4 viewMatrix() const;
    void           setPosition(simd::float3 newPosition);

private:
    // état interne — personne n'y touche directement
    simd::float3   _position;
    simd::float3   _direction;
    bool           _uniformsDirty;
    CameraUniforms _uniforms;

    // helpers internes — pas dans l'interface
    void orthogonalizeFromNewForward(simd::float3 newForward);
    void updateOrbitPosition();
};

updateOrbitPosition() est private : c'est un détail d'implémentation. L'appelant n'a pas à savoir que l'orbit recalcule la position — il appelle juste orbit().

Règle pratique
Tout ce qui peut changer sans casser le code appelant → private. Tout ce qui fait partie du contrat de la classe → public. En cas de doute, commence par private.

4 — const : méthodes en lecture seule

Une méthode marquée const garantit qu'elle ne modifie pas l'état de l'objet. Elle peut être appelée sur un objet const ou une référence const&.

// ✅ const : lecture seule, appelable sur const Camera&
simd::float3 Camera::position()  const { return _position; }
simd::float3 Camera::forward()   const { return _direction; }
float        Camera::nearPlane() const { return _nearPlane; }
bool         Camera::isOrbitMode() const { return _orbitMode; }

// ❌ pas const : modifie _position, _uniformsDirty
void Camera::setPosition(simd::float3 v)
{
    _position      = v;
    _uniformsDirty = true;
}
Règle pratique
Tout getter, toute méthode de requête, tout snapshot → const. Si tu hésites, demande-toi : "est-ce que cet appel peut changer ce que renvoie un autre appel ?" Si non → const.

Const en paramètre

const s'applique aussi aux paramètres. Passer un objet par const& évite la copie et garantit qu'on ne le modifie pas :

// 'snap' est passé par const référence : pas de copie, pas de modification
void Camera::applySnapshot(const CameraSnapshot& snap)
{
    _position  = snap.position;
    _direction = snap.direction;
    // …
    _uniformsDirty = true;
}

// 'other' est const : on ne peut appeler que ses méthodes const
void Camera::transitionTo(const Camera& other, float duration, /* … */)
{
    transitionTo(other.snapshot(), duration); // snapshot() doit être const
}

5 — mutable : cache dans un objet const

mutable est le seul mot-clé qui permet de modifier un membre depuis une méthode const. Il sert exclusivement pour les caches : des données dérivées recalculées à la demande, qui ne font pas partie de l'état logique de l'objet.

Dans Camera, les matrices view/projection sont dérivées de la position, direction, fov… Elles ne sont pas l'état — elles en sont la conséquence calculée.

class Camera
{
private:
    // état logique — modifiable seulement depuis les méthodes non-const
    simd::float3 _position;
    float        _viewAngle;

    // cache dérivé — modifiable même depuis une méthode const
    mutable bool               _uniformsDirty;
    mutable CameraUniforms _uniforms;
};
// Peut être const car elle ne touche qu'aux membres mutable
void Camera::updateUniforms() const
{
    _uniforms.viewMatrix = sInvMatrixLookat(_position + _shakeOffset,
                                            _position + _shakeOffset + _direction, _up);
    // … calcul des matrices …
    _uniformsDirty = false;  // ✅ OK : _uniformsDirty est mutable
}

CameraUniforms Camera::uniforms() const
{
    if (_uniformsDirty)
        updateUniforms();    // ✅ appel d'une méthode const sur *this const
    return _uniforms;
}
mutable n'est pas une excuse pour contourner const. Il est réservé aux caches et aux membres de synchronisation (mutex). Modifier de l'état logique depuis une méthode const via mutable est un bug de design.
// Utilisation — le compilateur rejette toute confusion de type
camera.transitionTo(snap, 1.5f, CameraEase::EaseInOutCubic);

// switch exhaustif — le compilateur avertit si un cas manque
float Camera::applyEase(float t, CameraEase ease) const
{
    switch (ease)
    {
        case CameraEase::Linear:       return t;
        case CameraEase::SmoothStep:   return t * t * (3.0f - 2.0f * t);
        case CameraEase::EaseInQuad:   return t * t;
        case CameraEase::EaseOutQuad:  return t * (2.0f - t);
        // …
    }
    return t;
}

En C++, la seule différence entre struct et class est l'accessibilité par défaut : public pour struct, private pour class.

Par convention, struct est utilisé pour les agrégats de données pures sans invariants à protéger.

public / private → encapsuler l'état, exposer une interface stable. Les helpers internes (updateOrbitPosition) restent private.
const méthode → garantit la lecture seule. Permet l'appel sur const Camera&.
mutable → réservé aux caches. Permet de modifier un membre depuis une méthode const sans trahir le contrat.
enum class → type énuméré fortement typé. Pas de conversion implicite, pas de collision de noms.