Come usare la coda C ++

Una coda è una raccolta di articoli, in cui il primo elemento aggiunto nell'elenco, deve essere il primo elemento da rimuovere successivamente. Quindi, quando gli articoli vengono aggiunti alla raccolta, sta crescendo di dimensioni, io.e. sta crescendo in lunghezza. Ogni volta che qualsiasi articolo deve essere rimosso, deve essere il primo aggiunto. Se gli oggetti vengono rimossi continuamente, allora il prossimo rimosso, è il secondo elemento; Il terzo viene rimosso in seguito, e così via.

Dopo che il primo elemento dell'elenco originale è stato rimosso, il secondo diventa il primo elemento. Dopo che il secondo elemento è stato rimosso, il terzo diventa il primo elemento e così via.

Un buon esempio reale di una coda è quando le persone si schierano per aspettare il servizio o bene. La prima persona viene servita prima dell'ultima. Tuttavia, la coda parlata in questo tutorial, è la coda del software, come progettata in C++.

FIFO

FIFO sta per il primo in primo piano. È un altro modo di apprezzare la coda. Ciò significa che il primo elemento per inserire l'elenco è il primo elemento da rimuovere, ogni volta che si verifica la rimozione. L'inizio dell'elenco è chiamato testa o fronte; La fine dell'elenco è chiamata retro o coda.

Operazioni essenziali

Una coda di software deve avere almeno le seguenti operazioni:

spingere

Questa operazione aggiunge un nuovo elemento sul retro della coda. Questa operazione è ufficialmente chiamata, enqueue.

spostare

Questa operazione rimuove il primo elemento della coda e il secondo elemento diventa il nuovo primo elemento. Questa operazione è ufficialmente chiamata dequeue. Si chiama pop in c++.

Questo articolo spiega come utilizzare la struttura dei dati della coda C ++. Dovresti conoscere i puntatori e i riferimenti C ++ per comprendere il resto di questo articolo.

Classe e oggetti

Una classe è un insieme di variabili e funzioni che funzionano insieme, in cui le variabili non hanno valori assegnati. Quando i valori vengono assegnati alle variabili, la classe diventa un oggetto. Valori diversi dati alla stessa classe derivano in oggetti diversi; cioè, oggetti diversi sono la stessa classe con valori diversi. Si dice che la creazione di un oggetto da una classe stia istanziando l'oggetto.

Il nome, coda, è una classe. Un oggetto creato dalla classe coda ha un nome programmatore scelto.

È necessaria una funzione che appartiene a una classe per istanziare un oggetto dalla classe. In C ++, quella funzione ha lo stesso nome del nome della classe. Gli oggetti creati (istanziati) dalla classe hanno nomi diversi dati, dal programmatore.

Creazione di un oggetto dalla classe significa costruire l'oggetto; Significa anche istanziamento.

Un programma C ++ che utilizza la classe coda, inizia con le seguenti righe nella parte superiore del file:

#includere
#includere
Utilizzo dello spazio dei nomi std;

La prima riga è per input/output. La seconda riga è consentire al programma di utilizzare tutte le funzionalità della classe coda. La terza riga consente al programma di utilizzare i nomi nello spazio dei nomi standard.

Sovraccaricare una funzione

Quando due o più firme della funzione diverse hanno lo stesso nome, si dice che quel nome sia sovraccarico. Quando viene chiamata una funzione, il numero e il tipo di argomenti, determinare quale funzione viene effettivamente eseguita.

Costruzione

coda nome()

La seguente dichiarazione istanzia una coda denominata, que di tipo int.

coda que;

La coda è vuota. La dichiarazione inizia con la parola riservata, coda seguita da staffe angolari con il tipo di dati. Quindi hai il nome del programmatore per la coda.

Costruire con l'elenco di inizializzatore

La seguente definizione mostra come creare una coda con elenco di inizializzatori:

coda que (1.1, 2.2, 3.3, 4.4);

Distruggere una coda

Per distruggere una coda, lascialo andare fuori dalla portata.

Accesso agli elementi in coda

push (valore)

Una coda è un primo elenco. Quindi, ogni valore viene aggiunto da dietro. Il seguente segmento di codice crea una coda vuota, dopo di che vengono aggiunti cinque valori galleggianti:

coda que;
que.Push (1.1);
que.Push (2.2);
que.Push (3.3);
que.Push (4.4);
que.Push (5.5);

dimensione () const

Questo restituisce il numero di elementi nella coda. Il seguente codice illustra:

