Come utilizzare i modelli C ++

Nella programmazione di base C ++, il tipo di dati, E.G., int o char, deve essere indicato in una dichiarazione o una definizione. Un valore come 4 o 22 o -5 è un int. Un valore come "a" o "b" o "c" è un char. Il meccanismo del modello consente al programmatore di utilizzare un tipo generico per un set di tipi reali. Ad esempio, il programmatore può decidere di utilizzare l'identificatore T per int o char. È possibile che un algoritmo C ++ abbia più di un tipo generico. Con, diciamo, T per l'int o Char, puoi rappresentare il tipo di galleggiante o puntatore. Una classe, come la stringa o la classe vettoriale, è come un tipo di dati e gli oggetti istanziati sono come valori del tipo di dati, che è la classe specificata. Pertanto, il meccanismo del modello consente anche al programmatore di utilizzare un identificatore di tipo generico per un insieme di classi.

Un modello C ++ crea un algoritmo indipendente dal tipo di dati utilizzati. Quindi, lo stesso algoritmo, con molte occorrenze dello stesso tipo, può usare tipi diversi a diverse esecuzioni. Le entità di variabile, funzione, struttura e classe possono avere modelli. Questo articolo spiega come dichiarare modelli, come definire i modelli e come applicarli in C++. Dovresti già conoscere le entità sopra menzionate per comprendere gli argomenti trattati in questo articolo.

Tipi

Scalare

I tipi scalari sono vuoti, bool, char, int, float e puntatore.

Classi come tipi

Una particolare classe può essere considerata come un tipo e i suoi oggetti come i valori.

Un tipo generico rappresenta un insieme di tipi scalari. L'elenco dei tipi scalari è esteso. Il tipo INT, ad esempio, ha altri tipi correlati, come Short Int, Long Int, ecc. Un tipo generico può anche rappresentare una serie di classi.

Variabile

Un esempio di dichiarazione e definizione del modello è il seguente:

modello T pi = 3.14;

Prima di continuare, si noti che questo tipo di affermazione non può apparire nella funzione principale () o in qualsiasi ambito di blocco. La prima riga è la dichiarazione della testa del modello, con il tipo generico scelto dal programmatore, T. La riga successiva è la definizione dell'identificatore, PI, che è di tipo generico, t. La precisione, se la T è un int o un galleggiante o qualche altro tipo, può essere eseguita nella funzione principale () () (o in qualche altra funzione). Tale precisione verrà eseguita con il PI variabile e non t.

La prima riga è la dichiarazione del tema. Questa dichiarazione inizia con la parola riservata, il modello e quindi le staffe angoli aperte e chiuse. All'interno delle parentesi angolari, esiste almeno un identificatore di tipo generico, come T, sopra. Può esserci più di un identificatore di tipo generico, con ciascuno preceduto dalla parola riservata, dattilico. Tali tipi generici in quella posizione sono chiamati parametri del modello.

La seguente dichiarazione può essere scritta in main () o in qualsiasi altra funzione:

cout << pi << '\n';

E la funzione verrebbe visualizzata 3.14. L'espressione Pi decide il tipo esatto di t per la variabile PI. La specializzazione decide il particolare tipo di dati per il parametro del modello. L'istanziazione è il processo interno C ++ di creazione del tipo particolare, come il galleggiante, in questo caso. Non confondere tra l'istanziazione di un parametro modello e l'istanza di una classe. Nell'argomento del modello, molti tipi di dati possono avere un nome di tipo generico, mentre molte classi possono avere un nome di classe generico. Tuttavia, il nome di classe generico per le classi viene semplicemente indicato come una classe e non come nome di classe. Inoltre, un valore è per un tipo di dati, come l'int, poiché un oggetto istanziato è per una classe, come la classe stringa.

Alla specializzazione, il tipo di dati scelto, come il galleggiante, viene posizionato tra parentesi angolari dopo la variabile. Se c'è più di un parametro modello nella dichiarazione della testa del modello, ci sarà un numero corrispondente di tipi di dati nello stesso ordine nell'espressione di specializzazione.

