Condividi tramite

Classe stack

  • Articolo

Una classe di adattatori di contenitori di modelli che fornisce una restrizione di funzionalità, limitando l'accesso all'elemento aggiunto più recentemente a un tipo di contenitore sottostante. La stack classe viene usata quando è importante essere chiari che solo stack le operazioni vengono eseguite nel contenitore.

Sintassi

template <class Type, class Container= deque <Type>>
class stack

Parametri

Type
Tipo di dati degli elementi da archiviare nello stack.

Container
Tipo del contenitore sottostante usato per implementare lo stack. Il valore predefinito è la classe deque<Type>.

Osservazioni:

Gli elementi della classe Type stipulati nel primo parametro modello di un oggetto stack sono sinonimi value_type e devono corrispondere al tipo di elemento nella classe Container contenitore sottostante stipulato dal secondo parametro di modello. Deve Type essere assegnabile, in modo che sia possibile copiare oggetti di tale tipo e assegnare valori alle variabili di tale tipo.

Le classi contenitore sottostanti appropriate per lo stack includono deque,list classe evector classe o qualsiasi altro contenitore di sequenza che supporta le operazioni di back, push_backe pop_back. La classe del contenitore sottostante è incapsulata nell'adattatore di contenitori, che espone solo il set limitato di funzioni membro dei contenitori di sequenza come interfaccia pubblica.

Gli stack oggetti sono equivalenti se e solo se gli elementi della classe Type sono confrontabili e sono meno di paragonabili se e solo se gli elementi della classe Type sono meno di paragonabili.

  • La stack classe supporta una struttura di dati LIFO (Last-In, First-Out). Una buona analogia è costituita da una pila di piatti. Gli elementi (piatti) possono essere inseriti, ispezionati o rimossi solo dalla cima della pila/stack, ovvero l'ultimo elemento alla fine del contenitore di base. La restrizione per accedere solo all'elemento principale è il motivo dell'uso della stack classe .

  • La queue classe supporta una struttura di dati FIFO (First-In First-In, First-Out). Una buona analogia è costituita da persone in coda davanti allo sportello di una banca. Gli elementi (persone) possono essere aggiunti alla fine della fila e vengono rimossi dalla parte iniziale della fila. È possibile ispezionare sia l'inizio che la fine della fila. La restrizione per accedere solo agli elementi anteriori e posteriore in questo modo è il motivo per cui si usa la queue classe .

  • La priority_queue classe ordina i relativi elementi in modo che l'elemento più grande sia sempre nella posizione superiore. Supporta l'inserimento di un elemento e l'ispezione e la rimozione del primo elemento. Una buona analogia è costituita da una fila di persone disposte in base a età, altezza o qualche altro criterio.

Membri

Costruttori

Nome Descrizione
stack Costruisce un stack vuoto o che rappresenta una copia totale o parziale di un oggetto contenitore di base.

Typedef

Nome Descrizione
container_type Tipo che fornisce il contenitore di base che deve essere adattato da un oggetto stack.
size_type Tipo Unsigned Integer in grado di rappresentare il numero di elementi di un stack.
value_type Tipo che rappresenta il tipo di oggetto archiviato come elemento in stack.

Funzioni

Nome Descrizione
empty Verifica se stack è vuoto.
pop Rimuove l'elemento dalla parte superiore di stack.
push Aggiunge un elemento alla parte superiore di stack.
size Restituisce il numero di elementi nel stack.
top Restituisce un riferimento a un elemento nella parte superiore di stack.

container_type

Tipo che fornisce il contenitore di base da adattare.

typedef Container container_type;

Osservazioni:

Il tipo è un sinonimo del parametro di modello Container. Tutte e tre le classi contenitore della sequenza della libreria standard C++, ovvero la classe, list la vector classe e la classe deque predefinita, soddisfano i requisiti da usare come contenitore di base per un stack oggetto. È anche possibile usare tipi definiti dall'utente che soddisfano i requisiti.

Per altre informazioni su Container, vedere la sezione Osservazioni dell'argomento stack Classe .

Esempio

Vedere l'esempio per stack::stack un esempio di come dichiarare e usare container_type.

empty

Verifica se uno stack è vuoto.

bool empty() const;

Valore restituito

true se lo stack è vuoto; false se lo stack non èempty.

Esempio

// stack_empty.cpp
// compile with: /EHsc
#include <stack>
#include <iostream>

int main( )
{
   using namespace std;
   // Declares stacks with default deque base container
   stack <int> s1, s2;

   s1.push( 1 );

   if ( s1.empty( ) )
      cout << "The stack s1 is empty." << endl;
   else
      cout << "The stack s1 is not empty." << endl;

   if ( s2.empty( ) )
      cout << "The stack s2 is empty." << endl;
   else
      cout << "The stack s2 is not empty." << endl;
}

The stack s1 is not empty.
The stack s2 is empty.

pop

Rimuove l'elemento all'inizio dello stack.

void pop();

Osservazioni:

Per applicare la funzione membro, lo stack deve essere non vuoto. L'inizio dello stack è la posizione occupata dall'elemento aggiunto più di recente ed è l'ultimo elemento alla fine del contenitore.

Esempio

// stack_pop.cpp
// compile with: /EHsc
#include <stack>
#include <iostream>

