C++
Articoli sul C++: dai fondamenti pragmatici del linguaggio e dai tipi regolari alle prestazioni a basso livello, al comportamento della cache e ai trucchi «anormali» del compilatore.
- C++
Guida sul campo a EASTL
La seconda parte della guida alle librerie «standard» altrui, ora su EASTL di Electronic Arts: allocatori-oggetto con stato e flag, container fixed e intrusive, sorted vector e reset() per la memoria scratch — e come queste idee siano arrivate nello standard.
- C++
Finiremo tutti lì…
Ogni motore di gioco attraversa quattro fasi — da «tutto è un oggetto» e un GameObject divino, passando per componenti e config, fino al proprio linguaggio di scripting, e poi il cerchio si chiude. Perché il data-driven non è affatto inevitabile e quale sia il motore più costoso del settore che conviene buttare piuttosto che riparare.
- C++
Cosa fanno davvero new e delete
In cosa le espressioni new/delete del C++ differiscono da malloc/free: chiamate a costruttori e distruttori, operator new/delete e il lavoro con la memoria grezza — con un'analisi dell'assembly.
- C++
Come funziona una vtable
Come un compilatore C++ implementa le funzioni virtuali: il vptr nascosto, la vtable e il dispatch dinamico — con un'implementazione fatta a mano usando puntatori a funzione.
- C++
I container associativi della STL
I container associativi della STL: set, map, multiset e multimap — in cosa differiscono, quando le chiavi sono uniche e quando si ripetono, con brevi esempi.
- C++
Heap vs stack: i compromessi
Heap vs stack: determinismo, frammentazione, dimensione del binario e footprint di memoria — perché nei giochi e sulle console conviene ridurre al minimo l'heap.
- C++
Il peggior linguaggio di programmazione di tutti i tempi /s
Perché il C++ viene criticato: lo zoo delle inizializzazioni, parole chiave che mentono, decine di tipi interi, una libreria standard non standard, errori dei template illeggibili e astrazioni non proprio a costo zero. E perché tutto converge in un unico punto — la retrocompatibilità a costo di tutto.
- C++
Comprimere una megalopoli fino alle dimensioni di un iPhone 4
Il ventre ingegneristico di SimCity BuildIt mobile: come un city builder desktop è stato stipato nei 100–300 MB di RAM di un iPhone — un'economia server-authoritative a timer, un client-terminale «stupido», batching aggressivo, un renderer TBDR con settori di anteprima, una simulazione svuotata con ingorghi fatti di sprite e l'elettricità come Capacità − Domanda. Più la storia dello studio di San Pietroburgo EA SPB.
- C++
Guida sul campo alle STL degli altri
Un giro tra le librerie C++ «standard» alternative di studi di gioco e grandi aziende: EASTL e le sue best practice, LLVM SmallVector/DenseMap, Folly e l'anatomia di fbstring (SSO, COW e l'accoppiata con jemalloc), boost flat_map, i container serializzabili di Zmeya e il value-oriented programming di Adobe — perché è nata ciascuna e dove ci si può far male.
- C++
C++101 (Parte 1)
Un catalogo di circa 100 idiomi e tecniche del C++ nato dalla serie Game++. Parte 1: risorse e compilazione — RAII, scope guard, copy-and-swap, smart pointer, copy-on-write, Pimpl, interface class, include/inline/export guard, CRTP, Barton-Nackman, EBO e metafunzioni.
- C++
C++101 (Parte 2)
Parte 2: metaprogrammazione e template — traits, tag dispatching, int-to-type, type selection, SFINAE ed enable-if, member detector, policy-based design, type erasure, thin template, named template parameters, expression templates e result_of, più named constructors e base-from-member.
- C++
C++101 (Parte 3)
Parte 3: inizializzazione, polimorfismo e container — chiamare funzioni virtuali durante l'init, NVI e thread-safe interface, acyclic visitor, tipi di ritorno covarianti, virtual friend function, gerarchia algebrica, tipi valore polimorfici, funtori, iterator pair, generic container, erase-remove, safe bool e attorney-client.
- C++
C++101 (Parte 4)
Parte 4: amicizia, memoria degli oggetti e C++ moderno — non-member non-friend, SOO/SSO, vietare l'heap, execute-around pointer, temporary proxy, nullptr, move constructor, boost mutant, deprecate and delete, function poisoning, rule of zero/three/five, most vexing parse, pass-key e l'operatore spaceship.
- C++
Come la GUI dei giochi viene riscritta (Parte 2)
Il seguito: l'architettura della UI di gioco lungo sei assi indipendenti — posizionamento rispetto al mondo (diegetica / HUD / meta / spaziale / narrativa, da Metroid Prime e Dead Space a Spec Ops e Hellblade), funzione, rappresentazione in memoria (scene graph, lista piatta, immediate mode, ECS), flusso dei dati (MVC/MVVM, reattivo, unidirezionale), layout (constraint, flexbox, anchors, RIMD) e rendering (canvas, layer, SDF, GPU-driven). Parte 2.
- C++
Perché la GUI dei giochi viene riscritta (Parte 1)
L'architettura della UI di gioco e perché viene riscritta da un progetto all'altro: un albero di controlli come Composite, proprietà con reflection, il disaccoppiamento dal codice di gioco tramite binding, template prototipo molto prima dei Prefab di Unity, tre livelli di handler, hit testing basato sulle forme, messaggi sincroni, layout e 9-slice, coordinate intere, un Bridge sopra il renderer, stili come CSS, il dolore della localizzazione, font SDF e UI diegetica (Dead Space, Doom, Metro). Parte 1.
- C++
Il resource manager
Perché un resource manager non è un singleton ma un intero sottosistema del motore: l'identità di una risorsa come coppia (sorgente + parametri), una cache con riferimenti deboli e LRU, parametri espliciti e impliciti, reload mirato e hot-reload, il ripristino dopo il device lost dai pool di D3D9 a DX12/Vulkan, una base template condivisa per i manager e il cambio delle impostazioni grafiche senza riavvio — con esempi da Unreal, Unity, Source, id Tech, Godot, No Man's Sky e Cyberpunk.
- C++
Compromessi architetturali nello sviluppo di videogiochi
Una grande analisi dei pattern architetturali e dei compromessi nel gamedev: layer, metalayer, sottosistemi, pipes & filters, microkernel e blackboard con esempi da Source, CryEngine, Unreal, id Tech e Naughty Dog; strategie di design, l'asse push vs pull, i linguaggi di scripting e il ripensamento dei GoF nel C++ moderno dei giochi.
- C++
Lo using disobbediente
Perché using namespace e l'ADL rendono imprevedibile il name lookup in C++: argument-dependent lookup e operator<<, il dirottamento di std con un sostituto locale, la verifica della viability delle funzioni, i ranghi delle conversioni implicite e perché le funzioni =delete partecipano alla risoluzione degli overload come candidati a pieno titolo.
- C++
Il name lookup semplice in C++
Il lookup dei nomi semplice (unqualified) e qualificato in C++: come convivono un namespace e una variabile locale con lo stesso nome, il nascondimento di nomi e di interi overload set nell'ereditarietà, l'ambiguità dell'ereditarietà a diamante, la regola dello using-namespace nel qualified lookup e le differenze storiche tra GCC, Clang e MSVC.
- C++
Anche i compilatori si confondono con i nomi
Il name lookup in C++: identificatori, unqualified-id, qualified-id, template-id e il «nome terminale», la storia dell'ADL (Koenig lookup), il two-phase lookup nei template e perché GCC, Clang e MSVC si sono storicamente comportati in modo diverso.
- C++
Calcoli ridondanti
Come l'esecuzione speculativa e la branch prediction interagiscono con il sottosistema di memoria: perché il codice branchless non è sempre più veloce, il costo di una misprediction rispetto alla latenza della memoria, la ricerca binaria e benchmark sul Jaguar (PS4).
- C++
Miti, superstizioni e saggezza popolare nello sviluppo di giochi
Un'analisi di 12 «verità» comuni del C++ nel gamedev — quali sono miti, quali superstizioni e quali saggezza popolare: il culto del C puro, la «cattiva build buona», il costo di eccezioni e RTTI, smart pointer e container STL, il polimorfismo, l'assembly inline, il template bloat, l'ottimizzazione prematura e la maledizione del commit del venerdì.
- C++
Uno zoo di stringhe nel tuo codice C++?
Un grande tour dei tipi di stringa del C++ come uno zoo di animali: char* e char[N], letterali stringa, std::string e SSO, string_view, pmr::string, QString, NSString, std::wstring, stringhe di frame, la FString di Unreal, StringAtom e interning, stringhe COW e StringID basati su hash — e dove ciascuno trova posto nei motori di gioco.
- C++
Il buono, il brutto, il colorato e il veloce
Allocatori di memoria anormali dalla pratica: un allocatore che traccia i lifetime per dare la caccia ai leak, un allocatore randomizzante (chaos) per lo stress test dei sistemi a lunga esecuzione, un allocatore «colorato» per l'isolamento dei sottosistemi (Deathloop) e il veloce TLSF — con diagrammi e un benchmark in cicli di CPU.
- C++
Sii il tuo breakpoint
Come funzionano i breakpoint software e hardware: sostituire un byte con int 3 (0xCC), i registri di debug x86-64 DR0–DR7 e il layout di DR7, breakpoint condizionali, su funzione e temporanei, un watchpoint in scrittura via GetThreadContext, un canary per il buffer e un pulsante per i breakpoint hardware direttamente in un editor di gioco ImGui.
- C++
Respingo i commit che usano l'heap e chiedo ai colleghi di riscrivere quella logica
L'esperienza di costruire grandi giochi C++ senza heap: perché le allocazioni dinamiche sono pericolose su console e mobile (frammentazione, degrado dei tempi di malloc, un rifiuto in certificazione) e con cosa sostituirle — container a dimensione fissa gtl::vector<T,N>, etl/FastDelegate al posto di std::function, CRTP e polimorfismo statico con std::variant, object pool e placement new.
- C++
Game++. Trappole di prestazioni
Il finale della serie Game++: le trappole di prestazioni più comuni in C++ — allocazioni inutili, la RVO traditrice, un callback std::function pesante, identificatori stringa costosi, un seno approssimato, la lenta divisione intera, il costo dei cache miss, std::pair/tuple e il prezzo della virtualità nelle strutture matematiche — con benchmark su quick-bench e storie dalla produzione.
- C++
Game++. while (!game(over))
Vale la pena scrivere il proprio motore di gioco: perché e se serve, cos'è davvero un motore e cosa fa — il game loop, l'input, la grafica, gli asset, l'audio, la fisica, script e config, il networking, l'IA, la UI e l'architettura (approccio a libreria, GodObject, ECS), più il tooling — con codice, link a librerie ed esperienza personale.
- C++
Game++. Pattern rattoppati
I design pattern nei giochi: cosa sopravvive del «libro blu» dei GoF e quali hanno attecchito proprio nel gamedev — Command, State e FSM con uno stack pushdown, Flyweight e instancing, Observer ed EventBus, Dirty Flag, Update Layers e GOAP — con codice, diagrammi e casi d'uso.
- C++
Game++. Work hard
I modelli di concorrenza nei motori di gioco: stato shared/separate/shadow, worker e thread pool, worker stateless (Assassin's Creed, Factorio), catene di worker e IO non bloccante, le fiber di Naughty Dog e la libreria marl — con diagrammi, codice e benchmark di caricamento.
- C++
Game++. Heap? Less
Come i giochi si liberano delle allocazioni sull'heap: le cinque regioni di memoria, stack vs heap, determinismo e frammentazione, RVO/NRVO, stringhe locali inplace e pmr::string, polimorfismo ad-hoc con std::variant e ottimizzazioni reali di vector/map/string via monotonic_buffer_resource e un profiler.
- C++
Perché gli sviluppatori di giochi restano sul C++17
Perché gli studi di gioco non hanno fretta di passare al C++20: auto e un +10-15% sui tempi di compilazione, Visual Studio come miglior debugger al mondo, l'economia delle build farm e dei tool, la sfiducia in STL e Boost, l'assenza di test automatizzati e perché il debug non scala.
- C++
Game++. Spacchettare i container
I container specializzati nei motori: array fissi e matrici, vector linear/stable/sparse/packed/static/small/dirty/buddy, deque e bcdeque, bounded_priority_deque, intrusive list, octree e quadtree, object_pool, ring buffer, cached_hashtable, handle_container e slot_container — come funzionano, diagrammi e dove si usano.
- C++
Game++. Costruire archi
Le architetture dei motori di gioco e la legge di Conway: l'approccio unitario (Big Ball of Mud) in Unity, a layer in Unreal Engine, il microkernel in CryEngine e O3DE, data-driven in Dagor, monolitico in X-Ray e micro-modulare in Godot.
- C++
Game++. run, thread, run…
Il multithreading nei giochi: i problemi dei lock (deadlock, thread starvation, inversione di priorità in Cyberpunk 2077 e Crysis), il memory model del C++11, lock-free e atomics, spinlock con backoff, thread pool e un sistema di task, hitching e un mutex read-write.
- C++
Game++. Giocolare con gli algoritmi STL
Perché gli algoritmi STL sono il C++ «colloquiale»: mostrano Cosa fai, non Come; eliminano i bug sui limiti, sulle collezioni vuote e sulle «prestazioni spalmate». La storia di EASTL, gli iteratori e back_inserter, il caching degli shader via set_difference e un grande cheat sheet degli algoritmi.
- C++
Game++. Danze con gli allocatori
Un grande tour degli allocatori di memoria nei giochi: linear, step-back, frame, stack, pool, free list, arena, segregated, buddy, thread-cache, fibonacci, compacting, suddivisione hot/cold e TLSF — con codice, diagrammi e un benchmark.
- C++
Game++. Cucinare i vettori
Come funzionano i vettori nei motori e quanto li paghi: crescita della capacity e frammentazione della memoria, composizione singola vs a cascata, std::array, uno static_vector sullo stack, hybrid_vector con un'ottimizzazione in stile SSO e le insidie degli allocatori pmr dei vendor.
- C++
Game++. String interning
L'interning delle stringhe (string pooling) nei motori: una sola copia di una stringa per tutti i riferimenti, l'interning dei letterali in clang/GCC e perché il trucco si rompe su Xbox, il pericolo dei confronti con ==, la lotta alla frammentazione della memoria e una semplice implementazione di xstring su hash con conteggio dei riferimenti.
- C++
Come far entrare un elefante in una valigia
I livelli di ottimizzazione nel porting dei giochi su hardware debole: architettura, algoritmi e codice. La storia di un costoso controllo di escaping delle stringhe — da un loop ingenuo a una versione branchless, una lookup table e SIMD con _mm_movemask_epi8.
- C++
Lance & bit
Impacchettare i bool nei bit: std::bitset, std::vector<bool>, un ingenuo array di byte e l'approccio di CryEngine, benchmark con picchi a 32/64/128, i miss del branch predictor e una vettorizzazione SSE finale con _mm_movemask_epi8.
- C++
Pensare a task nei motori di gioco
I pattern fondamentali dei sistemi di task nei motori: spostare movimento, fisica, script, path-finding, animazione, rendering e I/O su thread separati, il raggruppamento dei task, il message passing e un confronto tra un task semplice, un thread manager e un task manager.
- C++
Il pesante H[eader]
Ridurre il tempo di build di un grande progetto C++ da 15:32 a 5:16: header template pesanti, l'istanziazione, forward declaration, precompiled header, PIMPL, windows.h e la disattivazione di analizzatori e LTO — con tabelle dei tempi di build degli header.
- C++
Capo, è tutto sparito
Il seguito di «Dove sono i tuoi bug?»: 16 bug da venerdì sera presi da motori reali — scritture out-of-bounds, handle persi su Switch, memset su un tipo non banale, =! al posto di != e alloca in un loop.
- C++
Semplicemente non copiarlo
Passaggio per valore vs const&, allocazioni nascoste su stringhe e vettori, reserve e un crollo reale a 10 FPS — il tutto con benchmark.
- C++
Le stringhe nei motori di gioco
C-string e NTBS, std::string e SSO, string_view, stringhe sized/pool/arena, stringhe condivise, identificatori e parsing SIMD — come i motori gestiscono le stringhe.
- C++
Cos'è il C++ nel gamedev?
I livelli su cui vive il C++ dentro un motore: il macinare numeri hardcore, il C++ «ordinario» con script e hot-reload, e un metalivello con RTTI, reflection e generazione di codice.
- C++
La magia dello swizzle degli shader in C++
Implementare lo swizzle (vec.xxy, vec.zx) in C++ con union e template — senza overhead di memoria e più veloce di glm e CxxSwizzle.
- C++
Dove sono i tuoi bug?
Una collezione di bug selvaggi da motori reali: un punto e virgola mancante in Unity, un memset eliminato dal compilatore, race sui bitfield in CryEngine, il most vexing parse e un'altra dozzina.
- C++
I nomi contano per il compilatore?
Come il compilatore risponde a due domande chiave — cosa significa un nome e quale variante è quella giusta: name lookup e overload resolution, la coesistenza di nomi di categorie diverse, i conflitti funzione/namespace/enum e perché dietro a tutto c'è il name mangling degli anni '80.
- C++
Vincoli, ancora una volta
I limiti fondamentali dei concept del C++: il divieto di ricorsione nella definizione di un concept e l'impossibilità di applicare un requires al concept stesso, le forme di scrittura di requires, l'applicazione dei concept a classi, metodi, costruttori e variabili locali, il partial ordering e i vincoli atomici.
- C++
Gerarchie di concept in C++
Come il compilatore sceglie tra più overload di template compatibili tramite constraint subsumption e partial ordering: l'identità sintattica conta più dell'equivalenza logica, la gerarchia dei concept degli iteratori STL e dove le gerarchie profonde danneggiano la chiarezza del codice.
- C++
Una storia dei concept in C++
Come i concept si sono evoluti dalle ambiziose proposte semantiche di fine anni '90 (riflessività, simmetria, transitività) e dai concept «pesanti» che quasi entrarono nel C++11 fino al pragmatico modello Concepts Lite del C++20 — verificare la sintassi invece di garantire il comportamento.
- C++
Concept e vincoli in C++
Concept e vincoli (requires) come sostituto di SFINAE ed enable_if: contratti di tipo espliciti direttamente nella firma, requires come parte della firma, le requires-expression, vincoli semplici e complessi e static_assert.
- C++
Gli overload in C++
Gli overload non come zucchero sintattico ma come meccanismo di programmazione generica: l'algoritmo prima dei tipi, l'esponenziazione per quadratura, overload set buoni e cattivi e una critica al design di std::filesystem.
- C++
Generalizzazioni in C++ (parte 2)
La continuazione del capitolo 1: identità e uguaglianza degli oggetti, procedure e call stack, le convenzioni di chiamata e le categorie in/out/in-out, la base computazionale da ENIAC ad AMX e la regolarità dei tipi come guida pratica di design.
- C++
Generalizzazioni in C++ (parte 1)
Il capitolo 1 pubblicato: il C++ come modo di parlare del mondo attraverso entità, specie e generi, i valori e la loro rappresentazione in bit, l'unicità della rappresentazione e l'uguaglianza, le funzioni pure (regolari) e gli oggetti come contratto tra programmatore, compilatore e macchina.
- C++
Generalizzazioni, valori e oggetti in C++
Entità, specie e generi, i valori e la loro rappresentazione, gli oggetti, le procedure, la base computazionale e la regolarità — le fondamenta del linguaggio.
- C++
Non c'è fretta… (Sugli spinlock)
Implementazioni di spinlock — dal TAS ingenuo a un ticket spinlock — con benchmark, cache miss e le sfumature della prioritizzazione dei thread.
- C++
Cache inquinata? Fai scorta di test
Come cache, associatività, coerenza e allineamento dei dati influenzano le prestazioni — con benchmark.
- C++
Il nome di un enum C++ a runtime
Ottenere il nome di un tipo e del valore di un enum a runtime senza RTTI — via __PRETTY_FUNCTION__, template e magia constexpr.
- C++
Quando è private ma lo vorresti proprio public
Testare i membri privati di una classe C++ senza modificare gli header: dai friend e #define private public a un hack con i template.
- C++
Perché ci sono tre sin diversi nell'SDK dello Switch?
Come il porting dei giochi ha fatto emergere tre implementazioni di sin — e cosa ha mostrato il disassemblato con diversi livelli di ottimizzazione.