coda que;
que.Push (1.1); que.Push (2.2); que.Push (3.3); que.Push (4.4); que.Push (5.5);
cout << que.size() << '\n';

L'output è 5.

davanti()

Questo restituisce un riferimento al primo elemento della coda, senza rimuovere l'elemento. L'output del seguente codice è 1.1.

coda que;
que.Push (1.1); que.Push (2.2); que.Push (3.3); que.Push (4.4); que.Push (5.5);
cout << que.front() << '\n';

L'elemento non viene rimosso dalla coda.

Front () const

Quando la costruzione della coda è preceduta da const, l'espressione "front () const" viene eseguita al posto di "front ()". Viene utilizzato nel seguente codice, ad esempio.

coda const que (1.1, 2.2, 3.3, 4.4, 5.5);
cout << que.front() << '\n';

Viene restituito un riferimento costante. L'elemento non viene rimosso dal vettore. Gli elementi della coda non possono essere modificati.

Indietro()

Questo restituisce un riferimento all'ultimo elemento della coda, senza rimuovere l'elemento. L'output del seguente codice è 5.5.

coda que;
que.Push (1.1); que.Push (2.2); que.Push (3.3); que.Push (4.4); que.Push (5.5);
cout << que.back() << '\n';

Back () const

Quando la costruzione della coda è preceduta da const, l'espressione "back () const" viene eseguita invece di "back ()". Viene utilizzato nel seguente codice, ad esempio.

coda const que (1.1, 2.2, 3.3, 4.4, 5.5);
cout << que.back() << '\n';

Viene restituito un riferimento costante. L'elemento non viene rimosso dalla coda. Con il const precedente per la costruzione della coda, gli elementi in coda non possono essere modificati.

Capacità di coda

dimensione () const

- vedi sopra

vuoto () const

Questo restituisce 1 per vero se non ci sono elementi nella coda o 0 per false se la coda è vuota. Il seguente codice illustra questo:

coda que1 (1.1, 2.2, 3.3, 4.4, 5.5);
cout << que1.empty() << '\n';
coda Que2;
cout << que2.empty() << '\n';

L'output è:

0
1

Modificatori in coda

pop()

Una coda è FIFO, quindi qualsiasi elemento che deve essere rimosso deve essere rimosso dalla parte superiore (testa) della coda. Questa funzione membro rimuove il primo elemento senza restituirlo. Il seguente codice illustra questo:

coda que (1.1, 2.2, 3.3, 4.4, 5.5);
cout << que.front() << '\n';
que.pop();
cout << que.size() << '\n';

L'output è:

1.1
4

UN.scambiare (b)

È possibile scambiare due code, come illustrato in questo segmento di codice:

coda que1 (1.1, 2.2, 3.3, 4.4, 5.5);
coda que2 (10, 20);
Que1.Swap (Que2);
cout << "First element and size of que1:"
<< que1.front() <<", "<< que1.size() << '\n';
cout << "First element and size of que2 "<<
Que2.davanti() <<", "<< que2.size() << '\n';

L'output è:

Primo elemento e dimensione di Que1: 10, 2

Primo elemento e dimensione di Que2: 1.1, 5

Si noti che la lunghezza di una coda è aumentata se necessario. Inoltre, i valori che non avevano sostituzioni, sono sostituiti da un valore predefinito. I tipi di dati devono essere dello stesso tipo.

Uguaglianza e operatori relazionali per le code

Per i caratteri ordinari in C ++, in ordine crescente, i numeri vengono prima delle lettere maiuscole, che vengono prima delle lettere minuscole. Il personaggio spaziale viene prima dello zero e tutti loro.

Operatori di uguaglianza

Restituisce 1 per vero e 0 per false.

L'operatore ==

Restituisce 1 se le due code hanno le stesse dimensioni e gli elementi corrispondenti sono uguali; altrimenti restituisce 0. Esempio:

coda que1 ("kind", "qualcos'altro");
coda que2 ("malvagio");
int num = que1 == que2;
cout << num << '\n';

L'output è: 0.

IL != Operatore

- di fronte a quello sopra. Esempio:

coda que1 ("kind", "qualcos'altro");
coda que2 ("malvagio");
int num = que1 != que2;
cout << num << '\n';

L'output è: 1.

Operatori relazionali

Restituisce 1 per vero e 0 per false.

IL < Operator

