std::optional::operator-> — accesso a un membro del valore contenuto
Usa `->` per accedere a un membro del valore memorizzato in `std::optional`. In C++23 devi prima verificare che il valore sia presente.
CKTIS / Base di conoscenza
Sintassi, operatori e concetti di programmazione. Trova una spiegazione, consulta un esempio e torna a imparare.
Usa `->` per accedere a un membro del valore memorizzato in `std::optional`. In C++23 devi prima verificare che il valore sia presente.
`*opt` restituisce un riferimento al valore contenuto. Verifica che il valore sia presente prima di accedervi: l’indice `0` non indica un valore mancante.
`if (opt)` verifica se uno `std::optional` contiene un valore, non se quel valore è vero. Sia l’indice `0` sia il valore booleano `false` contano come presenti.
Scegli una risorsa di memoria per un vettore PMR e scopri quando i suoi elementi ricevono la stessa risorsa e come si comporta invece un vettore ordinario.
Verifica se lo stato di arresto condiviso ha ricevuto una richiesta, così da poter terminare il lavoro in un punto sicuro. `true` non indica che il thread sia già terminato.
`std::string::empty` verifica se una stringa ha lunghezza zero. Quando si uniscono più argomenti, non indica se la prima posizione è già stata elaborata.
Trova l’indice di un carattere o di una sottostringa e confrontalo con `std::string::npos` prima di usarlo come indice o di copiare o modificare il testo.
Confronta il risultato di `std::string::find` con `std::string::npos`. Come numero di caratteri in `substr` o `erase`, la stessa costante significa «fino alla fine», non una posizione iniziale.
Usa `back()` per leggere o modificare l’ultimo elemento di un vettore non vuoto. Impara quando il risultato diventa invalido e perché l’estrazione da un heap richiede due passaggi.
`begin()` restituisce l’iteratore iniziale del vettore. La qualificazione `const` determina l’overload e `end()` indica la posizione da non dereferenziare.
`std::vector::clear` distrugge tutti gli elementi e azzera la dimensione del vettore, mantenendo la capacità disponibile per inserimenti successivi.
Ottieni un puntatore agli elementi del vettore, passalo insieme al numero di elementi e riconosci quando perde validità.
Costruisce un elemento in coda al vettore a partire dagli argomenti ricevuti. Scopri cosa restituisce la funzione e quando i riferimenti esistenti diventano invalidi.
Usa `v.empty()` per verificare in tempo costante se un vettore non contiene elementi. La capacità riservata non incide sul risultato.
`std::vector::end` restituisce la posizione oltre l’ultimo elemento, non l’ultimo elemento stesso. È il limite escluso dell’intervallo e segnala che una ricerca non ha trovato risultati.
`front()` accede al primo elemento di un vettore in tempo costante. Se il vettore potrebbe essere vuoto, controlla prima `empty()`.
Inserisci un valore, più copie, una lista di inizializzazione o un intervallo di iteratori prima di una posizione. Usa l’iteratore restituito e controlla quali riferimenti restano validi.
`pop_back()` rimuove l’ultimo elemento di un vettore non vuoto senza restituirne il valore. Se il vettore contiene uno heap, `std::pop_heap` riordina gli elementi e `pop_back()` ne riduce il numero.
Aggiungi un elemento per copia o da un rvalue. Scopri quando una riallocazione invalida i puntatori e perché il vecchio `end()` si invalida anche senza riallocazione.
`reserve(n)` garantisce spazio per almeno `n` elementi in totale senza crearli. È utile prima di una serie di inserimenti in coda, se si conosce il numero finale di elementi o un limite superiore ragionevole.
`size()` restituisce il numero attuale di elementi in tempo costante. È questo numero, non `capacity()`, a determinare gli indici validi.
Scambia il contenuto e la capacità di due vettori in tempo costante. Verifica la compatibilità degli allocatori e quali iteratori restano validi dopo lo scambio.
Confronta la memorizzazione per record e per campo, tenendo conto degli accessi, della località nella cache e del costo di conversione tra i due layout.
Usa `delete` per un oggetto creato con `new T` e `delete[]` per un array creato con `new T[n]`. Queste espressioni gestiscono la durata di vita degli oggetti; le funzioni corrispondenti, con o senza `[]`, gestiscono la memoria.