Alla specializzazione, un tipo è noto come argomento modello. Non confondere tra questo e l'argomento della funzione per la chiamata.

Tipo predefinito

Se non viene riportato alcun tipo alla specializzazione, si assume il tipo di predefinito. Quindi, dalla seguente espressione:

modello U pi = "amore";

Questa camma deve essere utilizzata come tale con un tipo predefinito:

cout << pi << '\n';

Per cui "amore" per il puntatore costante a char viene usato come predefinito dal modello. Nota nella dichiarazione che u = const char*. Le staffe angolari saranno vuote alla specializzazione (nessun tipo indicato); Il tipo effettivo è considerato un puntatore const a char, il tipo predefinito. Se fosse necessario qualche altro tipo alla specializzazione, il nome di tipo verrebbe scritto tra parentesi angolari. Quando il tipo predefinito è desiderato alla specializzazione, ripetere il tipo tra parentesi angolari è facoltativo, i.e., Le staffe angoli possono essere lasciate vuote.

Nota: il tipo predefinito può ancora essere modificato alla specializzazione avendo un tipo diverso.

strumento

L'esempio seguente mostra come utilizzare un parametro modello con una struttura:

modello Struttion Età

T John = 11;
T peter = 12;
T Maria = 13;
T gioia = 14;
;

Questi sono secoli di studenti in un voto (classe). La prima riga è la dichiarazione del modello. Il corpo in parentesi graffe è la definizione effettiva del modello. Le età possono essere emesse nella funzione principale () con quanto segue:

Secoli grado 7;
cout << grade7.John << " << grade7.Mary << '\n';

L'output è: 11 13. La prima dichiarazione qui esegue la specializzazione. Nota come è stato realizzato. Dà anche un nome per un oggetto della struttura: Grado7. La seconda dichiarazione ha espressioni di oggetti struct ordinari. Una struttura è come una classe. Qui, i secoli sono come un nome di classe, mentre Grado7 è un oggetto della classe (Struttura).

Se alcune età sono numeri interi e altre sono galleggianti, allora la struttura necessita di due parametri generici, come segue:

modello Struttion Età

T John = 11;
U peter = 12.3;
T Maria = 13;
U gioia = 14.6;
;

Un codice pertinente per la funzione principale () è il seguente:

Secoli grado 7;
cout << grade7.John << " << grade7.Peter << '\n';

L'output è: 11 12.3. Alla specializzazione, l'ordine dei tipi (argomenti) deve corrispondere all'ordine dei tipi generici nella dichiarazione.

La dichiarazione del modello può essere separata dalla definizione, come segue:

modello Struttion Età

T John;
U peter;
T Maria;
U gioia;
;
Secoli Grade7 = 11, 12.3, 13, 14.6;

Il primo segmento di codice è puramente una dichiarazione di un modello (non ci sono incarichi). Il secondo segmento di codice, che è solo un'istruzione, è la definizione dell'identificatore, Grado7. Il lato sinistro è la dichiarazione dell'identificatore, Grado7. Il lato destro è l'elenco di inizializzatore, che assegna i valori corrispondenti ai membri della struttura. Il secondo segmento (istruzione) può essere scritto nella funzione principale (), mentre il primo segmento rimane al di fuori della funzione principale ().

Non tipo

Esempi di tipi non dati includono INT, puntatore a oggetto, puntatore alla funzione e tipi automatici. Ci sono altri non tipi, che questo articolo non affronta. Un non tipo è come un tipo incompleto, il cui valore viene dato in seguito e non può essere modificato. Come parametro, inizia con un particolare non tipo, seguito da un identificatore. Il valore dell'identificatore viene dato in seguito, alla specializzazione, e non può essere modificato di nuovo (come una costante, il cui valore viene dato in seguito). Il seguente programma illustra questo:

#includere
Utilizzo dello spazio dei nomi std;
modello Struttion Età

T John = n;
U peter = 12.3;
T Mary = n;
U gioia = 14.6;
;
int main ()

Secoli grado 7;
cout << grade7.John << " << grade7.Joy << '\n';
restituzione 0;

