Stapla in C++ STL med Exempel

Stack syntax

För att skapa en stack måste vi inkludera header-fil i vår kod. Vi använder sedan denna syntax för att definiera std::stack:

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

• Typ – är den typ av element som finns i std::stacken. Den kan vara vilken som helst giltig C++ typ eller till och med en användardefinierad typ.
• Behållare – är typen av underliggande containerobjekt.

Medlemstyper

Här är stackmedlemstyper:

• value_type- Den första mallparametern, T. Den anger elementtyperna.
• container_type- Den andra mallparametern, Container. Det anger den underliggande behållartypen.
• size_type- Osignerad integraltyp.

Operationer i Stack

A C++ stack stöder följande grundläggande operationer:

• push – Den lägger till/skjuter in ett föremål i stapeln.
• pop – Det tar bort/popper ett föremål från stapeln.
• kika – Returnerar det översta föremålet i högen utan att ta bort det.
• isFull – Kontrollerar om en stack är full.
• isEmpty – Kontrollerar om en stack är tom.

Stackimplementering

Steg 1) Vi har till en början en tom stack. Toppen av en tom stack är satt till -1.

Steg 2) Därefter har vi tryckt in elementet 5 i stapeln. Toppen av stapeln kommer att peka på elementet 5.

Steg 3) Därefter har vi tryckt in elementet 50 i stapeln. Toppen av stapeln skiftar och pekar på elementet 50.

Steg 4) Vi har sedan utfört en popoperation och tagit bort det översta elementet från stapeln. Elementet 50 fälls från stapeln. Toppen av stapeln pekar nu på elementet 5.

push() och pop()

Stack::push()-funktionerna lägger till ett nytt objekt överst i stacken. Stapelstorleken ökas med en 1 efter insättningen. Funktionen tar denna syntax:

stack.push(value)

Värdet är objektet som ska infogas i stapeln.

Stacken:: pop()-funktionen tar bort det översta elementet i stacken. Det här är det nyaste föremålet i stacken. Stapelstorleken minskas med 1 efter borttagningen. Här är funktionssyntaxen:

stack.pop()

Funktionen tar inga parametrar.

Exempel 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();
	}
}

Produktion:

Här är en skärmdump av koden:

Kodförklaring:

1. Inkludera iostream-huvudfilen i vår kod för att använda dess funktioner.
2. Inkludera stackhuvudfilen i vår kod för att använda dess funktioner.
3. Inkludera std-namnområdet i vår kod för att använda dess klasser utan att anropa det.
4. Anropa main()-funktionen. Programlogiken bör läggas till i denna funktion.
5. Skapa en stackst för att lagra heltalsvärden.
6. Använd push()-funktionen för att infoga värdet 10 i stacken.
7. Använd push()-funktionen för att infoga värdet 20 i stacken.
8. Använd push()-funktionen för att infoga värdet 30 i stacken.
9. Använd push()-funktionen för att infoga värdet 40 i stacken.
10. Använd pop()-funktionen för att ta bort det översta elementet från stacken, det vill säga 40. Det översta elementet blir nu 30.
11. Använd pop()-funktionen för att ta bort det översta elementet från stacken, det vill säga 30. Det översta elementet blir nu 20.
12. Använd en while loop och empty() funktion för att kontrollera om stacken INTE är tom. Den ! är NOT-operatören.
13. Skriver ut det aktuella innehållet i stapeln på konsolen.
14. Anropa pop()-funktionen i stacken.
15. Slutet på while-loopens kropp.
16. Slutet på huvuddelen () funktion.

tomma(), storlek(), topp()

Stackar har inbyggda funktioner som du kan använda för att leka med stacken och dess värden. Dessa inkluderar:

• empty()- kontrollerar om en stack är tom eller inte.
• size()- returnerar storleken på stack, det vill säga antalet element i en stack.
• top()- kommer åt stackelementet överst.

Exempel 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;
}

Produktion:

Här är en skärmdump av koden:

Kodförklaring:

1. Inkludera iostream-huvudfilen i vår kod för att kunna använda dess funktioner.
2. Inkludera stackhuvudfilen i vår kod för att kunna använda dess funktioner.
3. Inkludera std-namnområdet i vårt program för att kunna använda dess klasser utan att anropa det.
4. Skapa funktionen createStack som vi kan använda för att skapa stacken mystack. Högen kommer att innehålla en uppsättning heltal.
5. Början av kroppen för createStack-funktionen.
6. Skapa en instans av mystack-datatypen och ge den namnet ms.
7. Använd while-loopen och funktionen empty() för att kontrollera om stacken är tom.
8. Början av while-loopens kropp.
9. Använd top()-funktionen lagrad överst i stacken. Tecknet \t skapar en ny flik.
10. Använd pop()-funktionen för att ta bort elementet överst i stacken.
11. Slutet på while-loopens kropp.
12. Skriv ut en tom rad på konsolen.
13. Slutet på kroppen av createStack-funktionen.
14. Anropa main()-funktionen. Programlogiken bör läggas till i huvuddelen av main()-funktionen.
15. Början av huvuddelen av funktion main().
16. Skapa ett stackobjekt st.
17. Använd push()-funktionen för att infoga elementet 32 ​​i stacken.
18. Använd push()-funktionen för att infoga elementet 21 ​​i stacken.
19. Använd push()-funktionen för att infoga elementet 39 ​​i stacken.
20. Använd push()-funktionen för att infoga elementet 89 ​​i stacken.
21. Använd push()-funktionen för att infoga elementet 25 ​​i stacken.
22. Skriv ut lite text på konsolen.
23. Anropa createStack-funktionen för att utföra ovanstående infogningsoperationer i stacken.
24. Skriv ut stapelns storlek på konsolen tillsammans med annan text.
25. Skriv ut elementet överst i stapeln på konsolen.
26. Skriv ut lite text på konsolen.
27. Ta bort elementet överst i stapeln. Det kommer sedan att returnera de element som finns kvar i stacken.
28. Anropa createStack-funktionen för att utföra ovanstående operationer.
29. Programmet måste returnera värde efter framgångsrikt slutförande.
30. Slutet på huvuddelen av funktion main().

