STL stack fornisce la funzionalità di una struttura di dati dello stack in C++.

Segue la struttura dei dati dello stack LIFO (Last In First Out) principio. Cioè, l’ultimo elemento aggiunto verrà rimosso per primo.

Stack struttura dati

Per saperne di più sugli stack, visita il nostro tutorial su Stack Data Structure.

Creare Stack

Per creare uno stack in C++, dobbiamo prima includere stack file di intestazione.

#include <stack>

Una volta importato questo file, possiamo creare stack utilizzando la seguente sintassi:

stack<type> st;

Qui, type indica il tipo di dati questo comando questo comando vogliamo memorizzare nello stack. Ad esempio,

// create a stack of integers
 stack<int> integer_stack; 
// create a stack of strings
stack<string> string_stack;

Esempio: stack STL C++

#include <iostream>

#include <stack>

using namespace std;

int main {
    // create a stack of strings

stack<string> languages;

    
    // add element to the Stack
    languages.push("C++");
    languages.push("Java");
    languages.push("Python");
    
    // print top element
    cout << languages.top;

    return 0;
}

Output

Python

Nell’esempio sopra, abbiamo creato stack di stringhe denominate lingue .

Qui, abbiamo usato push per aggiungere elementi alla pila. Abbiamo poi utilizzato top per visualizzare l’elemento superiore.

Impareremo di più push e top più avanti nel tutorial.

Stack metodi

In C++, stack class fornisce vari metodi per eseguire diverse operazioni su uno stack.

Operazione Descrizione
push aggiunge un elemento allo stack
pop rimuove un elemento dallo stack
top restituisce l’elemento in cima allo stack
size restituisce il numero di elementi nello stack
empty ritorna true se la pila è vuota

Aggiungi elemento allo stack

Noi usiamo push per aggiungere un elemento in uno stack. Ad esempio,

#include <iostream>

#include <stack>

using namespace std;

int main {

  // create a stack of strings
  stack<string> colors;

// inserisce gli elementi nello stack colors.push(“Red”); colors.push(“Orange”);

  
  cout << "Stack: ";

  // print elements of stack
   while(!colors.empty) {
    cout << colors.top << ", ";
    colors.pop;
  }
 
  return 0;
}

Output

Stack: Orange, Red, 

Nell’esempio sopra, abbiamo creato una pila di stringhe chiamata colori. Quindi, abbiamo usato push per aggiungere elementi alla pila.

colors.push("Red");
colors.push("Orange");

Invece di stampare direttamente il contenuto della pila, abbiamo usato while loop e vari metodi di stack.

while(!colors.empty) {
  cout << colors.top << ", ";
  colors.pop;
}

Per stampare tutti gli elementi della pila, stampiamo il suo top element poi pop(rimuoverlo) all’interno del ciclo. Questo processo continua ripetutamente finché lo stack non è vuoto.

Impareremo pop, top e empty nelle prossime sezioni.

Si noti inoltre che abbiamo inserito gli elementi in questo ordine: {“Red”, “Orange”}.

Ma quando si stampano gli elementi, otteniamo {“Orange”, “Red”}.

Questo perché lo stack è una struttura dati LIFO, il che significa che l’elemento inserito per ultimo viene recuperato per primo.

Nota: a differenza di vettori o altri contenitori, non possiamo utilizzare un intervallo for loop per scorrere uno stack. Ciò è dovuto al fatto che lo stack STL è un adattatore contenitore STL, che fornisce un accesso restrittivo per farlo comportare come una struttura di dati stack standard.

Rimuovi elementi da Stack

Possiamo rimuovere un elemento dallo stack usando pop. Ad esempio,

#include <iostream>
#include <stack>
using namespace std;

// function prototype this command this command for display_stack utility
void display_stack(stack<string> st);

int main {

  // create a stack of strings
  stack<string> colors;

  // push elements into the stack
  colors.push("Red");
  colors.push("Orange");
  colors.push("Blue");
  
  cout << "Initial Stack: ";
  // print elements of stack
  display_stack(colors);

// rimuove “Blue” come è stato inserito lo scorso colors.pop;

  
  cout << "Final Stack: ";

  // print elements of stack
  display_stack(colors);
  
  return 0;
}