Alla specializzazione, il primo tipo, int, tra parentesi angolari è lì di più per la formalità, per assicurarsi che il numero e l'ordine dei parametri corrispondano al numero e all'ordine dei tipi (argomenti). Il valore di n è stato dato alla specializzazione. L'output è: 11 14.6.

Specializzazione parziale

Supponiamo che un modello abbia quattro tipi generici e che, tra i quattro tipi, è necessario due tipi predefiniti. Ciò può essere ottenuto utilizzando il costrutto di specializzazione parziale, che non utilizza l'operatore di assegnazione. Quindi, il costrutto di specializzazione parziale fornisce valori predefiniti a un sottoinsieme di tipi generici. Tuttavia, nello schema di specializzazione parziale, sono necessarie una classe di base (struttura) e una classe di specializzazione parziale (struttura). Il seguente programma lo illustra per un tipo generico su due tipi generici:

#includere
Utilizzo dello spazio dei nomi std;
// classe modello di base
modello
Struttion Età

;
// specializzazione parziale
modello
Struttion Età

T1 John = 11;
fluttuare peter = 12.3;
T1 mary = 13;
Gioia fluttuante = 14.6;
;
int main ()

Secoli grado 7;
cout << grade7.John << " << grade7.Joy << '\n';
restituzione 0;

Identifica la dichiarazione della classe base e la sua definizione di classe parziale. La dichiarazione della testa del modello della classe base ha tutti i parametri generici necessari. La dichiarazione del modello del modello della classe di specializzazione parziale ha solo il tipo generico. Esiste una serie extra di parentesi angolari utilizzate nello schema che arriva subito dopo il nome della classe nella definizione di specializzazione parziale. È ciò che effettivamente fa la specializzazione parziale. Ha il tipo predefinito e il tipo di non default, nell'ordine scritto nella classe base. Si noti che il tipo predefinito può ancora essere somministrato un tipo diverso nella funzione principale ().

Il codice pertinente nella funzione principale () può essere il seguente:

Secoli grado 7;
cout << grade7.John << " << grade7.Joy << '\n';

L'output è: 11 14.6.

Pacchetto parametri modello

Un pacchetto di parametri è un parametro modello che accetta zero o più tipi generici del modello per i tipi di dati corrispondenti. Il parametro del pacchetto parametri inizia con il tipografia o la classe riservata. Questo è seguito da tre punti, quindi l'identificatore per il pacchetto. Il seguente programma illustra come un pacchetto di parametri modello può essere utilizzato con una struttura:

#includere
Utilizzo dello spazio dei nomi std;
modello Struttion Età

int John = 11;
fluttuare peter = 12.3;
int Mary = 13;
Gioia fluttuante = 14.6;
;
int main ()

Secoli GradeB;
cout << gradeB.John << " << gradeB.Mary << '\n';
Secoli Gradec;
cout << gradeC.Peter << " << gradeC.Joy << '\n';
Secoli grado;
cout << gradeD.John << " << gradeD.Joy << '\n';
Età Gradea; // Mi piace il default
cout << gradeA.John << " << gradeA.Joy << '\n';
restituzione 0;

L'output è:

11 13
12.3 14.6
11 14.6
11 14.6

Modelli di funzione

Le caratteristiche del modello sopra menzionate si applicano in modo simile ai modelli di funzione. Il seguente programma mostra una funzione con due parametri del modello generico e tre argomenti:

#includere
Utilizzo dello spazio dei nomi std;
modello void func (t no, u cha, const char *str)
cout << "There are " << no << " books worth " << cha << str << " in the store." << '\n';

int main ()
func (12, '$', "500");
restituzione 0;

L'output è il seguente:

Ci sono 12 libri per un valore di $ 500 nel negozio.

Separazione dal prototipo

La definizione della funzione può essere separata dal suo prototipo, come mostra il seguente programma:

#includere
Utilizzo dello spazio dei nomi std;
modello void func (t no, u cha, const char *str);
modello void func (t no, u cha, const char *str)
cout << "There are " << no << " books worth " << cha << str << " in the store." << '\n';

