Stables ind C++ STL med Eksempel

Staksyntaks

For at oprette en stak skal vi inkludere header-fil i vores kode. Vi bruger derefter denne syntaks til at definere std::stack:

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

• Type – er den type element, der er indeholdt i std::stakken. Det kan være enhver gyldig C++ type eller endda en brugerdefineret type.
• Container – er typen af ​​underliggende containerobjekt.

Medlemstyper

Her er stackmedlemstyper:

• value_type- Den første skabelonparameter, T. Den angiver elementtyperne.
• container_type- Den anden skabelonparameter, Container. Det angiver den underliggende beholdertype.
• size_type- Usigneret integraltype.

Operationer i Stack

A C++ stack understøtter følgende grundlæggende handlinger:

• push – Det tilføjer/skubber et emne ind i stakken.
• pop – Det fjerner/popper et emne fra stakken.
• kig – Returnerer det øverste element i stakken uden at fjerne det.
• isFull – Kontrollerer, om en stak er fuld.
• isEmpty – Kontrollerer, om en stak er tom.

Stakimplementering

Trin 1) Vi har i første omgang en tom stak. Toppen af ​​en tom stak er sat til -1.

Trin 2) Dernæst har vi skubbet element 5 ind i stakken. Toppen af ​​stakken vil pege på elementet 5.

Trin 3) Dernæst har vi skubbet elementet 50 ind i stakken. Toppen af ​​stakken skifter og peger på elementet 50.

Trin 4) Vi har derefter udført en pop-operation, hvor vi har fjernet det øverste element fra stakken. Elementet 50 er trukket ud af stakken. Toppen af ​​stakken peger nu på elementet 5.

push() og pop()

Stack::push()-funktionerne tilføjer nyt element til toppen af ​​stakken. Stakstørrelsen øges med en 1 efter indsættelsen. Funktionen tager denne syntaks:

stack.push(value)

Værdien er det element, der skal indsættes i stakken.

Stakken:: pop()-funktionen fjerner det øverste element i stakken. Dette er det nyeste element i stakken. Stakstørrelsen reduceres med 1 efter fjernelse. Her er funktionssyntaksen:

stack.pop()

Funktionen tager ingen parametre.

Eksempel 1:

