Esempio 1:
Qui vengono importati diversi file di intestazione che sono 'stddef.h', 'limits' e 'iostream'. Le definizioni di variabili, tipi e puntatori utilizzati di frequente possono essere trovate in 'stddef.h' e il file di intestazione 'limits' viene utilizzato come costanti che rappresentano i limiti dei tipi integrali, come i valori minimo e massimo per vari tipi di dati , accessibili tramite questo file di intestazione. Quindi, viene aggiunto 'iostream' perché in esso sono definite le funzioni utilizzate per l'input/output dei dati.
Successivamente, qui viene aggiunto lo spazio dei nomi 'std'. Sotto questo viene richiamato il metodo “main()”. All'interno di questo, inseriamo il 'cout' che aiuta a rendere i dati che inseriremo qui. Il 'numeric_limits::max()' viene digitato in quanto restituisce il valore finito più alto che il tipo numerico 'T' può rappresentare. È significativo per ogni tipo limitato ma non può essere negativo.
Codice 1:
#include
#include
#include
utilizzando spazio dei nomi standard ;
int principale ( ) {
cout << 'La dimensione massima di size_t è ' << limiti_numerici :: massimo ( ) << fine ;
}
Produzione:
Potremmo notare che ora viene renderizzata la dimensione massima del tipo 'T', che è un valore molto grande, come mostrato di seguito:
Esempio 2:
Qui vengono importati due file di intestazione, inclusi 'limits' e 'iostream. Poiché in esso sono definite le funzioni necessarie per l'input e l'output dei dati, qui viene aggiunto 'iostream'. Quindi, il file di intestazione 'limits' viene utilizzato per accedere alle costanti che descrivono i limiti dei tipi integrali come i valori minimo e massimo per diversi tipi di dati.
Successivamente qui viene introdotto lo spazio dei nomi “std” e viene richiamata la funzione “main()”. Al di sotto di questo, utilizziamo 'INT_MAX' all'interno di 'cout' per eseguire il rendering del valore più alto del limite superiore del tipo di dati intero nella programmazione C++. Quindi, nella riga successiva, utilizziamo “size_t” che dà il valore più alto.
Codice 2:
#include#include
utilizzando spazio dei nomi standard ;
int principale ( ) {
cout << 'Il valore intero massimo: ' << INT_MAX << fine ;
cout << 'La dimensione mantenuta dalla funzione size_t: ' << ( taglia_t ) 0 - 1 << fine ;
ritorno 0 ;
}
Produzione :
Per prima cosa viene visualizzata la dimensione massima del numero intero, che otteniamo con l'aiuto di 'INT_MAX'. Quindi, viene visualizzata la dimensione massima memorizzata da 'size_t' che otteniamo con l'aiuto di 'size_t' in questo codice.
Esempio 3:
Qui vengono importati due file header, “climits” e “iostream”. Qui è incluso 'iostream' poiché in esso sono definite le funzioni necessarie per l'input e l'output dei dati. Successivamente, si accede alle costanti che descrivono i limiti dei tipi integrali come i valori minimo e massimo per vari tipi di dati utilizzando il file di intestazione 'climits'.
Qui viene ora invocata la funzione “main()” e successivamente viene introdotto lo spazio dei nomi “std”. Al di sotto di questo, utilizziamo 'INT_MAX' all'interno di 'cout' per restituire il limite superiore del valore massimo del tipo di dati intero nella programmazione C++. Sotto questo, utilizziamo 'INT_MIN' che restituisce il valore inferiore del tipo di dati 'int'. Quindi, utilizziamo 'size_t' che restituisce il valore massimo memorizzato nella riga seguente:
Codice 3:
#include#include
utilizzando spazio dei nomi standard ;
int principale ( ) {
cout << 'Il valore intero più grande: ' << INT_MAX << fine ;
cout << 'Il numero intero più piccolo: ' << INT_MIN << fine ;
cout << 'La dimensione mantenuta dalla funzione size_t: ' << ( taglia_t ) 0 - 1 << fine ;
ritorno 0 ;
}
Produzione:
Innanzitutto viene visualizzata la dimensione massima del numero intero che otteniamo con l'aiuto di “INT_MAX”. Successivamente viene visualizzata la dimensione minima del numero intero che otteniamo con l'aiuto di “INT_MIN”. Quindi, con l'aiuto di 'size_t' in questo codice, viene visualizzata la dimensione massima di cui vengono visualizzati gli archivi 'size_t'.
Esempio 4:
I file di intestazione inclusi in questo codice sono 'cstddef', 'iostream' e 'array'. Questi file di intestazione sono inclusi in modo da poter utilizzare quelle funzioni le cui definizioni sono definite in questi file di intestazione. Il file di intestazione 'array' viene aggiunto qui poiché dobbiamo lavorare con gli 'array' e le funzioni in questo codice. Dichiariamo qui la variabile 'my_sVar' con 'const size_t' e la inizializziamo con il valore '1000' per renderizzarne la dimensione.
Successivamente, dichiariamo anche l'array 'num[]' con tipo di dati 'int' e passiamo 'my_sVar' come dimensione. Quindi, utilizziamo la funzione “size_of()” in cui inseriamo la variabile “num” come parametro e la memorizziamo nella variabile “my_size” del tipo “size_t”. Quindi, utilizziamo 'cout' e digitiamo qui 'SIZE_MAX' in modo che venga visualizzata la dimensione massima della variabile 'my_sVar'.
Successivamente, mostriamo gli elementi di tipo array in numeri più piccoli. Lo selezioniamo solo per mostrare 10 come 1000 che è troppo numeroso per rientrare nell'output. Utilizzando il tipo 'size_t', iniziamo dall'indice 0 per mostrare come 'size_t' può essere utilizzato sia per l'indicizzazione che per il conteggio. Poiché i numeri diminuiranno, l'array viene mostrato in ordine decrescente poiché abbiamo inserito '–a' nel codice.
Codice 4:
#include#include
#include
utilizzando spazio dei nomi standard ;
int principale ( ) {
cost taglia_t mia_sVar = 1000 ;
int nessuno [ mia_sVar ] ;
taglia_t la mia taglia = taglia di ( nessuno ) ;
cout << 'La dimensione massima di my_sVar = ' << DIMENSIONE_MAX << fine ;
cout << 'Quando si lavora con un array di numeri, il tipo size_t è il seguente. ' ;
vettore < taglia_t , 10 > mio_arr ;
per ( taglia_t UN = 0 ; UN ! = mio_arr. misurare ( ) ; ++ UN )
mio_arr [ UN ] = UN ;
per ( taglia_t UN = mio_arr. misurare ( ) - 1 ; UN < mio_arr. misurare ( ) ; -- UN )
cout << mio_arr [ UN ] << ' ' ;
ritorno 0 ;
}
Produzione:
Rende prima la dimensione massima della variabile e poi rende l'array in ordine decrescente.
Esempio 5:
Questo codice include i file di intestazione 'cstddef', 'iostream' e 'array'. Poiché questo codice richiede di lavorare con 'array' e funzioni, il file di intestazione 'array' viene posizionato qui. Per rendere la dimensione della variabile “var”, la dichiariamo qui con il valore “const size_t” e la inizializziamo con “1000”. La dimensione massima della variabile 'var' viene quindi resa qui poiché abbiamo utilizzato la funzione 'cout' e specificato 'SIZE_MAX' in questo campo.
Successivamente, proviamo a visualizzare gli elementi di tipo array in quantità minori. Finora abbiamo scelto di visualizzarne solo 20 perché 1000 riempirebbe l’output. Dimostriamo come 'size_t' può essere utilizzato sia per l'indicizzazione che per il conteggio utilizzando il tipo 'size_t' e iniziando dall'indice 0. L'array viene quindi visualizzato in ordine decrescente perché i numeri diminuiranno come indicato dal posizionamento di '-a' in il seguente codice:
Codice 5:
#include#include
#include
utilizzando spazio dei nomi standard ;
int principale ( ) {
cost taglia_t era = 1000 ;
cout << 'Dimensione massima di var = ' << DIMENSIONE_MAX << fine ;
cout << 'Il tipo size_t utilizzato con un array di numeri viene fornito come ' ;
vettore < taglia_t , venti > num_array ;
per ( taglia_t io = 0 ; io ! = num_array. misurare ( ) ; ++ io )
num_array [ io ] = io ;
per ( taglia_t io = num_array. misurare ( ) - 1 ; io < num_array. misurare ( ) ; -- io )
cout << num_array [ io ] << ' ' ;
ritorno 0 ;
}
Produzione :
Rende l'array in una sequenza decrescente dopo aver reso la variabile alla sua dimensione massima.
Conclusione
Il tipo 'size_t' nella programmazione C++ è stato esplorato approfonditamente in questo articolo. Abbiamo definito di utilizzare 'size_t' nei nostri codici C++ poiché memorizza il suo valore più grande. Abbiamo anche spiegato che è un tipo senza segno e non può essere negativo. Abbiamo dimostrato i codici della programmazione C++ in cui abbiamo utilizzato 'size_t' e poi abbiamo presentato i loro risultati in questo articolo.