Phenquestions
La memoria di un computer è una serie di celle. Ogni cella ha la dimensione di un byte, normalmente è lo spazio occupato da un carattere dell'Europa occidentale. La dimensione di un oggetto è data in byte. Questo articolo fornisce un riepilogo dei tipi C++. Dovresti già avere una conoscenza di base del C++, per capire questo articolo.
Contenuto dell'articolo
- Tipi fondamentali
- Modi di costruire tipi composti
- matrici
- Enumerazione
- Classe
- Unione
- Riferimenti
- Funzioni
- Altri tipi di composti
- Conclusione
Tipi fondamentali
I tipi fondamentali sono tipi scalari.
bool
Un tipo booleano o un tipo bool ha un valore vero o falso per 1 o 0. Vero o falso occupa un byte.
char, unsigned char e firmato char
Un carattere è in genere per un carattere dell'Europa occidentale. In genere occupa un byte. C'è anche un carattere senza segno e con segno, ognuno dei quali è un intero a otto bit. I caratteri senza segno non comportano valori negativi, mentre i caratteri con segno comportano valori negativi. Il tipo di valore che un carattere contiene dipende dal compilatore e potrebbe essere solo un carattere senza segno. Questi tre tipi di caratteri sono chiamati tipi di caratteri stretti e ciascuno occupa un byte.
Numero intero
Esistono cinque tipi di interi standard senza segno e cinque tipi di interi standard con segno. I cinque tipi di interi senza segno sono: "unsigned char", "unsigned short int", "unsigned int", "unsigned long int" e "unsigned long long int". I cinque tipi di interi con segno corrispondenti sono: "signed char", "short int", "int", "long int" e "long long int".
"unsigned char" è dello stesso tipo dei tipi di caratteri stretti (vedi sopra). "signed char" è l'altro tipo di caratteri stretti (vedi sopra).
Con il compilatore g++, "unsigned char" o "signed char" occupa un byte; “unsigned short int” o “short int” occupa due byte; “unsigned int” o “int” occupa quattro byte; “unsigned long int” o “long int” occupa 8 byte; "unsigned long long int" o "long long int" occupa ancora 8 byte (per ora).
char16_t, char32_t, wchar_t
Quando si tratta di caratteri dell'Europa occidentale, il tipo di carattere è sufficiente in molte situazioni. Tuttavia, quando si tratta di cinese e altre lingue orientali, è necessario char16_t o char32_t o wchar_t. Con il compilatore g++, char16_t occupa due byte; char32_t occupa quattro byte e anche wchar_t occupa quattro byte.
Il bool, il char, il char16_t, il char32_t, il wchar_t, i tipi interi con segno e senza segno, formano un altro insieme, chiamato tipi integrali (interi).
A questo punto dell'articolo sono stati menzionati due tipi collettivi: i tipi a carattere stretto e i tipi integrali.
Tipi in virgola mobile
Supponiamo che i numeri 457.000 e 457.230 siano la stessa lettura, misurata da due diversi strumenti di misura. 457.230 è più preciso di 457.000 perché il valore è più dettagliato (riguarda luoghi più piccoli: + 200 più 30). Un numero in virgola mobile è un numero con una parte frazionaria (decimale). Sebbene i numeri nel computer siano una sequenza di bit, alcuni numeri in virgola mobile sono più precisi degli altri.
Alcuni strumenti di misura effettuano misurazioni in passi minimi, diciamo 10 unità. Tale strumento avrebbe le seguenti letture: 10, 20, 30, 40,… 100, 110, 130, 140,… 200, 210, 220, 230, 240 e così via. Sebbene i numeri nel computer siano una sequenza di bit, i numeri in virgola mobile variano in alcuni passaggi minimi (molto inferiori a 10 unità).
Il C++ ha tre tipi a virgola mobile, che sono: float, double e long double. Per ogni compilatore, double deve avere la precisione maggiore di quella di float o almeno quella di float; long double deve avere la precisione maggiore di quella di double o almeno quella di double.
C'è un terzo nome collettivo: tipo aritmetico. Questo è il nome per i tipi integrali e in virgola mobile. Nota che questo è anche il nome di tutti i tipi scalari, come spiegato finora.
Con il compilatore g++, il numero di byte per un float è quattro; il numero di byte per un double è otto; il numero di byte per un long double è sedici.
tipo vuoto
Con il compilatore g++, la dimensione del tipo void è di un byte. Il byte ufficialmente non ha bit, il che significa che la sua posizione ha un contenuto vuoto.
Modi di costruire tipi composti
I tipi composti sono tipi non fondamentali. Ciò significa che i tipi composti sono tipi non scalari. Questa sezione spiega le basi dei tipi di composti.
matrici
Il seguente segmento di codice mostra un array di int e un array di caratteri:
int arrInt[] = 1, 2, 3, 4, 5;char arrCha[] = 'a', 'b', 'c', 'd', 'e';
cout << arrInt[2] <<" <
Enumerazione
Un'enumerazione è un tipo, con costanti denominate. Considera il seguente segmento di codice:
enum a=3, b, c;cout << b <<'\n';
L'uscita è: 4. La prima riga del segmento di codice è un'enumerazione e a, b o c è un enumeratore.
Classe
Una classe è un'unità generalizzata da cui possono essere creati (istanziati) molti oggetti della stessa unità generalizzata. Il seguente programma mostra una classe e due oggetti, istanziati da essa. Tale oggetto è diverso da un oggetto scalare.
#includereusando lo spazio dei nomi std;
classe TheCla
pubblico:
numero int = 5;
int fn()
numero di ritorno;
;
intero principale()
TheCla obj1;
TheCla obj2;
cout << obj1.num << " << obj2.num <<'\n';
restituisce 0;
L'uscita è: 5 5. Il nome della classe è TheCla e i nomi dei due oggetti sono obj1 e obj2. Nota il punto e virgola subito dopo la descrizione (definizione) della classe. Nota come i due oggetti sono stati istanziati nella funzione main().
Nota: num è un membro dati e fn è una funzione membro.
Unione
struttura
Una struttura è come un array ma invece di avere coppie indice/valore, ha coppie nome/valore. I nomi possono essere scritti in qualsiasi ordine. Il seguente programma mostra una struttura e il suo utilizzo:
#includereusando lo spazio dei nomi std;
struttura TheCla
numero int = 5;
flottante flt = 2.3;
char ch = 'un';
obj1, obj2;
intero principale()
cout << obj2.num <<", "<< obj2.flt <<", "<< obj2.ch <<'\n';
restituisce 0;
L'uscita è:
5, 2.3, a
Il nome della struttura è TheCla. obj1 e obj2 sono due oggetti diversi della struttura.
Unione
Il seguente programma mostra un'unione e il suo utilizzo:
#includereusando lo spazio dei nomi std;
sindacato TheCla
numero int;
flottante flt = 2.3;
char ch;
obj1, obj2;
intero principale()
cout << obj2.flt <<'\n';
restituisce 0;
L'uscita è: 2.3. L'unione è simile a una struttura. La differenza principale tra una struttura e un'unione è che, per una struttura, solo un membro può avere un valore (inizializzato) in qualsiasi momento. Nel programma di cui sopra, il membro, flt ha un valore di 2.3. Ciascuno degli altri membri, num o ch, può avere un valore successivo solo se il valore di flt viene abbandonato.
Riferimenti
Un riferimento è sinonimo di un identificatore. Il segmento di codice seguente mostra come ottenere un riferimento a un identificatore:
int id = 5;int& ref1 = id;
int& ref2 = id;
cout << id << " << ref1 << " << ref2 <<'\n';
L'uscita è: 5 5 5. ref1 e ref2 sono sinonimi di id.
Riferimento lvalue e Riferimento rvalue
I riferimenti di cui sopra sono riferimenti lvalue. Il codice seguente mostra il riferimento rvalue:
int&& ref = 5;cout << ref <<'\n';
L'uscita è: 5. Questo riferimento viene creato senza identificare alcuna posizione in memoria. Per raggiungere questo obiettivo, è necessario raddoppiare &, i.e., &&.
puntatore
Un puntatore non è realmente un'entità C++. Tuttavia, fornisce uno schema migliore per trattare i riferimenti. Il codice seguente mostra come creare un puntatore:
int ptdId = 5;int ptdId = 5;
int *ptrId;
ptrId = &ptdId;
cout << *ptrId <<'\n';
L'uscita è: 5. Nota la differenza di nome tra ptdId e ptdId. ptdId è l'oggetto puntato e ptrId è l'oggetto puntatore. &ptdId restituisce l'indirizzo dell'oggetto puntato assegnato a ptrId. Per restituire il valore dell'oggetto puntato, usa *ptrId.
Funzioni
Funzione di base e suo richiamo
Il codice seguente mostra una definizione di funzione di base e la sua chiamata:
#includereusando lo spazio dei nomi std;
int fn(int num)
cout<<"seen"<<'\n';
numero di ritorno;
intero principale()
int ret = fn(5);
cout << ret <<'\n';
restituisce 0;
L'uscita è
definizione della funzione
5
La chiamata alla funzione è fn(5). Il nome della funzione è fn.
Riferimento e puntatore a una funzione
&fn restituisce l'indirizzo in memoria della funzione il cui nome è fn. La seguente istruzione dichiara un puntatore a una funzione:
int (*funzione)();Qui func è il nome del puntatore alla funzione. La prima coppia di parentesi differenzia questo puntatore a funzione da un puntatore a oggetto scalare. func può essere fatto per contenere l'indirizzo di una funzione identificata da fn, come segue:
funzione = &fn;Il seguente programma mette in azione il riferimento alla funzione e il puntatore:
#includereusando lo spazio dei nomi std;
int fn(int num)
/* alcune affermazioni */
numero di ritorno;
intero principale()
int(*func)(int);
funzione = &fn;
int ret = func(5);
cout << ret <<'\n';
restituisce 0;
L'uscita è: 5. Nota che sia fn che func hanno ciascuno il parametro int nella dichiarazione.
Altri tipi di composti
I tipi di composti di base di cui sopra sono composti di per sé. Sono anche usati per costruire tipi di composti elaborati.
typedef
La parola riservata typedef viene utilizzata per sostituire una sequenza di tipi con un nome (per la sequenza). Il seguente segmento di codice illustra questo:
typedef unsigned long int IduIL;
IduIL mioInt = 555555555555555555;cout << myInt <<'\n';
L'uscita è 555555555555555555. Nel codice, IduIL è diventato un tipo che sta per "unsigned long int".
Rilegatura strutturata
L'associazione strutturata è una funzionalità che consente di assegnare nomi ai suboggetti. Il codice seguente illustra questo per l'array:
int arr[3] = 1, 2, 3;auto [x, y, z](arr);
cout << x <<"<< y <<"<< z <<'\n';
L'uscita è 1 2 3. Quindi, ai valori: 1, 2, 3 sono stati dati i nomi, x, y, z. Notare l'uso e la posizione della parola riservata, auto. Si noti inoltre l'uso delle parentesi quadre.
Bit-Field
La memoria è una sequenza di celle. Ogni cella occupa un byte. Inoltre, ogni byte è composto da otto bit. È possibile impostare e modificare un gruppo di bit, non necessariamente otto bit. Tale gruppo è chiamato campo di bit bit. Questi gruppi giacerebbero uno accanto all'altro. Se i gruppi non costituiscono un tipo, diciamo 16 bit per un int breve, vengono aggiunti bit di riempimento pa. Il codice seguente lo illustra con la struttura:
struttura Dataunsigned short wkDay: 3; ///3 bit
unsigned short monDay : 6; //6 bit
unsigned short lun : 5; ///5 bit
anno breve non firmato: 8; ///8 bit per anno a 2 cifre
dte;
dte.wkDay = 1; dte.lunGiorno = 2; dte.lun = 2; dte.anni = 21;
cout << dte.mon <<'/'<< dte.monDay <<'/'<< dte.yr <<'\n';
L'uscita è: 2/2/21. Il numero totale di bit per wkDay, MonDay e mon è 3 + 6 + 5 = 14. Quindi, due bit di riempimento verrebbero aggiunti per creare 16 bit per l'intero breve di 2 byte (16 bit). I successivi 8 bit iniziano il successivo short int, che viene quindi riempito con 8 bit di riempimento.
Nota: evitare di utilizzare campi di bit; usalo solo per la ricerca.
Spazio dei nomi
Uno spazio dei nomi è un insieme di nomi, che non dovrebbe entrare in conflitto con gli stessi nomi di altri insiemi di nomi. Il seguente programma illustra l'uso degli stessi nomi da due diversi namespace, applicati nel namespace della funzione main():
#includereusando lo spazio dei nomi std;
spazio dei nomi NS1
int mioInt = 8;
galleggiante piatto;
spazio dei nomi NS2
int mioInt = 9;
galleggiante piatto;
intero principale()
cout << NS1::myInt << '\n';
cout << NS2::myInt << '\n';
NS1::flt = 2.5;
NS2::flt = 4.8;
cout << NS1::flt << '\n';
cout << NS2::flt << '\n';
restituisce 0;
L'uscita è:
9
8
2.5
4.8
Ci sono due stessi nomi int in conflitto e due stessi nomi float in conflitto nel codice.
Modello e specializzazione del modello
Lo schema del modello consente l'uso di un segnaposto per diversi possibili tipi scalari. La specializzazione è la scelta di un particolare tipo scalare. Il codice seguente illustra questo per una funzione:
#includereusando lo spazio dei nomi std;
template void func (T cha, U no)
cout << "I need bread for " << cha << no << '.' << '\n';
intero principale()
func('$', 3);
restituisce 0;
L'uscita è:
"Ho bisogno di pane per $ 3."
Pacchetto parametri modello
I compilatori devono ancora implementare completamente questa funzione - vedi dopo.
Conclusione
I tipi C++ esistono in due categorie: tipi fondamentali e tipi composti. I tipi fondamentali sono tipi scalari. I tipi composti di base sono array, enumerazioni, classi, unioni, riferimenti, puntatori e funzioni. Questi tipi composti di base sono usati per costruire tipi composti elaborati, che sono typedef, associazioni strutturate, campi di bit, spazio dei nomi e caratteristiche del modello.
cris