Restituisce 1 se la prima coda è il sottoinsieme iniziale della seconda coda, con gli elementi delle due parti uguali che sono gli stessi e nello stesso ordine. Se entrambe le code hanno le stesse dimensioni o dimensioni diverse e si spostano da sinistra a destra, si incontra un elemento nella prima coda che è inferiore all'elemento corrispondente nella seconda coda, allora 1 verrà comunque restituito. Altrimenti 0 viene restituito. Esempio:

coda que1 ("kind", "qualcos'altro");
coda que2 ("malvagio");
int num = que1 < que2;
cout << num << '\n';

L'output è 1. < does not include the case when the size and order are the same.

L'operatore>

- di fronte a quello sopra. Esempio:

coda que1 ("kind", "qualcos'altro");
coda que2 ("malvagio");
int num = que1> que2;
cout << num << '\n';

Output: 0

IL <= Operator

- uguale a < but includes the case when the size and order are the same. Example:

coda que1 ("kind", "qualcos'altro");
coda que2 ("malvagio");
int num = que1 <= que2;
cout << num << '\n';

Output: 1

L'operatore> =

- di fronte a quello sopra. Esempio:

coda que1 ("kind", "qualcos'altro");
coda que2 ("malvagio");
int num = que1> = que2;
cout << num << '\n';

Output: 0

Classe e i suoi oggetti istanziati

Un valore è per un tipo di dati, poiché un oggetto istanziato è per una classe. La costruzione della coda può anche accettare una classe come tipo di dati. Il seguente programma illustra questo:

#includere
#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 obj1; Thecla obj2; Thecla obj3; Thecla obj4; Thecla obj5;
coda que;
que.push (obj1);
que.push (obj2);
que.push (obj3);
que.push (obj4);
que.push (obj5);
cout << que.size() << '\n';
restituzione 0;

L'output è 5.

Lista collegata

L'elenco delle code è tecnicamente chiamato un elenco collegato. Esistono due tipi di elenchi collegati per la coda: elenco singolarmente collegato e un elenco doppiamente collegato.

Un elemento elenco singolarmente collegato può essere implementato da una struttura di due membri. Un membro detiene un puntatore all'elemento successivo e l'altro membro detiene il dato (singolare per i dati).

Un elemento di elenco doppiamente collegato può essere implementato da una struttura di tre membri. Il membro centrale detiene il dato, mentre il primo e il terzo membro tengono puntatori ai loro elementi adiacenti.

Applicazioni della coda

La coda è una struttura di dati del primo in primo piano. Ci sono situazioni nel calcolo quando i dati arrivano sotto forma di una coda, che richiedono un comportamento al primo posto.

Condivisione delle risorse del computer

Una risorsa in un computer è qualsiasi componente fisico o virtuale di disponibilità limitata. Includono la CPU, la scheda video, il disco rigido e la memoria. La condivisione di tale risorsa ha bisogno di una coda.

Gestione degli interrupt

Le periferiche del computer devono interrompere il computer di volta in volta. Gli interrupt devono essere gestiti nello stesso modo in cui sono arrivati. Questo ha bisogno di una coda.

Gestisci informazioni.

La coda può essere utilizzata, ad esempio, per gestire i file dell'applicazione per un lavoro, se i file sono archiviati nel computer.

Conclusione

Una coda è una struttura dei dati dell'elenco, che è un elenco singolarmente collegato o un elenco doppiamente collegato. Di norma, il primo elemento che entra nell'elenco è il primo elemento a uscire. C ++ fornisce una struttura di dati in coda nella sua libreria standard. Le categorie di funzioni e operatori dei membri disponibili per questa struttura sono la costruzione della coda, l'accesso agli elementi della coda, la capacità di coda, i modificatori della coda e gli operatori sovraccarichi di code.

Qualsiasi struttura di dati in coda deve fornire almeno le funzioni del membro push () e pop (). push () significa inviare un nuovo elemento sul retro della coda; e pop () significa rimuovere l'elemento che si trova nella parte anteriore della coda. Sfortunatamente, in C ++, queste funzioni non restituiscono il valore spinto o scoppiato. Quindi, per conoscere l'ultimo elemento prima di spingere, è necessario utilizzare la funzione posteriore extra (); E per conoscere il primo elemento prima di scoppiare, è necessario utilizzare la funzione anteriore () extra.

Un valore è per un tipo di dati, poiché un oggetto istanziato è per una classe. Quindi, una particolare classe può essere utilizzata come tipo di dati per l'istanza del modello della coda. Oggetti diversi per la classe diventano valori diversi per la classe.

La coda ha applicazioni sul computer. Può essere utilizzato, ad esempio, per gestire i file dell'applicazione per un lavoro, se i file sono archiviati nel computer.