// utility function to display stack elements
void display_stack(stack<string> st) {

  while(!st.empty) {
    cout << st.top << ", ";
    st.pop;
  }

  cout << endl;
}

Output

Initial Stack: Blue, Orange, Red, 
Final Stack: Orange, Red,

Nell’esempio sopra, abbiamo usato pop per rimuovere un elemento dalla pila.

Inizialmente, il contenuto dello stack lo è {“Blue”, “Orange”, “Red”}.

Allora abbiamo usato pop per rimuovere l’elemento.

// removes top element
colors.pop 

Questo rimuove l’elemento nella parte superiore di stack cioè l’ultimo elemento inserito, che è “Blue”.

Quindi, lo stack finale diventa {“Orange”, “Red”}.

Accedi agli elementi da Stack

Accediamo all’elemento in cima alla pila usando top. Ad esempio,

#include <iostream>
#include <stack>
using namespace std;

int main {

  // create a stack of strings
  stack<string> colors;

  // push element into the stack
  colors.push("Red");
  colors.push("Orange");
  colors.push("Blue");
  
  // get top element

string top = colors.top;

  cout << "Top Element: " << top;
  
  return 0;
}

Output

Top Element: Blue

Nell’esempio sopra, abbiamo creato una pila di stringhe chiamata colori e aggiunto i seguenti elementi: “Red”, “Orange” e “Blue”.

Abbiamo poi utilizzato top per accedere all’elemento superiore:

string top = colors.top; 

Qui, “Blue” è stato inserito per ultimo, così è top element.

Ottieni la dimensione della pila

Noi usiamo size per ottenere il numero di elementi in stack. Ad esempio,

#include <iostream>
#include <stack>
using namespace std;

int main {

  // create a stack of int
  stack<int> prime_nums;

  // push elements into the stack
  prime_nums.push(2);
  prime_nums.push(3);
  prime_nums.push(5);

// ottieni la dimensione dello stack int size = prime_nums.size;

  cout << "Size of the stack: " << size;

  return 0;
}

Output

Size of the stack: 3

Nell’esempio sopra, abbiamo creato uno stack di numeri interi chiamato prime_nums e aggiunto tre elementi ad esso.

Allora abbiamo usato size per trovare il numero di elementi nello stack:

prime_nums.size;

Poiché abbiamo aggiunto 3 elementi allo stack, prime_nums.size ritorna 3.

Controlla se lo stack è vuoto

Noi usiamo empty per verificare se la pila è vuota. Questo metodo restituisce:

  • 1(true)– se la pila è vuota
  • 0(false)– se la pila non è vuota

Ad esempio,

#include <iostream>
#include <stack>
using namespace std;

int main {

  // create a stack of double
  stack<double> nums;
  
  cout << "Is the stack empty? ";

// controlla se lo stack è vuoto if (nums.empty) {

    cout << "Yes" << endl;
  }
  else {
    cout << "No" << endl;
  }

  cout << "Pushing elements..." << endl;

  // push element into the stack
  nums.push(2.3);
  nums.push(9.7);
 
  cout << "Is the stack empty? ";

// controlla se lo stack è vuoto if (nums.empty) {

    cout << "Yes";
  }
  else {
    cout << "No";
  }

  return 0;
}

Output

Is the stack empty? Yes
Pushing elements...
Is the stack empty? No

Nell’esempio sopra, abbiamo usato empty per determinare se stack è vuoto,

if(nums.empty) { // returns false
  cout << "Yes" << end;;
}
else {
  cout << "No" << endl; 
}

Inizialmente, lo stack non contiene elementi. Così nums.empty ritorna true.

Abbiamo quindi aggiunto elementi allo stack.

Ancora una volta, usiamo nums.empty per determinare se lo stack è vuoto. Questa volta, ritorna false.

Sopra sono informazioni su Come usare lo stack C++ Per saperne di più sugli stack [Detailed Guide]. Se avete domande, si prega di chiedere fixsy.org in un commento qui sotto. Sono felice di aiutarti.