#include <iostream> 
#include <stack> 
using namespace std;
int main() {
	stack<int> st;
	st.push(10);
	st.push(20);
	st.push(30);
	st.push(40);
	
         st.pop();
	st.pop();

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

Output:

Her er et skærmbillede af koden:

Kodeforklaring:

1. Inkluder iostream-headerfilen i vores kode for at bruge dens funktioner.
2. Inkluder stackheader-filen i vores kode for at bruge dens funktioner.
3. Inkluder std-navneområdet i vores kode for at bruge dets klasser uden at kalde det.
4. Kald funktionen main(). Programlogikken skal tilføjes i denne funktion.
5. Opret en stak st for at gemme heltalsværdier.
6. Brug push()-funktionen til at indsætte værdien 10 i stakken.
7. Brug push()-funktionen til at indsætte værdien 20 i stakken.
8. Brug push()-funktionen til at indsætte værdien 30 i stakken.
9. Brug push()-funktionen til at indsætte værdien 40 i stakken.
10. Brug pop()-funktionen til at fjerne det øverste element fra stakken, det vil sige 40. Det øverste element bliver nu 30.
11. Brug pop()-funktionen til at fjerne det øverste element fra stakken, det vil sige 30. Det øverste element bliver nu 20.
12. Brug en while-løkke og en tomme()-funktion til at kontrollere, om stakken IKKE er tom. Den ! er NOT-operatøren.
13. Udskrivning af det aktuelle indhold af stakken på konsollen.
14. Kald pop()-funktionen på stakken.
15. Slut på mens-løkkens krop.
16. Slutningen af ​​hoved() funktionsteksten.

tomme(), størrelse(), top()

Stakke har indbyggede funktioner, som du kan bruge til at lege med stakken og dens værdier. Disse omfatter:

• empty()- kontrollerer om en stak er tom eller ej.
• size()- returnerer størrelsen af ​​stak, det vil sige antallet af elementer i en stak.
• top()- får adgang til stakelementet øverst.

Eksempel 2:

#include <iostream> 
#include <stack>  
using namespace std;
void createStack(stack <int> mystack)
{
	stack <int> ms = mystack;
	while (!ms.empty())
	{
		cout << '\t' << ms.top();
		ms.pop();
	}
	cout << '\n';
}
int main()
{
	stack <int> st;
	st.push(32);
	st.push(21);
	st.push(39);
	st.push(89);
	st.push(25);

	cout << "The stack st is: ";
	createStack(st);
	cout << "\n st.size() : " << st.size();
	cout << "\n st.top() : " << st.top();
	cout << "\n st.pop() : ";
	st.pop();
	createStack(st);
	return 0;
}

Output:

Her er et skærmbillede af koden:

Kodeforklaring:

1. Inkluder iostream-headerfilen i vores kode for at bruge dens funktioner.
2. Inkluder stackheader-filen i vores kode for at bruge dens funktioner.
3. Inkluder std-navneområdet i vores program for at bruge dets klasser uden at kalde det.
4. Opret funktionen createStack, som vi kan bruge til at oprette stack mystack. Stakken vil indeholde et sæt heltal.
5. Begyndelsen af ​​kroppen af ​​createStack-funktionen.
6. Opret en forekomst af mystack-datatypen og giv den navnet ms.
7. Brug while-løkken og funktionen empty() til at kontrollere, om stakken er tom.
8. Starten på kroppen af ​​while-løkken.
9. Brug top()-funktionen, der er gemt øverst i stakken. Tegnet \t vil oprette en ny fane.
10. Brug pop()-funktionen til at slette elementet øverst i stakken.
11. Slut på mens-løkkens krop.
12. Udskriv en tom linje på konsollen.
13. Slutningen af ​​brødteksten af ​​createStack-funktionen.
14. Kald funktionen main(). Programlogikken skal tilføjes i hoveddelen af ​​funktionen main().
15. Starten af ​​kroppen af ​​funktion main().
16. Opret et stabelobjekt st.
17. Brug push()-funktionen til at indsætte elementet 32 ​​i stakken.
18. Brug push()-funktionen til at indsætte elementet 21 ​​i stakken.
19. Brug push()-funktionen til at indsætte elementet 39 ​​i stakken.
20. Brug push()-funktionen til at indsætte elementet 89 ​​i stakken.
21. Brug push()-funktionen til at indsætte elementet 25 ​​i stakken.
22. Udskriv noget tekst på konsollen.
23. Kald createStack-funktionen for at udføre ovenstående indsættelsesoperationer i stakken.
24. Udskriv størrelsen af ​​stakken på konsollen sammen med anden tekst.
25. Udskriv elementet øverst i stakken på konsollen.
26. Udskriv noget tekst på konsollen.
27. Slet elementet øverst i stakken. Det vil derefter returnere de resterende elementer i stakken.
28. Kald createStack-funktionen for at udføre ovenstående operationer.
29. Programmet skal returnere værdi efter vellykket afslutning.
30. Slutningen af ​​hoveddelen af ​​funktion main().

emplace() og swap()

Disse er andre indbyggede stakfunktioner:

• emplace()- konstruerer derefter indsætter nyt element til toppen af ​​stakken.
• swap()- udveksler stakindhold med en anden staks indhold.

Eksempel 3:

#include <iostream>    
#include <stack>
#include <cstdlib>
using namespace std;
int main() {
	stack<int> st1;
	stack<int> st2;

	st1.emplace(12);
	st1.emplace(19);

	st2.emplace(20);
	st2.emplace(23);

	st1.swap(st2);

	cout << "st1 = ";
	while (!st1.empty()) {
		cout << st1.top() << " ";
		st1.pop();
	}

	cout << endl << "st2 = ";
	while (!st2.empty()) {
		cout << st2.top() << " ";
		st2.pop();
	}
}

Output:

Her er et skærmbillede af koden:

Kodeforklaring:

1. Inkluder iostream-headerfilen i vores kode for at bruge dens funktioner.
2. Inkluder stackheader-filen i vores kode for at bruge dens funktioner.
3. Inkluder cstdlib-headerfilen i vores kode for at bruge dens funktioner.
4. Inkluder std-navneområdet i vores kode for at bruge dets klasser uden at kalde det.
5. Kald funktionen main(). Programlogikken vil blive tilføjet i denne funktions brødtekst.
6. Erklære en stak ved navn st1 for at gemme heltalsværdier.
7. Erklære en stak ved navn st2 for at gemme heltalsværdier.
8. Brug emplace()-funktionen til at indsætte hele tallet 12 i stakken med navnet st1.
9. Brug emplace()-funktionen til at indsætte hele tallet 19 i stakken med navnet st1.
10. Brug emplace()-funktionen til at indsætte hele tallet 20 i stakken med navnet st2.
11. Brug emplace()-funktionen til at indsætte hele tallet 23 i stakken med navnet st2.
12. Brug swap()-funktionen til at bytte indholdet af de to stakke, st1 og st2. Indholdet af stakken st1 skal flyttes til stakken st2. Indholdet af stakken st2 skal flyttes til stakken st1.
13. Udskriv noget tekst på konsollen.
14. Brug while-sætningen og funktionen empty() til at kontrollere, om stakken st1 ikke er tom.
15. Udskriv indholdet af stakken st1 på konsollen. " " tilføjer plads mellem stakelementerne, når de udskrives på konsollen.
16. Udfør pop()-funktionen på stakken st1 for at fjerne det øverste element.
17. Slutningen af ​​brødteksten af ​​while-erklæringen.
18. Udskriv noget tekst på konsollen. Endl er en C++ nøgleord for slutlinje. Den flytter musemarkøren til næste linje for at begynde udskrivningen derfra.
19. Brug while-sætningen og funktionen empty() til at kontrollere, om stakken st2 ikke er tom.
20. Udskriv indholdet af stakken st2 på konsollen. " " tilføjer plads mellem stakelementerne, når de udskrives på konsollen.
21. Udfør pop()-funktionen på stakken st2 for at fjerne det øverste element.
22. Slutningen af ​​brødteksten af ​​while-erklæringen.
23. Slutningen af ​​hoveddelen af ​​funktionen main().

Stak i STL

STL (Standard Template Library) kommer med skabelonklasser, der giver fælles C++ datastrukturer. Derfor kan en stack også implementeres i STL. Vi inkluderer simpelthen dette bibliotek i vores kode og bruger det til at definere en stak.

stack<T> st; 

Ovenstående syntaks erklærer en stack st til elementer af datatype T.

Eksempel 4:

#include <iostream>      
#include <stack>
#include <cstdlib>
using namespace std;
int main() {
	stack<int> st;
	st.push(12);
	st.push(19);
	st.push(20);
	cout << st.top();   
	cout << st.size();  
}

Output:

Her er et skærmbillede af koden:

Kodeforklaring:

1. Inkluder iostream-headerfilen i vores kode for at bruge dens funktioner.
2. Inkluder stackheader-filen i vores kode for at bruge dens funktioner.
3. Inkluder cstdlib-headerfilen i vores kode for at bruge dens funktioner.
4. Inkluder std-navneområdet i vores kode for at bruge dets klasser uden at kalde det.
5. Kald funktionen main(). Programlogikken skal tilføjes i denne funktions brødtekst.
6. Erklære en stak st for at gemme heltalsdata.
7. Tilføj element 12 til stakken.
8. Tilføj element 19 til stakken.
9. Tilføj element 20 til stakken.
10. Udskriv elementet øverst i stakken på konsollen.
11. Udskriv stakkens størrelse på konsollen.
12. Slutningen af ​​kroppen af ​​funktionen main().

Resumé

• En stak er en datastruktur, der fungerer baseret på LIFO-teknikken (Last In first Out).
• Std::-stakken tillader kun at tilføje og fjerne elementer fra den ene ende.
• Klassen std::stack er en containeradapter, der indeholder elementer af en lignende datatype.
• En stak kan oprettes fra forskellige sekvensbeholdere.
• Hvis du ikke leverer en container, vil dequecontaineren blive brugt som standard.
• push()-funktionen er til at indsætte elementer i stakken.
• Pop()-funktionen er til at fjerne det øverste element fra trinnet.
• Funktionen empty() er til at kontrollere, om en stak er tom eller ej.