Phenquestions
Въведение
Опашката е колекция от елементи, където първият елемент, добавен в списъка, трябва да бъде първият елемент, който следва да бъде премахнат. Тъй като предметите се добавят към колекцията, тя нараства по размер, т.е.д. той нараства в дължина. Всеки път, когато някой елемент трябва да бъде премахнат, той трябва да бъде първият добавен. Ако елементите се премахват непрекъснато, тогава следващият премахнат е вторият елемент; третият се отстранява след това и т.н.
След като първият елемент от оригиналния списък е премахнат, вторият става първият елемент. След като вторият елемент е премахнат, третият се превръща в първи елемент и т.н.
Добър пример за опашка в реалния живот е, когато хората се редят, за да чакат услуга или добро. Първият човек се обслужва първи преди последния. Опашката, за която се говори в този урок, е софтуерната опашка, както е проектирана в C++.
FIFO
FIFO означава First-In, First-Out. Това е друг начин за оценяване на опашката. Това означава, че първият елемент, който влиза в списъка, е първият елемент, който трябва да бъде премахнат, когато трябва да се извърши премахването. Началото на списъка се нарича глава или фронт; краят на списъка се нарича гръб или опашка.
Основни операции
Софтуерната опашка трябва да има поне следните операции:
натиснете
Тази операция добавя нов елемент в задната част на опашката. Тази операция се нарича официално, опашка.
смяна
Тази операция премахва първия елемент от опашката, а вторият елемент се превръща в новия първи елемент. Тази операция се нарича официално отлагане. Нарича се поп в C++.
Тази статия обяснява как да използвате структурата на данните за опашката C ++. Трябва да знаете указатели и препратки към C ++, за да разберете останалата част от тази статия.
Клас и обекти
Класът е набор от променливи и функции, които работят заедно, където променливите нямат присвоени стойности. Когато стойностите се присвояват на променливите, класът се превръща в обект. Различните стойности, дадени на един и същи клас, водят до различни обекти; тоест различните обекти са един и същи клас с различни стойности. Създаването на обект от клас се казва като екземпляр на обекта.
Името, опашката, е клас. Обект, създаден от класа на опашката, има избрано от програмиста име.
Функция, която принадлежи на клас, е необходима за създаване на екземпляр на обект от класа. В C ++ тази функция има същото име като името на класа. Обектите, създадени (инстанцирани) от класа, имат различни имена, дадени им от програмиста.
Създаването на обект от класа означава конструиране на обекта; това също означава инстанциране.
Програма C ++, която използва класа на опашката, започва със следните редове в горната част на файла:
#include#include
използване на пространство от имена std;
Първият ред е за вход / изход. Вторият ред е да позволи на програмата да използва всички функции на класа на опашката. Третият ред позволява на програмата да използва имената в стандартното пространство от имена.
Претоварване на функция
Когато два или повече различни подписи на функции имат едно и също име, се казва, че това име е претоварено. Когато се извика една функция, броят и видът аргументи определят коя функция всъщност се изпълнява.
Строителство
опашкаСледващата декларация създава опашка с име, que от тип int.
опашкаОпашката е празна. Декларацията започва със запазената дума, опашка, последвана от ъглови скоби с типа данни. След това имате програмиста с име за опашката.
Изграждане със списък за инициализация
Следващата дефиниция показва как да създадете опашка със списък за инициализация:
опашкаУнищожаване на опашка
За да унищожите опашката, просто я оставете извън обхвата.
Достъп до елемент на опашката
тласък (стойност)
Опашката е списък „Първо в началото“. И така, всяка стойност се добавя отзад. Следният кодов сегмент създава празна опашка, след което отзад се добавят пет плаващи стойности:
опашкаque.натиснете (1.1);
que.натиснете (2.2);
que.натиснете (3.3);
que.натиснете (4.4);
que.натиснете (5.5);
размер () конст
Това връща броя на елементите в опашката. Следният код илюстрира:
опашкаque.натиснете (1.1); que.натиснете (2.2); que.натиснете (3.3); que.натиснете (4.4); que.натиснете (5.5);
Cout << que.size() << '\n';
Изходът е 5.
отпред ()
Това връща препратка към първия елемент от опашката, без да се премахва елемента. Резултатът от следния код е 1.1.
опашкаque.натиснете (1.1); que.натиснете (2.2); que.натиснете (3.3); que.натиснете (4.4); que.натиснете (5.5);
Cout << que.front() << '\n';
Елементът не се премахва от опашката.
front () const
Когато конструкцията на опашката се предшества от const, изразът „front () const” се изпълнява вместо „front ()”. Използва се например в следния код.
const опашкаCout << que.front() << '\n';
Връща се постоянна препратка. Елементът не се премахва от вектора. Елементите на опашката не могат да бъдат променяни.
обратно()
Това връща препратка към последния елемент от опашката, без да се премахва елемента. Резултатът от следния код е 5.5.
опашкаque.натиснете (1.1); que.натиснете (2.2); que.натиснете (3.3); que.натиснете (4.4); que.натиснете (5.5);
Cout << que.back() << '\n';
back () const
Когато конструкцията на опашката се предшества от const, изразът „back () const“ се изпълнява вместо „back ()“. Използва се например в следния код.
const опашкаCout << que.back() << '\n';
Връща се постоянна препратка. Елементът не се премахва от опашката. С предходното const за конструкцията на опашката елементите в опашката не могат да бъдат променяни.
Капацитет на опашката
размер () конст
- виж по-горе
празен () const
Това връща 1 за true, ако в опашката няма елементи, или 0 за false, ако опашката е празна. Следният код илюстрира това:
опашкаCout << que1.empty() << '\n';
опашка
Cout << que2.empty() << '\n';
Резултатът е:
01
Модификатори на опашката
поп ()
Опашката е FIFO, така че всеки елемент, който трябва да бъде премахнат, трябва да бъде премахнат отгоре (главата) на опашката. Тази функция член премахва първия елемент, без да го връща. Следният код илюстрира това:
опашкаCout << que.front() << '\n';
que.поп ();
Cout << que.size() << '\n';
Резултатът е:
1.14
а.суап (б)
Две опашки могат да бъдат разменени, както е илюстрирано в този кодов сегмент:
опашкаопашка
que1.суап (que2);
Cout << "First element and size of que1:
"<< que1.front() <<", "<< que1.size() << '\n';
Cout << "First element and size of que2 "<<
que2.отпред () <<", "<< que2.size() << '\n';
Резултатът е:
Първи елемент и размер на que1: 10, 2
Първи елемент и размер на que2: 1.15
Имайте предвид, че дължината на опашката се увеличава, ако е необходимо. Също така стойностите, които не са замествали, се заменят с някаква стойност по подразбиране. Типовете данни трябва да са от същия тип.
Равенство и релационни оператори за опашки
За обикновените символи в C ++, във възходящ ред, цифрите идват преди главни букви, които идват преди малки букви. Пространственият знак е преди нулата и всички те.
Оператори за равенство
Връща 1 за true и 0 за false.
Операторът ==
Връща 1, ако двете опашки имат еднакъв размер и съответните елементи са равни; в противен случай връща 0. Пример:
опашкаопашка
int num = que1 == que2;
Cout << num << '\n';
Резултатът е: 0.
The != Оператор
- противоположно на горното. Пример:
опашкаопашка
int num = que1 != que2;
Cout << num << '\n';
Резултатът е: 1.
Релационни оператори
Връща 1 за true и 0 за false.
The < Operator
Връща 1, ако първата опашка е началното подмножество на втората опашка, като елементите на двете равни части са еднакви и в същия ред. Ако и двете опашки са с еднакъв размер или различни размери и се движат отляво надясно, в първата опашка се среща елемент, който е по-малък от съответния елемент във втората опашка, тогава 1 все пак ще бъде върната. В противен случай се връща 0. Пример:
опашкаопашка
int num = que1 < que2;
Cout << num << '\n';
Изходът е 1. < does not include the case when the size and order are the same.
> Операторът
- противоположно на горното. Пример:
опашкаопашка
int num = que1> que2;
Cout << num << '\n';
Изход: 0
The <= Operator
- същото като < but includes the case when the size and order are the same. Example:
опашкаопашка
int num = que1 <= que2;
Cout << num << '\n';
Изход: 1
Операторът> =
- противоположно на горното. Пример:
опашкаопашка
int num = que1> = que2;
Cout << num << '\n';
Изход: 0
Клас и неговите инстанцирани обекти
Стойността е към тип данни, както инстанцираният обект е към клас. Конструкцията на опашката може също да приеме клас като тип данни. Следващата програма илюстрира това:
#include#include
използване на пространство от имена std;
клас TheCla
публично:
int num;
статичен символ;
void func (char cha, const char * str)
Cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';
статично празно забавление (char ch)
ако (ch == 'a')
Cout << "Official static member function" << '\n';
;
int main ()
TheCla obj1; TheCla obj2; TheCla obj3; TheCla obj4; TheCla obj5;
опашка
que.натискане (obj1); que.натискане (obj2); que.натискане (obj3); que.натискане (obj4); que.натискане (obj5);
Cout << que.size() << '\n';
връщане 0;
Изходът е 5.
Свързан списък
Списъкът на опашките се нарича технически свързан списък. Има два типа свързани списъци за опашката: единично свързан списък и двойно свързан списък.
Единично свързан списъчен елемент може да бъде реализиран от структура от два члена. Единият член държи указател към следващия елемент, а другият член държи данните (единствено число за данни).
Двойно свързан списъчен елемент може да бъде реализиран от структура от три члена. Средният член държи опорната точка, докато първият и третият членове държат указатели към съседните им елементи.
Приложения на опашката
Опашката е структура на данни „първо в първото“. Има ситуации при изчисляването, когато данните пристигат под формата на опашка, което налага поведение „първо в първото излизане“.
Споделяне на компютърни ресурси
Ресурс в компютър е всеки физически или виртуален компонент с ограничена наличност. Те включват процесора, видеокартата, твърдия диск и паметта. Споделянето на такъв ресурс се нуждае от опашка.
Обработка на прекъсвания
Компютърните периферни устройства трябва да прекъсват компютъра от време на време. Прекъсванията трябва да се обработват по същия начин, по който са пристигнали. Това се нуждае от опашка.
Управление на информацията.
Опашката може да се използва, например, за управление на файлове на приложения за работа, ако файловете се съхраняват в компютъра.
Заключение
Опашката е структура от данни на списъка, която е или единично свързан списък, или двойно свързан списък. По правило първият елемент, който влиза в списъка, е първият елемент, който излиза. C ++ осигурява структура на данните за опашката в стандартната си библиотека. Категориите на функциите-членове и операторите, достъпни за тази структура, са изграждане на опашки, достъп до елементи на опашката, капацитет на опашката, модификатори на опашки и претоварени оператори.
Всяка структура от данни на опашката трябва да осигурява най-малко функциите на член push () и pop (). push () означава изпращане на нов елемент в задната част на опашката; и pop () означава премахване на елемента, който е в предната част на опашката. За съжаление, в C ++ тези функции не връщат стойността, изтласкана или изскачаща. Така че, за да се знае последният елемент преди натискане, трябва да се използва функцията extra back (); и за да се знае първият елемент преди изскачане, трябва да се използва допълнителната функция front ().
Стойността е към тип данни, както инстанцираният обект е към клас. Така че, определен клас може да се използва като тип данни за инстанцирането на шаблона на опашката. Различните обекти за класа стават като различни стойности за класа.
Опашката има приложения на компютъра. Може да се използва, например, за управление на файлове на приложения за работа, ако файловете се съхраняват в компютъра.
Chrys
