Sistema di tipi C++ (C++ moderno)
Il concetto di tipo è molto importante in C++.Ogni variabile, argomento della funzione e valore restituito della funzione deve avere un tipo per essere compilato.Inoltre, ogni espressione (valori letterali compresi i in modo implicito viene assegnato un tipo dal compilatore prima che venga valutata.Alcuni esempi di tipi includono int per archiviare i valori integrali, double per archiviare valori a virgola mobile conosciuti anche come tipi di dati scalari ), o la classe standard std::basic_string di libreria per archiviare il testo.È possibile creare un tipo definito class o struct.Il tipo indica la quantità di memoria che verrà allocata per la variabile o il risultato di l), i tipi di valori che possono essere archiviati in tale variabile, come i valori quali schemi di bit) sono interpretati e le operazioni che possono essere eseguite su.In questo articolo sono contenuti cenni preliminari informali le funzionalità principali del sistema di tipi C++.
Terminologia
Variabile: Il nome simbolico di una quantità di dati per poter utilizzare il nome per accedere ai dati si riferisce in qualsiasi ambito del codice in cui è definito.In C++, la "variabile" è solitamente utilizzato per fare riferimento a istanze dei tipi di dati scalari, mentre le istanze di altri tipi in genere vengono definite "oggetto".
Oggetto: Per semplicità e coerenza, questo articolo viene utilizzato il termine "oggetto" per fare riferimento a qualsiasi istanza di una classe o struttura e quando viene utilizzato in genere inclusi tutti i tipi, anche variabili scalari.
Tipo POD (dati non aggiornati normali): Questa categoria informale di tipi di dati in C++ fa riferimento ai tipi che sono scalari (vedere la sezione fondamentale dei tipi) o sono classi POD.Una classe POD non dispone di membri dati statici che non vengono inoltre baccelli e non ha costruttori definiti dall'utente, distruttori definiti dall'utente, o operatori di assegnazione definiti dall'utente.Inoltre, una classe POD non dispone di funzioni virtuali, classe base e membri dati non privati e protetti di non statici.I tipi POD vengono spesso utilizzati per lo scambio di dati esterni, ad esempio con un modulo scritto nel linguaggio C (con tipi POD solo).
Specificare i tipi di funzione e di variabile
C++ è un linguaggio fortemente tipizzato e anche statico- viene digitata; ogni oggetto non ha mai modifiche di quel tipo e un tipo (non confondere con gli oggetti dati statici).
Quando si dichiara una variabile nel codice, è necessario specificare il tipo in modo esplicito, o utilizzare la parola chiave di auto per indicare al compilatore di dedurre il tipo dall'inizializzatore.
Quando si dichiara una funzione nel codice, è necessario specificare il tipo di ogni argomento e del valore restituito, o void se nessun valore restituito dalla funzione.L'eccezione è quando si utilizza i modelli di funzione, che consentono degli argomenti dei tipi arbitrari.
Dopo aver prima dichiara una variabile, non è possibile modificarne il tipo solo ad alcuni passaggio successivo.Tuttavia, è possibile copiare il valore restituito del valore della variabile o di una funzione in un'altra variabile di tipo differente.Tali operazioni sono chiamate conversioni di tipo, che sono necessarie talvolta ma sono anche origini potenziali di perdita di informazioni di scorrettezza.
Quando si dichiara una variabile di tipo POD, si consiglia vivamente la inizializza, ovvero fornire un valore iniziale.Finché non inizializzare una variabile, con un valore di "operazione" costituito da qualsiasi di bit sono sembrato in precedenza per essere in tale posizione di memoria.Si tratta di un aspetto importante di C++ da ricordare, specialmente se si osservino da un altro linguaggio che gestisce l'inizializzazione automaticamente.Quando si dichiara una variabile del tipo di classe non POD, il costruttore gestisce l'inizializzazione.
L'esempio seguente illustra alcune dichiarazioni delle variabili semplici con alcune descrizioni di essi.Nell'esempio viene inoltre illustrato come il compilatore utilizza le informazioni sul tipo per consentire o meno determinate operazioni successive nella variabile.
int result = 0; // Declare and initialize an integer.
double coefficient = 10.8; // Declare and initialize a floating
// point value.
auto name = "Lady G."; // Declare a variable and let compiler
// deduce the type.
auto address; // error. Compiler cannot deduce a type
// without an intializing value.
age = 12; // error. Variable declaration must
// specify a type or use auto!
result = "Kenny G."; // error. Can’t assign text to an int.
string result = "zero"; // error. Can’t redefine a variable with
// new type.
int maxValue; // Not recommended! maxValue contains
// garbage bits until it is initialized.
Tipi fondamentali (predefinito)
A differenza di alcuni linguaggi, C++ non ha un tipo di base universale che tutti gli altri tipi siano derivati.L'implementazione di Visual C++ del linguaggio include molti tipi di base, noti anche come tipi incorporati.Inclusi i tipi numerici int, double, long, bool, più tipi di wchar_t e di char per ASCII e caratteri unicode, rispettivamente.I tipi di base (eccetto bool, double, wchar_t e tipi correlati) hanno tutti versioni senza segno, che modificano l'intervallo di valori che la variabile può archiviare.Ad esempio, int, che archivia un intero con segno a 32 bit, può rappresentare un valore da -2.147.483.648 a 2.147.483.647.unsigned int, che viene archiviato come 32 bit/x86, è possibile memorizzare un valore da 0 a 4.294.967.295.Il numero totale dei valori possibili in ogni caso è lo stesso; unicamente l'intervallo è diverso.
I tipi fondamentali sono riconosciuti dal compilatore, di regole incorporate che regolano le operazioni che è possibile eseguire su di essi e come possono essere convertite in altri tipi fondamentali.Per un elenco completo dei tipi incorporati e della relativa numerici e di dimensione, vedere Tipi di base (C++).
Di seguito vengono mostrate le dimensioni relative dei tipi incorporati:
.png "Dimensione in byte di tipi predefiniti")
Nella tabella seguente sono elencati più di frequente i tipi fondamentali utilizzati:
Type |
Dimensione |
Commento |
|---|---|---|
int |
4 byte |
La scelta predefinita per i valori integrali. |
double |
8 byte |
La scelta predefinita per i valori a virgola mobile. |
bool |
1 byte |
Rappresenta i valori che possono essere true o false. |
char |
1 byte |
Utilizzo di caratteri ASCII nelle stringhe di tipo C precedenti o oggetti std::string che non dovranno mai essere convertiti in UNICODE. |
wchar_t |
2 byte |
Rappresenta gli "a" valori di caratteri che possono essere codificati nel formato di UNICODE (UTF-16 sulle finestre, altri sistemi operativi può differire).Questo tipo di carattere utilizzato in serie di tipo std::wstring. |
unsigned char |
1 byte |
C++ non è di tipo incorporato di byte.Utilizzare char senza segno rappresentare un valore byte. |
unsigned int |
4 byte |
Scelta predefinita per i flag di bit. |
tempo tempo |
8 byte |
Rappresenta i valori Integer molto grandi. |
Il tipo void
Il tipo di void è un tipo speciale, non è possibile dichiarare una variabile di tipo void, ma è possibile dichiarare una variabile di tipo void * (puntatore a void), che è necessario talvolta si alloca memoria (non memorizzato) non elaborata.Tuttavia, i puntatori a void non sono indipendenti dai tipi e il relativo utilizzo è consigliato in genere forte in C++ moderno.In una dichiarazione di funzione, un valore restituito di void significa che la funzione non restituisce un valore, si tratta di un comune e un utilizzo eccessivo di void.Mentre il linguaggio C richiede le funzioni che hanno parametri zero per dichiarare void nell'elenco di parametri, ad esempio, fou(void), questa pratica è sconsigliata in C++ moderno e deve essere fou()dichiarato.Per ulteriori informazioni, vedere Conversioni di tipi e l'indipendenza dai tipi (C++ moderno).
qualificatore di tipo const
Qualsiasi incorporato o tipo definito dall'utente può essere qualificato dalla parola chiave const.Inoltre, le funzioni membro possono essere const- qualificato e persino const- di overload.Il valore di un tipo di const non può essere modificato dopo l'inizializzazione.
const double PI = 3.1415;
PI = .75 //Error. Cannot modify const variable.
Il qualificatore di const viene utilizzato spesso nella funzione e le dichiarazioni di variabili e la precisione "const" è un concetto importante in C++, essenzialmente si intende utilizzare const per garantire, in fase di compilazione, i valori non sono in modo non intenzionale modificato.Per ulteriori informazioni, vedere const (C++).
Un tipo di const è diverso dalla versione non const; ad esempio, const int è un tipo diverso da int.È possibile utilizzare l'operatore C++ const_cast nei rari casi quando è necessario rimuovere il sarà ness da una variabile.Per ulteriori informazioni, vedere Conversioni di tipi e l'indipendenza dai tipi (C++ moderno).
Tipi di stringa
In teoria, il linguaggio C++ non è di tipo incorporato "stringa"; char e caratteri singoli file di wchar_t – è necessario dichiarare una matrice di questi tipi per ottenere un'approssimazione in una stringa, aggiungendo un valore null di terminazione (ad esempio, ‘\0’ASCII) all'elemento di matrice uno dopo l'ultimo carattere valido denominato anche "una stringa di tipo C ").Stringhe di tipo C richiedono molto più codice di essere scritte o l'utilizzo delle funzioni esterne della libreria di servizio della stringa.Ma in C++ moderno, nei tipi standard std::string (per le stringhe di caratteri tipe di chara 8 bit) o std::wstring libreria (per le stringhe di caratteri tipe di wchar_ta 16 bit.Questi contenitori STL possono essere considerati come tipi nativi di stringa perché fanno parte delle librerie standard inclusi nell'ambiente operativo di compilazione C++.Utilizzare semplicemente la direttiva di #include <string> per rendere questi tipi nel programma.Se si utilizza MFC o ATL, la classe di CString è anche disponibile, ma non fa parte dello standard C++.) L'utilizzo delle matrici di caratteri con terminazione null (stringhe di tipo C menzionate) è fortemente sconsigliato in C++ moderno.Per ulteriori informazioni su come determinare il tipo della stringa da utilizzare in un programma moderno C++ e la conversione tra diversi tipi, vedere a Stringhe e testo (C++ moderno).
Tipi definiti dall'utente
Quando si definisce class, struct, union, o enum, che il costrutto è utilizzato nel resto del codice come se fosse un tipo fondamentale.Ha una dimensione nota in memoria e alcune regole su come può essere utilizzata si applicano a per fase di compilazione che controlla e, nel runtime, per la durata del programma.Le differenze principali tra tipi incorporati e tipi definiti dall'utente fondamentali sono:
Il compilatore non ha familiarità incorporata di un tipo definito dall'utente."Impara" tipo1 la prima volta che rileva la definizione durante il processo di compilazione.
Specificare le operazioni possono essere eseguite sul tipo e può essere convertito in altri tipi, definendo (con l'overload degli operatori appropriati, quali i membri della classe o funzioni non membro.Per ulteriori informazioni, vedere L'overload.
Non devono essere scritti in modo statico (la regola che un tipo di oggetto non modifica mai).Tramite meccanismi di ereditarietà e polimorfismo, una variabile dichiarata come tipo definito dall'utente di classe (definita come istanza di oggetto classe) potrebbe avere un tipo diverso in esecuzione che in fase di compilazione.Per ulteriori informazioni, vedere Classi derivate.
Tipi puntatore
Datando da versioni precedenti del linguaggio C, C++ continua a possibile dichiarare una variabile di un tipo di puntatore utilizzando il dichiaratore speciale * asterisco ().Un tipo di puntatore archivia l'indirizzo della posizione di memoria in cui il valore effettivo di dati viene archiviato.In C++ moderno, definiti i puntatori non elaboratie si accede nel codice mediante gli operatori speciali * asterisco () o -> (trattino con il maggiore).Si tratta di dereferenziaree quali quello da utilizzare varia a seconda della dereferenziazione di un puntatore a un valore scalare o un puntatore a un membro di un oggetto.Utilizzo di tipi di puntatore long è stato uno degli aspetti più provocatori e più confusione c e C++ per lo sviluppo di programmi.In questa sezione vengono descritti i fatti e pratiche consente di utilizzare i puntatori non elaborati se lo si desidera, ma in C++ moderno più richiesto (o non è consigliato) di utilizzare i puntatori non elaborati per proprietà dell'oggetto affatto, a causa dell'evoluzione di puntatore intelligente (esaminato più alla fine di questa sezione).È inoltre utile e sicuro utilizzare i puntatori non elaborati per il commento di oggetti, ma se è necessario utilizzarli per proprietà dell'oggetto, è necessario farlo con cautela e molto opportuno valutare attentamente come gli oggetti di proprietà da esse vengono creati e viene eliminato.
La prima operazione che è necessario conoscere sta dichiarando una variabile puntatore non elaborato allocherà solo la memoria necessaria per archiviare un indirizzo della posizione di memoria che il puntatore faccia riferimento a quando viene derefenziato.L'allocazione della memoria per il valore di dati stessa (anche denominato archivio di backup) non è ancora stata allocata.Ovvero la dichiarazione di una variabile puntatore non elaborato, si crea una variabile dell'indirizzo di memoria, non la stessa variabile di dati.La dereferenziazione di un puntatore variabile prima di assicurarsi che contenga un indirizzo valido a un archivio di backup genera un comportamento indefinito in genere un errore irreversibile) nel programma.Nell'esempio seguente viene illustrato questo tipo di errore:
int* pNumber; // Declare a pointer-to-int variable.
*pNumber = 10; // error. Although this may compile, it is
// a serious error. We are dereferencing an
// uninitialized pointer variable with no
// allocated memory to point to.
L'esempio dereferenziazione di un tipo di puntatore senza apportare alcuna allocare memoria per archiviare i dati effettivi Integer o un indirizzo di memoria valido assegnati.Il codice seguente risolve questi errori:
int number = 10; // Declare and initialize a local integer
// variable for data backing store.
int* pNumber = &number; // Declare and initialize a local integer
// pointer variable to a valid memory
// address to that backing store.
...
*pNumber = 41; // Dereference and store a new value in
// the memory pointed to by
// pNumber, the integer variable called
// “number”. Note “number” was changed, not
// “pNumber”.
La memoria locale corretta dello stack dell'esempio di codice per la creazione dell'archivio di backup che indica pNumber.Viene utilizzato un tipo fondamentale per semplicità.In pratica, l'archivio di backup dei puntatori è più frequentemente tipi definiti da dinamico- vengono allocati in un'area della memoria definita heap (o "archive formato ") utilizzando un'espressione di parole chiave di new (nella programmazione di tipo C, la funzione precedente della libreria di runtime di malloc() C è stato utilizzato).Una volta che viene allocata, queste variabili "" genere vengono definite anche "e", specialmente se sono basate sulla definizione di classe.La memoria allocata con new eliminare da un'istruzione corrispondente di delete o, se è stata utilizzata la funzione di malloc() per allocare, la funzione free()runtime c).
Tuttavia, è facile dimenticare di eliminare un oggetto dinamico- allocato nel codice particolarmente complesso, generando un bug di risorse denominato una perdita di memoria.Per questo motivo, l'utilizzo dei puntatori non elaborati è fortemente sconsigliato in C++ moderno.È quasi sempre consigliabile eseguire il wrapping di un puntatore non elaborato in puntatore intelligente, che vengono automaticamente rimuoveranno la memoria quando il relativo distruttore viene chiamato (quando il codice esce dall'ambito del puntatore intelligente); tramite puntatori intelligenti di eliminare un'intera classe di bug nei programmi C++.Nell'esempio seguente, si supponga MyClass è un tipo definito dall'utente che ha un metodo DoSomeWork();pubbliche
void someFunction() {
unique_ptr<MyClass> pMc(new MyClass);
pMc->DoSomeWork();
}
// No memory leak. Out-of-scope automatically calls the destructor
// for the unique_ptr, freeing the resource.
Per ulteriori informazioni sui puntatori intelligenti, vedere Puntatori intelligenti (C++ moderno).
Per ulteriori informazioni sulle conversioni di puntatore, vedere Conversioni di tipi e l'indipendenza dai tipi (C++ moderno).
Per ulteriori informazioni sui puntatori vedere in genere Puntatori.
Tipi di dati Windows
Nella programmazione classica Win32 per c e C++, la maggior parte delle funzioni utilizzano i typedef input specifici e le macro #define (definite in windef.h) per specificare i tipi di parametri e valori restituiti.Questi "tipi di dati Windows" sono principalmente solo nomi speciali (alias) forniti ai tipi incorporati C/C++.Per un elenco completo dei typedef e definizioni del preprocessore, vedere Windows Data Types.Alcuni di questi typedef, come HRESULT e LCID, utili e descrittivi.Altri, come INT, non hanno un significato speciale e sono solo alias per i tipi fondamentali di C++.Altri tipi di dati Windows cui nomi vengono mantenuti dai giorni dei processori di programma C e a 16 bit E non hanno scopo o significato su hardware o nei sistemi operativi moderni.Esistono inoltre tipi di dati speciali associati alla libreria di runtime di Windows, elencata tra Windows Runtime base data types.In C++ moderno, l'orientamento è preferibile dei tipi fondamentali di C++ a meno che il tipo di Windows comunicare il significato ulteriore su come valore deve essere interpretato.
Ulteriori informazioni
Per ulteriori informazioni sul sistema di tipi C++, vedere i seguenti argomenti.
Vengono descritti i tipi di valore con i problemi relativi al relativo utilizzo. |
|
Vengono descritti i problemi e mostra conversione di tipi comuni come evitarli. |