Tipi C ++
La memoria di un computer è una serie di celle. Ogni cella ha le dimensioni 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 di C ++, per capire questo articolo.
Contenuto dell'articolo
- Tipi fondamentali
- Modi per costruire tipi di composti
- Array
- Enumerazione
- Classe
- Unione
- Riferimenti
- Funzioni
- Altri tipi composti
- Conclusione
Tipi fondamentali
I tipi fondamentali sono tipi scalari.
bool
Un tipo booleano o tipo bool ha un valore di vero o falso per 1 o 0. Vero o falso occupa un byte.
Char, non firmato e firmato Char
Un carattere è in genere per un carattere dell'Europa occidentale. In genere occupa un byte. C'è anche un carbone non firmato e firmato, che è ciascuno un numero intero a otto bit. I carboni non firmati non comportano valori negativi, mentre i caratteri firmati comportano valori negativi. Il tipo di valore detenuto da un carbone dipende dal compilatore e potrebbe essere solo un carattere non firmato. Questi tre tipi di carattere sono chiamati, tipi di carattere stretti e ciascuno occupa un byte.
Numero intero
Esistono cinque tipi interi standard non firmati e cinque tipi interi standard firmati. I cinque tipi di interi non firmati sono: "carattere non firmato", "corto int non firmato", "int unsigned", "long int long non firmato" e "lungh lungo non firmato". I cinque corrispondenti tipi interi firmati sono: "char firmato", "corto int", "int", "lungo int" e "long long int".
"Unsigned Char" è lo stesso tipo dei tipi di caratteri stretti (vedi sopra). "Firmed Char" è l'altro tipo di tipi di caratteri stretti (vedi sopra).
Con il compilatore G ++, "Carbone non firmato" o "Char firmato" occupa un byte; "Short int" non firmato "o" corto int "occupa due byte; "Unsigned Int" o "Int" occupa quattro byte; "Insigned Long Int" o "Long Int" occupa 8 byte; "Insigned Long Long Int" o "Long Long Int" occupa ancora 8 byte (a partire da ora).
char16_t, char32_t, wchar_t
Quando si tratta di personaggi dell'Europa occidentale, il tipo di carattere è sufficiente in molte situazioni. Tuttavia, quando si tratta di lingue cinesi e di altra orientale, è necessario char16_t o char32_t o wchar_t. Con il compilatore G ++, Char16_T occupa due byte; char32_t occupa quattro byte e wchar_t occupa anche quattro byte.
Il bool, il char, il char16_t, il char32_t, il wchar_t, il firmato e i tipi interi non firmati, formano un altro set, chiamato integrale (intero).
A questo punto dell'articolo sono stati menzionati due tipi collettivi: tipi di carattere stretti e tipi integrali.
Tipi di punti galleggianti
Supponiamo che i numeri 457.000 e 457.230 siano la stessa lettura, misurata da due diversi strumenti di misurazione. 457.230 è più preciso di 457.000 perché il valore è più dettagliato (coinvolge luoghi più piccoli: + 200 più 30). Un numero di punto mobile è un numero con una parte frazionaria (decimale). Sebbene i numeri nel computer siano una sequenza di bit, alcuni numeri a punto mobile sono più precisi degli altri.
Alcuni strumenti di misurazione prendono misurazioni in passaggi 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 a punto mobile vanno in alcuni passaggi minimi (molto più piccoli di 10 unità).
C ++ ha tre tipi di punto mobile, che sono: galleggiante, doppio e lungo doppio. Per qualsiasi compilatore, il doppio deve avere la precisione superiore a quella del galleggiante o almeno quella del galleggiante; Il doppio lungo deve avere la precisione superiore a quella del doppio o almeno quella del doppio.
C'è un terzo nome collettivo: tipo aritmetico. Questo è il nome per i tipi integrato e mobile. Si noti che questo è anche il nome per tutti i tipi scalari, come spiegato finora.
Con il compilatore G ++, il numero di byte per un galleggiante è quattro; Il numero di byte per un doppio è otto; Il numero di byte per un lungo doppio è sedici.
tipo vuoto
Con il compilatore G ++, la dimensione del tipo di vuoto è di un byte. Il byte non ha ufficialmente bit, il che significa che la sua posizione ha contenuti vuoti.
Modi per costruire tipi di composti
I tipi di composti sono tipi non finanziari. Ciò significa che i tipi composti sono tipi non scalari. Questa sezione spiega le basi dei tipi composti.
Array
Il seguente segmento di codice mostra una matrice di INT e una matrice 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 nominate. Considera il seguente segmento di codice:
enum a = 3, b, c;cout << b <<'\n';
L'output è: 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 è possibile creare molti oggetti della stessa unità generalizzata (istanziata). Il seguente programma mostra una classe e due oggetti, istanziati da esso. Tale oggetto è diverso da un oggetto scalare.
#includereUtilizzo dello spazio dei nomi std;
Classe thecla
pubblico:
int num = 5;
int fn ()
restituire num;
;
int main ()
Thecla obj1;
Thecla obj2;
cout << obj1.num << " << obj2.num <<'\n';
restituzione 0;
L'output è: 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 principale ().
Nota: NUM è un membro dei dati e FN è una funzione membro.
Unione
strumento
Una struttura è come un array ma invece di avere coppie indice/valore, ha coppie di nomi/valore. I nomi possono essere scritti in qualsiasi ordine. Il seguente programma mostra una struttura e il suo uso:
#includereUtilizzo dello spazio dei nomi std;
struct thecla
int num = 5;
float flt = 2.3;
char ch = 'a';
obj1, obj2;
int main ()
cout << obj2.num <<", "<< obj2.flt <<
"",<< obj2.ch <<'\n';
restituzione 0;
L'output è:
5, 2.3, aIl nome della struttura è Thecla. OBJ1 e OBJ2 sono due diversi oggetti della struttura.
Unione
Il seguente programma mostra un sindacato e il suo uso:
#includereUtilizzo dello spazio dei nomi std;
Union thecla
int num;
float flt = 2.3;
Char Ch;
obj1, obj2;
int main ()
cout << obj2.flt <<'\n';
restituzione 0;
L'output è: 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. Ognuno degli altri membri, num o ch, può avere un valore solo se il valore per FLT viene abbandonato.
Riferimenti
Un riferimento è sinonimo di identificatore. Il seguente segmento di codice mostra come ottenere un riferimento a un identificatore:
int id = 5;int & ref1 = id;
int & ref2 = id;
cout << id << " << ref1 <<
" << ref2 <<'\n';
L'output è: 5 5 5. Ref1 e Ref2 sono sinonimi di ID.
Riferimento di LValue e riferimento per la rValue
I riferimenti di cui sopra sono riferimenti a lValue. Il seguente codice mostra il riferimento RValue:
int && ref = 5;cout << ref <<'\n';
L'output è: 5. Questo riferimento viene creato senza identificare alcuna posizione in memoria. Per raggiungere questo obiettivo, Double ed è necessario, io.e., &&.
Pointer
Un puntatore non è proprio un'entità C ++. Tuttavia, fornisce uno schema migliore per affrontare i riferimenti. Il seguente codice mostra come creare un puntatore:
int ptdid = 5;int ptdid = 5;
int *ptrid;
ptrid = &ptdId;
cout << *ptrId <<'\n';
L'output è: 5. Nota la differenza in nome tra PTDID e PTDID. PTDID è l'oggetto appuntito e PTRID è l'oggetto puntatore. & ptdid restituisce l'indirizzo dell'oggetto appuntito assegnato a PTRID. Per restituire il valore dell'oggetto appuntito, usa *PTRID.
Funzioni
Funzione di base e la sua chiamata
Il seguente codice mostra una definizione di funzione di base e la sua chiamata:
#includereUtilizzo dello spazio dei nomi std;
int fn (int num)
cout<<"seen"<<'\n';
restituire num;
int main ()
int ret = fn (5);
cout << ret <<'\n';
restituzione 0;
L'output è
visto5
La chiamata di funzione è FN (5). Il nome della funzione è FN.
Riferimento e puntatore a una funzione
& fn restituire l'indirizzo in memoria della funzione il cui nome è FN. La seguente affermazione dichiara un puntatore a una funzione:
int (*func) ();Qui, Func è il nome del puntatore alla funzione. La prima coppia di parentesi differenzia questo puntatore di funzione da un puntatore dell'oggetto scalare. Func può essere fatto per contenere l'indirizzo di una funzione identificata da FN, come segue:
func = &fn;Il seguente programma mette in azione il riferimento e il puntatore della funzione:
#includereUtilizzo dello spazio dei nomi std;
int fn (int num)
/ * Alcune affermazioni */
restituire num;
int main ()
int (*func) (int);
func = &fn;
int ret = func (5);
cout << ret <<'\n';
restituzione 0;
L'output è: 5. Si noti che sia FN che Func hanno ciascuno il parametro INT nella dichiarazione.
Altri tipi composti
I tipi di composti di base sopra sono composti in se stessi. 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 MYINT = 55555555555555555;
cout << myInt <<'\n';
L'uscita è 5555555555555555555. Nel codice, IDUIL è diventato un tipo che sta per "Insigned Long Int".
Legame strutturato
Il legame strutturato è una caratteristica che consente di somministrare nomi ai subjects. Il seguente codice lo illustra per l'array:
int arr [3] = 1, 2, 3;auto [x, y, z] (arr);
cout << x <<"<< y <<"<< z <<'\n';
L'output è 1 2 3. Quindi, i valori: 1, 2, 3 sono stati dati i nomi, x, y, z. Nota l'uso e la posizione della parola riservata, auto. Inoltre, nota l'uso delle staffe quadrate.
Campo bit
La memoria è una sequenza di cellule. Ogni cella prende un byte. Inoltre, ogni byte è composto da otto bit. Un gruppo di bit, non necessariamente otto bit, può essere impostato e modificato. Un tale gruppo è chiamato un po 'di campo. Questi gruppi si mentirebbero uno accanto all'altro. Se i gruppi non costituiranno un tipo, diciamo 16 bit per un breve INT, vengono aggiunti bit di imbottitura. Il seguente codice lo illustra con la struttura:
data di strumentoShort Wkday non firmato: 3; // 3 bit
Brevi non firmati lunedì: 6; // 6 bit
Short non firmato Mon: 5; // 5 bit
Short Yr non firmato: 8; // 8 bit per 2 cifre
dte;
dte.wkday = 1; dte.Lunedì = 2; dte.mon = 2; dte.anno = 21;
cout << dte.mon <<'/'<< dte.monDay <<'/'<< dte.yr <<'\n';
L'output è: 2/2/21. Il numero totale di bit per wkday, lunedì e mon è 3 + 6 + 5 = 14. Quindi, verrebbero aggiunti due bit di imbottitura per compensare 16 bit per l'intero corto di 2 byte (16 bit). I successivi 8 bit iniziano il prossimo corto int, che viene quindi riempito con 8 bit di imbottitura.
NOTA: evitare l'uso di bit-field; Usalo solo per la ricerca.
Spazio dei nomi
Uno spazio dei nomi è un insieme di nomi, che non dovrebbe essere in conflitto con gli stessi nomi di altri set di nomi. Il seguente programma illustra l'uso degli stessi nomi da due spazi nomi diversi, applicati nello spazio dei nomi della funzione principale ():
#includereUtilizzo dello spazio dei nomi std;
spazio dei nomi NS1
int myint = 8;
float flt;
spazio dei nomi NS2
int myint = 9;
float flt;
int main ()
cout << NS1::myInt << '\n';
cout << NS2::myInt << '\n';
Ns1 :: flt = 2.5;
Ns2 :: flt = 4.8;
cout << NS1::flt << '\n';
cout << NS2::flt << '\n';
restituzione 0;
L'output è:
98
2.5
4.8
Ci sono due nomi Int in conflitto e due nomi fluttuanti in conflitto nel codice.
Specializzazione modello e modello
Lo schema del modello consente l'uso di un segnaposto per diversi possibili tipi scalari. La specializzazione sta scegliendo un particolare tipo scalare. Il seguente codice lo illustra per una funzione:
#includereUtilizzo dello spazio dei nomi std;
modello
void func (t cha, u no)
cout << "I need bread for " << cha << no << '.' << '\n';
int main ()
func ('$', 3);
restituzione 0;
L'output è:
Ho bisogno di pane per $ 3.Pacchetto parametri modello
I compilatori sono ancora per implementare completamente questa funzione - vedi più avanti.
Conclusione
I tipi C ++ esistono in due categorie: tipi fondamentali e tipi di composti. I tipi fondamentali sono tipi scalari. I tipi di composti di base sono array, enumerazioni, classi, sindacati, riferimenti, puntatori e funzioni. Questi tipi di composti di base vengono utilizzati per costruire tipi di composti elaborati, che sono typedef, legami strutturati, campi bit, spazio dei nomi e modelli.