int main ()
func (12, '$', "500");
restituzione 0;

Nota: La dichiarazione del modello di funzione non può apparire nella funzione principale () o in qualsiasi altra funzione.

Sovraccarico

Il sovraccarico della stessa funzione può avvenire con diverse dichiarazioni della testa di modello. Il seguente programma illustra questo:

#includere
Utilizzo dello spazio dei nomi std;
modello void func (t no, u cha, const char *str)
cout << "There are " << no << " books worth " << cha << str << " in the store." << '\n';

modello void func (t no, const char *str)
cout << "There are " << no << " books worth $" << str << " in the store." << '\n';

int main ()

func (12, '$', "500");
func (12, "500");
restituzione 0;

L'output è:

Ci sono 12 libri per un valore di $ 500 nel negozio.

Ci sono 12 libri per un valore di $ 500 nel negozio.

Modelli di classe

Le caratteristiche dei modelli sopra menzionati si applicano in modo simile ai modelli di classe. Il seguente programma è la dichiarazione, la definizione e l'uso di una semplice classe:

#includere
Utilizzo dello spazio dei nomi std;
Classe thecla

pubblico:
int num;
Statico Char Ch;
void func (char cha, const char *str)
cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';

statico void fun (char ch)
if (ch == 'a')
cout << "Official static member function" << '\n';

;
int main ()

Thecla obj;
obj.num = 12;
obj.func ('$', "500");
restituzione 0;

L'output è il seguente:

Ci sono 12 libri per un valore di $ 500 nel negozio.

Il seguente programma è il programma di cui sopra con una dichiarazione di testa di modello:

#includere
Utilizzo dello spazio dei nomi std;
modello Classe thecla

pubblico:
T num;
statico u ch;
void func (u cha, const char *str)
cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';

statico void fun (u ch)
if (ch == 'a')
cout << "Official static member function" << '\n';

;
int main ()

Thecla obj;
obj.num = 12;
obj.func ('$', "500");
restituzione 0;

Invece del tylename di Word nell'elenco dei parametri del modello, è possibile utilizzare la classe Word. Nota la specializzazione nella dichiarazione dell'oggetto. L'output è sempre la stessa:

Ci sono 12 libri per un valore di $ 500 nel negozio.

Dichiarazione di separazione

La dichiarazione del modello di classe può essere separata dal codice di classe, come segue:

modello Classe thecla;
modello class thecla
pubblico:
T num;
statico u ch;
void func (u cha, const char *str)
cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';

statico void fun (u ch)
if (ch == 'a')
cout << "Official static member function" << '\n';

;

Affrontare i membri statici

Il seguente programma mostra come accedere a un membro dei dati statici e una funzione membro statico:

#includere
Utilizzo dello spazio dei nomi std;
modello class thecla
pubblico:
T num;
statico u ch;
void func (u cha, const char *str)
cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';

statico void fun (u cha)
if (ch == 'a')
cout << "Official static member function" << cha << '\n';

;
modello U thecla:: ch = 'a';
int main ()

Thecla::divertimento('.');
restituzione 0;

Assegnare un valore a un membro dei dati statici è una dichiarazione e non può essere in main (). Nota l'uso e le posizioni dei tipi generici e il tipo di dati generici nell'istruzione di assegnazione. Inoltre, si noti che la funzione del membro dei dati statico è stata chiamata in main (), con i tipi di dati del modello effettivo. L'output è il seguente:

Funzione ufficiale dei membri statici.

Compilazione

La dichiarazione (intestazione) e la definizione di un modello devono essere in un file. Cioè, devono essere nella stessa unità di traduzione.

Conclusione

I modelli C ++ creano un algoritmo indipendente dal tipo di dati utilizzati. Le entità di variabile, funzione, struttura e classe possono avere modelli, che comportano dichiarazioni e definizioni. La creazione di un modello comporta anche una specializzazione, che è quando un tipo generico prende un tipo reale. La dichiarazione e la definizione di un modello devono essere entrambi in un'unità di traduzione.