emplace() och swap()

Det här är andra inbyggda stackfunktioner:

• emplace()- konstruktioner infogar sedan ett nytt element till toppen av stacken.
• swap()- utbyter stackinnehåll med en annan stacks innehåll.

Exempel 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();
	}
}

Produktion:

Här är en skärmdump av koden:

Kodförklaring:

1. Inkludera iostream-huvudfilen i vår kod för att använda dess funktioner.
2. Inkludera stackhuvudfilen i vår kod för att använda dess funktioner.
3. Inkludera cstdlib-huvudfilen i vår kod för att använda dess funktioner.
4. Inkludera std-namnområdet i vår kod för att använda dess klasser utan att anropa det.
5. Anropa main()-funktionen. Programlogiken kommer att läggas till i kroppen av denna funktion.
6. Deklarera en stack med namnet st1 för att lagra heltalsvärden.
7. Deklarera en stack med namnet st2 för att lagra heltalsvärden.
8. Använd funktionen emplace() för att infoga heltal 12 i stacken som heter st1.
9. Använd funktionen emplace() för att infoga heltal 19 i stacken som heter st1.
10. Använd funktionen emplace() för att infoga heltal 20 i stacken som heter st2.
11. Använd funktionen emplace() för att infoga heltal 23 i stacken som heter st2.
12. Använd swap()-funktionen för att byta innehållet i de två stackarna, st1 och st2. Innehållet i stack st1 ska flyttas till stack st2. Innehållet i stack st2 ska flyttas till stack st1.
13. Skriv ut lite text på konsolen.
14. Använd while-satsen och funktionen empty() för att kontrollera om stacken st1 inte är tom.
15. Skriv ut innehållet i stack st1 på konsolen. ” ” lägger till utrymme mellan stapelelementen när du skriver ut dem på konsolen.
16. Kör pop()-funktionen på stacken st1 för att ta bort det översta elementet.
17. Slutet på stundens brödtext.
18. Skriv ut lite text på konsolen. Änden är en C++ nyckelord för slutrad. Den flyttar muspekaren till nästa rad för att börja skriva ut därifrån.
19. Använd while-satsen och funktionen empty() för att kontrollera om stacken st2 inte är tom.
20. Skriv ut innehållet i stack st2 på konsolen. ” ” lägger till utrymme mellan stapelelementen när du skriver ut dem på konsolen.
21. Kör pop()-funktionen på stacken st2 för att ta bort det översta elementet.
22. Slutet på stundens brödtext.
23. Slutet på huvuddelen av funktionen main().

Stapla i STL

STL (Standard Template Library) kommer med mallklasser som ger gemensamma C++ datastrukturer. Därför kan en stack också implementeras i STL. Vi inkluderar helt enkelt detta bibliotek i vår kod och använder det för att definiera en stack.

stack<T> st; 

Ovanstående syntax deklarerar en stack st till element av datatyp T.

Exempel 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();  
}

Produktion:

Här är en skärmdump av koden:

Kodförklaring:

1. Inkludera iostream-huvudfilen i vår kod för att använda dess funktioner.
2. Inkludera stackhuvudfilen i vår kod för att använda dess funktioner.
3. Inkludera cstdlib-huvudfilen i vår kod för att använda dess funktioner.
4. Inkludera std-namnområdet i vår kod för att använda dess klasser utan att anropa det.
5. Anropa main()-funktionen. Programlogiken bör läggas till i kroppen av denna funktion.
6. Deklarera en stack st för att lagra heltalsdata.
7. Lägg till elementet 12 i stapeln.
8. Lägg till elementet 19 i stapeln.
9. Lägg till elementet 20 i stapeln.
10. Skriv ut elementet överst i stapeln på konsolen.
11. Skriv ut stapelns storlek på konsolen.
12. Slutet på kroppen av funktionen main().

Sammanfattning

• En stack är en datastruktur som fungerar baserat på LIFO-tekniken (Last In first Out).
• Std::stack tillåter endast att objekt läggas till och tas bort från ena änden.
• Klassen std::stack är en containeradapter som innehåller föremål av liknande datatyp.
• En stack kan skapas från olika sekvensbehållare.
• Om du inte tillhandahåller en behållare kommer deque-behållaren att användas som standard.
• Funktionen push() är till för att infoga objekt i stacken.
• Pop()-funktionen är till för att ta bort det översta objektet från steget.
• Funktionen empty() är till för att kontrollera om en stack är tom eller inte.