int main( )
{
   using namespace std;
   stack <int> s1, s2;

   s1.push( 10 );
   s1.push( 20 );
   s1.push( 30 );

   stack <int>::size_type i;
   i = s1.size( );
   cout << "The stack length is " << i << "." << endl;

   i = s1.top( );
   cout << "The element at the top of the stack is "
        << i << "." << endl;

   s1.pop( );

   i = s1.size( );
   cout << "After a pop, the stack length is "
        << i << "." << endl;

   i = s1.top( );
   cout << "After a pop, the element at the top of the stack is "
        << i << "." << endl;
}

The stack length is 3.
The element at the top of the stack is 30.
After a pop, the stack length is 2.
After a pop, the element at the top of the stack is 20.

push

Aggiunge un elemento all'inizio dello stack.

void push(const Type& val);

Parametri

val
Elemento aggiunto all'inizio dello stack.

Osservazioni:

L'inizio dello stack è la posizione occupata dall'elemento aggiunto più di recente ed è l'ultimo elemento alla fine del contenitore.

Esempio

// stack_push.cpp
// compile with: /EHsc
#include <stack>
#include <iostream>

int main( )
{
   using namespace std;
   stack <int> s1;

   s1.push( 10 );
   s1.push( 20 );
   s1.push( 30 );

   stack <int>::size_type i;
   i = s1.size( );
   cout << "The stack length is " << i << "." << endl;

   i = s1.top( );
   cout << "The element at the top of the stack is "
        << i << "." << endl;
}

The stack length is 3.
The element at the top of the stack is 30.

size

Restituisce il numero di elementi presenti nello stack.

size_type size() const;

Valore restituito

Lunghezza corrente dello stack.

Esempio

// stack_size.cpp
// compile with: /EHsc
#include <stack>
#include <iostream>

int main( )
{
   using namespace std;
   stack <int> s1, s2;
   stack <int>::size_type i;

   s1.push( 1 );
   i = s1.size( );
   cout << "The stack length is " << i << "." << endl;

   s1.push( 2 );
   i = s1.size( );
   cout << "The stack length is now " << i << "." << endl;
}

The stack length is 1.
The stack length is now 2.

size_type

Tipo Unsigned Integer in grado di rappresentare il numero di elementi di uno stack.

typedef typename Container::size_type size_type;

Osservazioni:

Il tipo è un sinonimo del size_type del contenitore di base adattato dallo stack.

Esempio

Vedere l'esempio per size un esempio di come dichiarare e usare size_type.

stack

Costruisce uno stack vuoto o che rappresenta una copia totale o parziale di una classe contenitore di base.

stack();

explicit stack(const container_type& right);

Parametri

right
Contenitore di cui lo stack costruito deve essere una copia.

Esempio

// stack_stack.cpp
// compile with: /EHsc
#include <stack>
#include <vector>
#include <list>
#include <iostream>

int main( )
{
   using namespace std;

   // Declares stack with default deque base container
   stack <char> dsc1;

   //Explicitly declares a stack with deque base container
   stack <char, deque<char> > dsc2;

   // Declares a stack with vector base containers
   stack <int, vector<int> > vsi1;

   // Declares a stack with list base container
   stack <int, list<int> > lsi;

   // The second member function copies elements from a container
   vector<int> v1;
   v1.push_back( 1 );
   stack <int, vector<int> > vsi2( v1 );
   cout << "The element at the top of stack vsi2 is "
        << vsi2.top( ) << "." << endl;
}

The element at the top of stack vsi2 is 1.

top

Restituisce un riferimento a un elemento all'inizio dello stack.

reference top();

const_reference top() const;

Valore restituito

Riferimento all'ultimo elemento del contenitore all'inizio dello stack.

Osservazioni:

Per applicare la funzione membro, lo stack deve essere non vuoto. L'inizio dello stack è la posizione occupata dall'elemento aggiunto più di recente ed è l'ultimo elemento alla fine del contenitore.

Se il valore restituito di top viene assegnato a un const_referenceoggetto , l'oggetto stack non può essere modificato. Se il valore restituito di top viene assegnato a un referenceoggetto , l'oggetto stack può essere modificato.

Esempio

// stack_top.cpp
// compile with: /EHsc
#include <stack>
#include <iostream>

int main( )
{
   using namespace std;
   stack <int> s1;

   s1.push( 1 );
   s1.push( 2 );

   int& i = s1.top( );
   const int& ii = s1.top( );

   cout << "The top integer of the stack s1 is "
        << i << "." << endl;
   i--;
   cout << "The next integer down is "<< ii << "." << endl;
}

The top integer of the stack s1 is 2.
The next integer down is 1.

value_type

Tipo che rappresenta il tipo di oggetto archiviato come elemento in uno stack.

typedef typename Container::value_type value_type;

Osservazioni:

Il tipo è un sinonimo del value_type del contenitore di base adattato dallo stack.

Esempio

// stack_value_type.cpp
// compile with: /EHsc
#include <stack>
#include <iostream>

int main( )
{
   using namespace std;
   // Declares stacks with default deque base container
   stack<int>::value_type AnInt;

   AnInt = 69;
   cout << "The value_type is AnInt = " << AnInt << endl;

   stack<int> s1;
   s1.push( AnInt );
   cout << "The element at the top of the stack is "
        << s1.top( ) << "." << endl;
}

The value_type is AnInt = 69
The element at the top of the stack is 69.

Vedi anche

Thread Safety in the C++ Standard Library (Sicurezza dei thread nella libreria standard C++)
Informazioni di riferimento per la libreria standard C++