FreeMediaLab

Questa pagina è in sola lettura. Puoi visualizzare il sorgente, ma non puoi modificarlo. Contatta l'amministratore se pensi che ci sia un errore.
====== Buone pratiche di programmazione in C/C++  ======
Autore: **//Fabio Di Matteo//** \\ Ultima revisione:  **//  07/09/2026 10:59   //**  // //

Buone pratiche di programmazione in C/C++ e cose da evitare.

^ Costrutto/funzione ^ Linguaggio ^ Perché è pericoloso ^ Alternativa più sicura ^
| <code>gets()</code> | C | Non limita la quantità di dati letti e può causare buffer overflow. | <code>fgets()</code> con controllo della dimensione |
| <code>strcpy()</code> | C/C++ | Copia senza verificare la dimensione del buffer di destinazione. | <code>snprintf()</code>, <code>strncpy()</code> con attenzione oppure <code>std::string</code> |
| <code>strcat()</code> | C/C++ | Concatena stringhe senza controllare lo spazio disponibile. | <code>strncat()</code> con attenzione oppure <code>std::string</code> |
| <code>sprintf()</code> | C/C++ | Può scrivere oltre i limiti del buffer. | <code>snprintf()</code> |
| <code>vsprintf()</code> | C/C++ | Variante senza controllo di dimensione di <code>sprintf()</code>. | <code>vsnprintf()</code> |
| <code>scanf("%s", ...)</code> | C/C++ | Legge stringhe senza limite e può provocare buffer overflow. | Specificare una larghezza, per esempio <code>%19s</code>, o usare <code>fgets()</code> |
| <code>scanf()</code> | C/C++ | Può lasciare input non consumato e causare errori di conversione o loop imprevisti. | Controllare sempre il valore restituito; in C++ preferire <code>std::getline()</code> |
| <code>printf(user_input)</code> | C/C++ | Crea una format-string vulnerability se l'input controlla il formato. | <code>printf("%s", user_input)</code> |
| <code>fprintf(file, user_input)</code> | C/C++ | Presenta lo stesso rischio delle format string controllate dall'utente. | Usare una stringa di formato fissa |
| <code>memcpy()</code> | C/C++ | Una dimensione errata può causare letture o scritture fuori dai limiti. | Controllare rigorosamente dimensioni e sovrapposizione |
| <code>memmove()</code> | C/C++ | Evita alcuni problemi di sovrapposizione, ma non impedisce buffer overflow. | Verificare sempre la dimensione dei buffer |
| <code>memset()</code> | C/C++ | Una lunghezza errata può sovrascrivere memoria; non è adatta a inizializzare ogni tipo C++. | Usare dimensioni corrette e costruttori C++ |
| <code>free()</code> | C/C++ | Può causare double free, use-after-free o heap corruption. | Gestione RAII e smart pointer |
| <code>delete</code> | C++ | Può causare double delete, use-after-free o comportamento indefinito. | <code>std::unique_ptr</code> e <code>std::shared_ptr</code> |
| <code>delete[]</code> | C++ | Usarlo con memoria allocata da <code>new</code> invece di <code>new[]</code> causa comportamento indefinito. | Evitare array dinamici manuali; usare <code>std::vector</code> |
| <code>new</code> / <code>new[]</code> | C++ | Richiede una gestione manuale della memoria e può causare memory leak. | <code>std::make_unique()</code>, <code>std::make_shared()</code>, <code>std::vector</code> |
| <code>malloc()</code> / <code>calloc()</code> / <code>realloc()</code> | C/C++ | Errori di dimensione, overflow, memory leak e mancato controllo del valore restituito. | In C++ usare contenitori STL e RAII |
| Conversione implicita di <code>malloc()</code> | C++ | Convertire direttamente il risultato di <code>malloc()</code> può nascondere errori e non invoca costruttori. | Usare <code>new</code> gestito da smart pointer o contenitori STL |
| Puntatori non inizializzati | C/C++ | Dereferenziarli può causare crash o corruzione della memoria. | Inizializzare a <code>nullptr</code> o usare oggetti automatici |
| Puntatori dangling | C/C++ | Puntano a memoria già rilasciata o a oggetti usciti dallo scope. | Usare RAII, riferimenti validi e smart pointer |
| Dereferenziazione di <code>nullptr</code> | C++ | Provoca normalmente un crash e comporta comportamento indefinito. | Controllare il puntatore o evitare puntatori non necessari |
| Accesso oltre i limiti di un array | C/C++ | Può corrompere memoria, causare crash o vulnerabilità. | <code>std::array::at()</code>, <code>std::vector::at()</code> o range-based <code>for</code> |
| Aritmetica dei puntatori | C/C++ | Un calcolo errato può produrre puntatori fuori dall'oggetto valido. | Usare iteratori e contenitori della libreria standard |
| <code>reinterpret_cast</code> | C++ | Può violare l'allineamento, l'aliasing e le regole sui tipi. | Preferire conversioni tipate o interfacce sicure |
| Cast in stile C, per esempio <code>(Tipo*)ptr</code> | C/C++ | Nasconde il tipo di conversione e può rimuovere controlli importanti. | <code>static_cast</code>, <code>dynamic_cast</code> o <code>const_cast</code> solo quando appropriato |
| <code>const_cast</code> | C++ | Modificare un oggetto realmente dichiarato <code>const</code> causa comportamento indefinito. | Evitare di rimuovere <code>const</code> |
| <code>static_cast</code> verso un tipo incompatibile | C++ | Una conversione errata può produrre dati corrotti o comportamento indefinito. | Verificare i tipi e usare conversioni esplicite controllate |
| <code>union</code> usata per reinterpretare tipi | C/C++ | La lettura di un membro diverso da quello scritto può violare le regole del linguaggio. | Usare <code>std::variant</code> o conversioni definite |
| Variabili locali restituite per indirizzo | C/C++ | L'indirizzo diventa invalido quando la funzione termina. | Restituire un valore, un oggetto o usare memoria gestita |
| Riferimenti a temporanei | C++ | Il riferimento può sopravvivere all'oggetto temporaneo e diventare dangling. | Restituire per valore o prolungare correttamente la durata |
| <code>exit()</code> in codice complesso | C/C++ | Salta il normale flusso di distruzione degli oggetti e può lasciare risorse aperte. | Restituire errori e lasciare che RAII gestisca le risorse |
| <code>abort()</code> | C/C++ | Termina bruscamente il programma senza una normale gestione delle risorse. | Gestire l'errore o usare eccezioni dove appropriato |
| <code>system()</code> | C/C++ | Se l'input contiene dati controllabili dall'utente può permettere command injection. | Evitare la shell; usare API dedicate e argomenti separati |
| <code>popen()</code> | C/C++ | Esegue comandi tramite shell e può esporre a command injection. | Usare API di processo sicure senza interpretazione della shell |
| <code>execl()</code>, <code>execv()</code> e simili | C/C++ | Argomenti o percorsi non controllati possono eseguire programmi indesiderati. | Convalidare percorsi e argomenti; evitare input non fidato |
| <code>tmpnam()</code> | C/C++ | Il nome temporaneo può essere prevedibile o soggetto a race condition. | Usare API sicure per file temporanei |
| <code>mktemp()</code> | C/C++ | Genera nomi temporanei non sicuri e può permettere attacchi di tipo symlink/race condition. | Usare <code>mkstemp()</code> o API moderne del sistema |
| <code>fopen()</code> con percorso controllato dall'utente | C/C++ | Può permettere path traversal o apertura di file arbitrari. | Normalizzare, validare e limitare il percorso |
| <code>atoi()</code> | C/C++ | Non segnala correttamente gli errori e può produrre risultati ambigui. | <code>strtol()</code> oppure <code>std::from_chars()</code> |
| <code>atol()</code> / <code>atoll()</code> | C/C++ | Come <code>atoi()</code>, non gestiscono bene errori e overflow. | <code>strtol()</code>, <code>strtoll()</code> o <code>std::from_chars()</code> |
| Conversioni da interi signed a unsigned | C/C++ | Possono trasformare valori negativi in numeri molto grandi. | Controllare i limiti prima della conversione |
| Overflow di interi signed | C/C++ | È comportamento indefinito e può invalidare i controlli di sicurezza. | Verificare i limiti o usare controlli aritmetici sicuri |
| Overflow di interi unsigned | C/C++ | Il valore ricomincia da zero e può causare allocazioni o dimensioni errate. | Controllare l'overflow prima dei calcoli |
| Shift con quantità negativa o troppo grande | C/C++ | Può causare comportamento indefinito o risultati non portabili. | Validare la quantità dello shift |
| Divisione intera per zero | C/C++ | Causa comportamento indefinito e generalmente termina il programma. | Controllare il divisore prima della divisione |
| Macro con argomenti valutati più volte | C/C++ | Possono produrre effetti collaterali inattesi, per esempio incrementi duplicati. | Preferire funzioni, template o lambda |
| <code>volatile</code> usato per sincronizzazione | C/C++ | Non garantisce atomicità né sincronizzazione tra thread. | Usare <code>std::atomic</code>, mutex o variabili condition |
| Variabili condivise senza mutex o atomiche | C++ | Possono causare data race e comportamento indefinito. | <code>std::mutex</code>, <code>std::lock_guard</code> o <code>std::atomic</code> |
| <code>std::thread::detach()</code> | C++ | Il thread può usare oggetti già distrutti e gli errori diventano difficili da gestire. | Preferire <code>join()</code> o <code>std::jthread</code> |
| Ordine errato di acquisizione dei mutex | C++ | Può causare deadlock quando più thread attendono risorse circolarmente. | Usare un ordine fisso o <code>std::scoped_lock</code> |
| Distruzione manuale di oggetti | C++ | Può causare doppia distruzione o uso di oggetti non più validi. | Lasciare gestire la durata a RAII |
| Eccezioni lanciate dai distruttori | C++ | Possono causare <code>std::terminate()</code> durante lo svolgimento di un'altra eccezione. | Rendere i distruttori <code>noexcept</code> |
| <code>assert()</code> per controlli di sicurezza | C/C++ | Le asserzioni possono essere disabilitate in compilazione. | Usare controlli normali per input e autorizzazioni |
| Disabilitare avvisi e protezioni del compilatore | C/C++ | Può nascondere errori e rimuovere difese utili. | Mantenere warning elevati e protezioni abilitate |
| Uso di dati non inizializzati | C/C++ | Può causare risultati imprevedibili, divulgazione di dati o crash. | Inizializzare sempre variabili e memoria |
| Serializzazione tramite copia diretta di struct | C/C++ | Padding, endianness e puntatori rendono il formato non portabile e insicuro. | Definire un formato esplicito e validare le lunghezze |
| Deserializzazione senza validazione | C/C++ | Dati manipolati possono causare overflow, accessi fuori limite o esecuzione non prevista. | Validare tipo, lunghezza, limiti e versione dei dati |
| Regex o parser applicati a input senza limiti | C/C++ | Input molto grandi possono causare consumo eccessivo di CPU o memoria. | Imporre limiti di dimensione e timeout |
| <code>new</code> / <code>delete</code> manuali | C++ | Possono causare memory leak, double delete e use-after-free. | Oggetti automatici, RAII e <code>std::unique_ptr</code> |
| <code>std::shared_ptr</code> usato indiscriminatamente | C++ | Può nascondere la proprietà delle risorse, creare cicli e aggiungere costi inutili. | Preferire <code>std::unique_ptr</code> e usare <code>std::shared_ptr</code> solo per proprietà realmente condivise |
| Array C | C/C++ | Non contengono informazioni sulla dimensione e facilitano gli accessi oltre i limiti. | <code>std::array</code> o <code>std::vector</code> |
| Stringhe C gestite manualmente | C/C++ | Possono causare buffer overflow, terminazione errata e use-after-free. | <code>std::string</code> |
| Cast C-style | C/C++ | Nasconde il tipo di conversione e può consentire conversioni pericolose. | <code>static_cast</code>, <code>dynamic_cast</code> o altra conversione esplicita appropriata |
| <code>reinterpret_cast</code> | C++ | Può violare allineamento, aliasing e regole sui tipi, causando comportamento indefinito. | Conversioni tipizzate o <code>std::bit_cast</code> quando applicabile |
| <code>operator[]</code> senza controllo | C++ | Non verifica che l’indice sia nei limiti del contenitore. | <code>.at()</code> quando è necessario un controllo esplicito |
| Puntatore e dimensione separati | C/C++ | Possono diventare incoerenti e causare accessi oltre i limiti. | <code>std::span</code> |
| <code>std::string_view</code> verso oggetti temporanei | C++ | La vista può riferirsi a memoria già distrutta. | <code>std::string</code> oppure garantire la durata della stringa originale |
| Iteratori usati dopo modifiche al contenitore | C++ | Inserimenti o riallocazioni possono invalidare gli iteratori. | Rispettare le regole di invalidazione degli iteratori |
| Conversioni implicite signed/unsigned | C/C++ | Possono trasformare valori negativi in numeri molto grandi e causare errori nei controlli. | Usare tipi coerenti e conversioni esplicite verificate |
| Operazioni aritmetiche non controllate | C/C++ | Overflow e underflow possono produrre risultati errati o comportamento indefinito. | Controllare i valori e usare tipi numerici adeguati |
| Variabili globali modificabili | C/C++ | Rendono difficile controllare lo stato e aumentano il rischio di dipendenze nascoste e race condition. | Stato locale, incapsulamento e dati <code>const</code> |
| Dati condivisi senza sincronizzazione | C/C++ | Possono causare data race e comportamento indefinito nei programmi concorrenti. | Mutex, atomici, immutabilità o comunicazione tramite messaggi |
| Warning del compilatore ignorati | C/C++ | Errori e conversioni sospette possono rimanere inosservati. | Compilare con warning severi come <code>-Wall -Wextra -Wpedantic</code> |
| Codice non verificato con sanitizzatori | C/C++ | Errori di memoria, comportamento indefinito e data race possono non essere rilevati. | Usare AddressSanitizer, UndefinedBehaviorSanitizer e ThreadSanitizer |
| Input esterno non validato | C/C++ | Dati inattesi possono causare crash, overflow o consumo eccessivo di risorse. | Validazione, limiti di dimensione e gestione esplicita degli errori |
| Risorse gestite manualmente | C++ | File, mutex e altre risorse possono non essere rilasciati in caso di errore o eccezione. | RAII e classi come <code>std::lock_guard</code> |