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;
};
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 ;
- @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.
- @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.
- @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. - 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();
}
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 ;
- public
→ interface que tu exposes au monde. draw(), resize(), getters. ApplicationController appelle ces méthodes directement via le unique_ptr<Renderer>. - 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. - 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)
*/
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().
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;
}
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.