Push c что это

Stack.Push(T) Метод

Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.

Вставляет объект как верхний элемент стека Stack .

public: void Push(T item);

public void Push (T item);

member this.Push : 'T -> unit

Public Sub Push (item As T)

Параметры

Примеры

В следующем примере кода демонстрируется несколько методов универсального Stack класса, включая Push метод .

В примере кода создается стек строк с емкостью по умолчанию и используется Push метод для отправки пяти строк в стек. Элементы стека перечисляются, что не изменяет состояние стека. Метод Pop используется для того, чтобы вывести первую строку из стека. Метод Peek используется для просмотра следующего элемента в стеке, а затем Pop метод используется для его отключения.

Метод ToArray используется для создания массива и копирования элементов стека в него, а затем массив передается конструктору Stack , который принимает IEnumerable , создавая копию стека с обратным порядком элементов. Отображаются элементы копии.

Создается массив, в два раза больше размера стека, и CopyTo метод используется для копирования элементов массива, начиная с середины массива. Конструктор Stack снова используется для создания копии стека с обратным порядком элементов. Таким образом, три элемента NULL находятся в конце.

Метод Contains используется, чтобы показать, что строка «четыре» находится в первой копии стека, после чего Clear метод очищает копию, а Count свойство показывает, что стек пуст.

using System; using System.Collections.Generic; class Example < public static void Main() < Stacknumbers = new Stack(); numbers.Push("one"); numbers.Push("two"); numbers.Push("three"); numbers.Push("four"); numbers.Push("five"); // A stack can be enumerated without disturbing its contents. foreach( string number in numbers ) < Console.WriteLine(number); >Console.WriteLine("\nPopping ''", numbers.Pop()); Console.WriteLine("Peek at next item to destack: ", numbers.Peek()); Console.WriteLine("Popping ''", numbers.Pop()); // Create a copy of the stack, using the ToArray method and the // constructor that accepts an IEnumerable. Stack stack2 = new Stack(numbers.ToArray()); Console.WriteLine("\nContents of the first copy:"); foreach( string number in stack2 ) < Console.WriteLine(number); >// Create an array twice the size of the stack and copy the // elements of the stack, starting at the middle of the // array. string[] array2 = new string[numbers.Count * 2]; numbers.CopyTo(array2, numbers.Count); // Create a second stack, using the constructor that accepts an // IEnumerable(Of T). Stack stack3 = new Stack(array2); Console.WriteLine("\nContents of the second copy, with duplicates and nulls:"); foreach( string number in stack3 ) < Console.WriteLine(number); >Console.WriteLine("\nstack2.Contains(\"four\") = ", stack2.Contains("four")); Console.WriteLine("\nstack2.Clear()"); stack2.Clear(); Console.WriteLine("\nstack2.Count = ", stack2.Count); > > /* This code example produces the following output: five four three two one Popping 'five' Peek at next item to destack: four Popping 'four' Contents of the first copy: one two three Contents of the second copy, with duplicates and nulls: one two three stack2.Contains("four") = False stack2.Clear() stack2.Count = 0 */ 

open System open System.Collections.Generic let numbers = Stack() numbers.Push "one" numbers.Push "two" numbers.Push "three" numbers.Push "four" numbers.Push "five" // A stack can be enumerated without disturbing its contents. for number in numbers do printfn $"" printfn $"\nPopping ''" printfn $"Peek at next item to destack: " numbers.Peek() |> ignore printfn $"Popping ''" // Create a copy of the stack, using the ToArray method and the // constructor that accepts an IEnumerable. let stack2 = numbers.ToArray() |> Stack printfn "\nContents of the first copy:" for number in stack2 do printfn $"" // Create an array twice the size of the stack and copy the // elements of the stack, starting at the middle of the // array. let array2 = numbers.Count * 2 |> Array.zeroCreate numbers.CopyTo(array2, numbers.Count) // Create a second stack, using the constructor that accepts an // IEnumerable(Of T). let stack3 = Stack array2 printfn "\nContents of the second copy, with duplicates and nulls:" for number in stack3 do printfn $"" printfn $""" stack2.Contains "four" = """ printfn "\nstack2.Clear()" stack2.Clear() printfn $"\nstack2.Count = " // This code example produces the following output: // five // four // three // two // one // // Popping 'five' // Peek at next item to destack: four // Popping 'four' // // Contents of the first copy: // one // two // three // // Contents of the second copy, with duplicates and nulls: // one // two // three // // stack2.Contains("four") = False // // stack2.Clear() // // stack2.Count = 0 

Imports System.Collections.Generic Module Example Sub Main Dim numbers As New Stack(Of String) numbers.Push("one") numbers.Push("two") numbers.Push("three") numbers.Push("four") numbers.Push("five") ' A stack can be enumerated without disturbing its contents. For Each number As String In numbers Console.WriteLine(number) Next Console.WriteLine(vbLf & "Popping ''", numbers.Pop()) Console.WriteLine("Peek at next item to pop: ", _ numbers.Peek()) Console.WriteLine("Popping ''", numbers.Pop()) ' Create another stack, using the ToArray method and the ' constructor that accepts an IEnumerable(Of T). Note that ' the order of items on the new stack is reversed. Dim stack2 As New Stack(Of String)(numbers.ToArray()) Console.WriteLine(vbLf & "Contents of the first copy:") For Each number As String In stack2 Console.WriteLine(number) Next ' Create an array twice the size of the stack, compensating ' for the fact that Visual Basic allocates an extra array ' element. Copy the elements of the stack, starting at the ' middle of the array. Dim array2((numbers.Count * 2) - 1) As String numbers.CopyTo(array2, numbers.Count) ' Create a second stack, using the constructor that accepts an ' IEnumerable(Of T). The elements are reversed, with the null ' elements appearing at the end of the stack when enumerated. Dim stack3 As New Stack(Of String)(array2) Console.WriteLine(vbLf & _ "Contents of the second copy, with duplicates and nulls:") For Each number As String In stack3 Console.WriteLine(number) Next Console.WriteLine(vbLf & "stack2.Contains(""four"") = ", _ stack2.Contains("four")) Console.WriteLine(vbLf & "stack2.Clear()") stack2.Clear() Console.WriteLine(vbLf & "stack2.Count = ", _ stack2.Count) End Sub End Module ' This code example produces the following output: ' 'five 'four 'three 'two 'one ' 'Popping 'five' 'Peek at next item to pop: four 'Popping 'four' ' 'Contents of the first copy: 'one 'two 'three ' 'Contents of the second copy, with duplicates and nulls: 'one 'two 'three ' ' ' ' 'stack2.Contains("four") = False ' 'stack2.Clear() ' 'stack2.Count = 0 

Комментарии

Если тип T является ссылочным типом, null при необходимости его можно отправить в Stack в качестве заполнителя. Он занимает слот в стеке и обрабатывается как любой объект.

Если Count значение меньше емкости стека, Push является операцией O(1). Если емкость необходимо увеличить для размещения нового элемента, Push становится операцией O( n ), где n — Count.

Array.prototype.push()

Метод push() добавляет один или более элементов в конец массива и возвращает новую длину массива.

Синтаксис

arr.push(element1, . elementN)

Параметры

Элементы, добавляемые в конец массива.

Возвращаемое значение

Новое значение свойства length объекта, для которого был вызван данный метод.

Описание

Метод push присоединяет значения к массиву.

Метод push не является привязанным к типу; этот метод может быть вызван или применён к объектам, напоминающим массив. Метод опирается на свойство length для определения места вставки значений. Если свойство length не может быть преобразовано в число, будет использовать индекс 0. Сюда входит случай несуществования свойства length , в этом случае оно также будет создано.

Единственными родными массивоподобными объектами являются строки, хотя к ним он не может быть применён, поскольку строки являются неизменяемыми.

Примеры

Пример: добавление элементов в массив

Следующий код создаёт массив sports , содержащий два элемента, а затем добавляет к нему ещё два элемента. Переменная total будет содержать новую длину массива.

var sports = ["футбол", "бейсбол"]; var total = sports.push("американский футбол", "плавание"); console.log(sports); // ['футбол', 'бейсбол', 'американский футбол', 'плавание'] console.log(total); // 4 

Пример: слияние двух массивов

В этом примере используется функция apply() для помещения всех элементов из второго массива в первый.

var vegetables = ["пастернак", "картошка"]; var moreVegs = ["сельдерей", "свёкла"]; // Сливает второй массив с первым // Эквивалентно вызову vegetables.push('сельдерей', 'свёкла'); Array.prototype.push.apply(vegetables, moreVegs); console.log(vegetables); // ['пастернак', 'картошка', 'сельдерей', 'свёкла'] 

Спецификации

Specification
ECMAScript Language Specification # sec-array.prototype.push

Совместимость с браузерами

BCD tables only load in the browser

Смотрите также

• Array.prototype.pop()
• Array.prototype.shift()
• Array.prototype.unshift()
• Array.prototype.concat()

Found a content problem with this page?

• Edit the page on GitHub.
• Report the content issue.
• View the source on GitHub.

This page was last modified on 4 авг. 2023 г. by MDN contributors.

Your blueprint for a better internet.

Стек

С тек – наверное, самая простая структура данных, которую мы будем изучать и которой будем постоянно пользоваться. Стек – это структура данных, в которой элементы поддерживают принцип LIFO (“Last in – first out”): последним зашёл – первым вышел. Или первым зашёл – последним вышел.

Стек позволяет хранить элементы и поддерживает, обычно, две базовые операции:

• PUSH – кладёт элемент на вершину стека
• POP – снимает элемент с вершины стека, перемещая вершину к следующему элементу

Также часто встречается операция PEEK, которая получает элемент на вершине стека, но не снимает его оттуда.

Стек является одной из базовых структур данных и используется не только в программировании, но и в схемотехнике, и просто в производстве, для реализации технологических процессов и т.д.; стек используется в качестве вспомогательной структуры данных во многих алгоритмах и в других более сложных структурах.

Пусть, например, у нас есть стек чисел. Выполним несколько команд. Изначально стек пуст. Вершина стека – указатель на первый элемент, никуда не указывает. В случае си она может быть равна NULL.

Теперь стек состоит из одного элемента, числа 3. Вершина стека указывает на число 3.

Стек состоит из двух элементов, 5 и 3, при этом вершина стека указывает на 5.

Стек состоит из трёх элементов, вершина стека указывает на 7.

Вернёт значение 7, в стеке останется 5 и 3. Вершина будет указывать на следующий элемент – 5.

Вернёт 5, в стеке останется всего один элемент, 3, на который будет указывать вершина стека.

Вернёт 3, стек станет пуст.

Часто сравнивают стек со стопкой тарелок. Чтобы достать следующую тарелку, необходимо снять предыдущие. Вершина стека – это вершина стопки тарелок.

Когда мы будем работать со стеком, возможны две основные и часто встречающиеся ошибки:

• 1. Stack Underflow: Попытка снять элемент с пустого стека
• 2. Stack Overflow: Попытка положить новый элемент на стек, который не может больше расти (например, не хватает оперативной памяти)

Программная реализация

• 1) Стек фиксированного размера на массиве
• 2) Динамически растущий стек на массиве
• 3) Динамически растущий стек на односвязном списке

Стек фиксированного размера, построенный на массиве

О тличительная особенность – простота реализации и максимальная скорость выполнения. Такой стек может применяться в том, случае, когда его максимальный размер известен заранее или известно, что он мал.

Сначала определяем максимальный размер массива и тип данных, которые будут в нём храниться:

#define STACK_MAX_SIZE 20 typedef int T;

Теперь сама структура

typedef struct Stack_tag < T data[STACK_MAX_SIZE]; size_t size; >Stack_t;

Здесь переменная size – это количество элементов, и вместе с тем указатель на вершину стека. Вершина будет указывать на следующий элемент массива, в который будет занесено значение.

Кладём новый элемент на стек.

void push(Stack_t *stack, const T value) < stack->data[stack->size] = value; stack->size++; >

Единственная проблема – можно выйти за пределы массива. Поэтому всегда надо проверять, чтобы не было ошибки Stack overflow:

#define STACK_OVERFLOW -100 #define STACK_UNDERFLOW -101 void push(Stack_t *stack, const T value) < if (stack->size >= STACK_MAX_SIZE) < exit(STACK_OVERFLOW); >stack->data[stack->size] = value; stack->size++; >

Аналогично, определим операцию Pop, которая возвращает элемент с вершины и переходит к следующему

T pop(Stack_t *stack) < if (stack->size == 0) < exit(STACK_UNDERFLOW); >stack->size--; return stack->data[stack->size]; >

И функция peek, возвращающая текущий элемент с вершины

T peek(const Stack_t *stack) < if (stack->size return stack->data[stack->size - 1]; >

Ещё одно важное замечание – у нас нет функции создания стека, поэтому необходимо вручную обнулять значение size

Вспомогательные функции для печати элементов стека

void printStackValue(const T value) < printf("%d", value); >void printStack(const Stack_t *stack, void (*printStackValue)(const T)) < int i; int len = stack->size - 1; printf("stack %d > ", stack->size); for (i = 0; i < len; i++) < printStackValue(stack->data[i]); printf(" | "); > if (stack->size != 0) < printStackValue(stack->data[i]); > printf("\n"); >

Заметьте, что в функции печати мы использует int, а не size_t, потому что значение len может стать отрицательным. Функция печатает сначала размер стека, а потом его содержимое, разделяя элементы символом |

Stack_t stack; stack.size = 0; push(&stack, 3); printStack(&stack, printStackValue); push(&stack, 5); printStack(&stack, printStackValue); push(&stack, 7); printStack(&stack, printStackValue); printf("%d\n", pop(&stack)); printStack(&stack, printStackValue); printf("%d\n", pop(&stack)); printStack(&stack, printStackValue); printf("%d\n", pop(&stack)); printStack(&stack, printStackValue); _getch();

Рассмотрим также ситуации, когда есть ошибки использования. Underflow

void main()

void main() < Stack_t stack; size_t i; stack.size = 0; for (i = 0; i < 100; i++) < push(&stack, i); >_getch(); >

Динамически растущий стек на массиве

Д инамически растущий стек используется в том случае, когда число элементов может быть значительным и не известно на момент решения задачи. Максимальный размер стека может быть ограничен каким-то числом, либо размером оперативной памяти.

Стек будет состоять из указателя на данные, размера массива (максимального), и числа элементов в массиве. Это число также будет и указывать на вершину.

typedef struct Stack_tag < T *data; size_t size; size_t top; >Stack_t;

Для начала понадобится некоторый начальный размер массива, пусть он будет равен 10

#define INIT_SIZE 10

Алгоритм работы такой: мы проверяем, не превысило ли значение top значение size. Если значение превышено, то увеличиваем размер массива. Здесь возможно несколько вариантов того, как увеличивать массив. Можно прибавлять число, можно умножать на какое-то значение. Какой из вариантов лучше, зависит от специфики задачи. В нашем случае будем умножать размер на число MULTIPLIER

#define MULTIPLIER 2

Максимального размера задавать не будем. Программа будет выпадать при stack overflow или stack underflow. Будем реализовывать тот же интерфейс (pop, push, peek). Кроме того, так как массив динамический, сделаем некоторые вспомогательные функции, чтобы создавать стек, удалять его и чистить.

Во-первых, функции для создания и удаления стека и несколько ошибок

#define STACK_OVERFLOW -100 #define STACK_UNDERFLOW -101 #define OUT_OF_MEMORY -102 Stack_t* createStack() < Stack_t *out = NULL; out = malloc(sizeof(Stack_t)); if (out == NULL) < exit(OUT_OF_MEMORY); >out->size = INIT_SIZE; out->data = malloc(out->size * sizeof(T)); if (out->data == NULL) < free(out); exit(OUT_OF_MEMORY); >out->top = 0; return out; > void deleteStack(Stack_t **stack) < free((*stack)->data); free(*stack); *stack = NULL; >

Всё крайне просто и понятно, нет никаких подвохов. Создаём стек с начальной длиной и обнуляем значения.

Теперь напишем вспомогательную функцию изменения размера.

void resize(Stack_t *stack) < stack->size *= MULTIPLIER; stack->data = realloc(stack->data, stack->size * sizeof(T)); if (stack->data == NULL) < exit(STACK_OVERFLOW); >>

Здесь, заметим, в случае, если не удалось выделить достаточно памяти, будет произведён выход с STACK_OVERFLOW.

Функция push проверяет, вышли ли мы за пределы массива. Если да, то увеличиваем его размер

void push(Stack_t *stack, T value) < if (stack->top >= stack->size) < resize(stack); >stack->data[stack->top] = value; stack->top++; >

Функции pop и peek аналогичны тем, которые использовались для массива фиксированного размера

T pop(Stack_t *stack) < if (stack->top == 0) < exit(STACK_UNDERFLOW); >stack->top--; return stack->data[stack->top]; > T peek(const Stack_t *stack) < if (stack->top return stack->data[stack->top - 1]; >

void main() < int i; Stack_t *s = createStack(); for (i = 0; i < 300; i++) < push(s, i); >for (i = 0; i < 300; i++) < printf("%d ", peek(s)); printf("%d ", pop(s)); >deleteStack(&s); _getch(); >

Напишем ещё одну функцию, implode, которая уменьшает массив до размера, равного числу элементов в массиве. Она может быть использована тогда, когда уже известно, что больше элементов вставлено не будет, и память может быть частично освобождена.

void implode(Stack_t *stack) < stack->size = stack->top; stack->data = realloc(stack->data, stack->size * sizeof(T)); >

Можем использовать в нашем случае

for (i = 0; i < 300; i++) < push(s, i); >implode(s); for (i = 0; i

Эта однопоточная реализация стека использует мало обращений к памяти, достаточно проста и универсальна, работает быстро и может быть реализована, при необходимости, за несколько минут. Она используется всегда в дальнейшем, если не указано иное.

У неё есть недостаток, связанный с методом увеличения потребляемой памяти. При умножении в 2 раза (в нашем случае) требуется мало обращений к памяти, но при этом каждое последующее увеличение может привести к ошибке, особенно при маленьком количестве памяти в системе. Если же использовать более щадящий способ выделения памяти (например, каждый раз прибавлять по 10), то число обращений увеличится и скорость упадёт. На сегодня, проблем с размером памяти обычно нет, а менеджеры памяти и сборщики мусора (которых нет в си) работают быстро, так что агрессивное изменение преобладает (на примере, скажем, реализации всей стандартной библиотеки языка Java).

Реализация стека на односвязном списке

Ч то такое односвязный список, будет подробнее рассказано дальше. Коротко: односвязный список состоит из узлов, каждый из которых содержит полезную информацию и ссылку на следующий узел. Последний узел ссылается на NULL.

Никакого максимального и минимального размеров у нас не будет (хотя в общем случае может быть). Каждый новый элемент создаётся заново. Для начала определим структуру узел

#define STACK_OVERFLOW -100 #define STACK_UNDERFLOW -101 #define OUT_OF_MEMORY -102 typedef int T; typedef struct Node_tag < T value; struct Node_tag *next; >Node_t;

Функция вставки первого элемента проста: создаём новый узел. Указатель next кидаем на старый узел. Далее указатель на вершину стека перекидываем на вновь созданный узел. Теперь вершина стека указывает на новый узел.

void push(Node_t **head, T value) < Node_t *tmp = malloc(sizeof(Node_t)); if (tmp == NULL) < exit(STACK_OVERFLOW); >tmp->next = *head; tmp->value = value; *head = tmp; >

Функция pop берёт первый элемент (тот, на который указывает вершина), перекидывает указатель на следующий элемент и возвращает первый. Здесь есть два варианта – можно вернуть узел или значение. Если вернём значение, то придётся удалять узел внутри функции

Node_t* pop1(Node_t **head) < Node_t *out; if ((*head) == NULL) < exit(STACK_UNDERFLOW); >out = *head; *head = (*head)->next; return out; >

T pop2(Node_t **head) < Node_t *out; T value; if (*head == NULL) < exit(STACK_UNDERFLOW); >out = *head; *head = (*head)->next; value = out->value; free(out); return value; >

Теперь вместо проверки на длину массива везде используется проверка на равенство NULL вершины стека.

Простая функция peek

T peek(const Node_t* head) < if (head == NULL) < exit(STACK_UNDERFLOW); >return head->value; >

Итерирование достаточно интересное. Просто переходим от одного узла к другому, пока не дойдём до конца

void printStack(const Node_t* head) < printf("stack >"); while (head) < printf("%d ", head->value); head = head->next; > >

И ещё одна проблема – теперь нельзя просто посмотреть размер стека. Нужно пройти от начала до конца и посчитать все элементы. Например, так

size_t getSize(const Node_t *head) < size_t size = 0; while (head) < size++; head = head->next; > return size; >

Конечно, можно хранить размер отдельно, можно обернуть стек со всеми данными ещё в одну структуру и т.д. Рассмотрим всё это при более подробном изучении списков.

void main() < int i; Node_t *head = NULL; for (i = 0; i < 300; i++) < push(&head, i); >printf("size = %d\n", getSize(head)); while (head) < printf("%d ", peek(head)); printf("%d ", pop2(&head)); >_getch(); >

void main() < int i; Node_t *head = NULL; Node_t *tmp; for (i = 0; i < 300; i++) < push(&head, i); >printf("size = %d\n", getSize(head)); while (head) < printf("%d ", peek(head)); tmp = pop1(&head); printf("%d ", tmp->value); free(tmp); > _getch(); >

ru-Cyrl 18- tutorial Sypachev S.S. 1989-04-14 sypachev_s_s@mail.ru Stepan Sypachev students

Всё ещё не понятно? – пиши вопросы на ящик

Класс stack

Класс адаптера контейнера шаблона, который предоставляет ограничение функциональности, ограничивая доступ к элементу, который был последним добавлен в некоторый тип базового контейнера. Класс stack используется, если важно ясно, что в контейнере выполняются только stack операции.

Синтаксис

template > class stack 

Параметры

Type
Тип данных элемента для сохранения в стеке.

Container
Тип базового контейнера, используемый для реализации стека. Значение по умолчанию — это класс deque .

Замечания

Элементы класса Type , указанного в первом параметре шаблона объекта стека, являются синонимами value_type и должны соответствовать типу элемента в базовом классе Container контейнера, заданном вторым параметром шаблона. Необходимо Type назначить его, чтобы можно было копировать объекты этого типа и назначать значения переменным этого типа.

Подходящие базовые классы контейнеров для стека включают deque , list класс и vector класс или любой другой контейнер последовательности, поддерживающий операции back , push_back и pop_back . Класс базового контейнера инкапсулирован в адаптер контейнера, который предоставляет только ограниченный набор функций-членов контейнера последовательностей в виде открытого интерфейса.

Объекты stack являются равными, если и только если элементы класса Type являются равными и являются менее сопоставимыми, если и только если элементы класса Type меньше, чем сопоставимы.

• Класс stack поддерживает структуру данных последней версии (LIFO). Хороший аналог такого подхода — стопка тарелок. Элементы (тарелки) можно вставлять, проверять или удалять только из верхней части стека, которая является последним элементом в конце базового контейнера. Ограничение доступа только к верхнему элементу является причиной использования stack класса.
• Класс queue поддерживает структуру данных fiFO. Хороший аналог такого подхода — очередь из людей к банковскому служащему. Элементы (люди) можно добавлять в конец очереди и удалять из начала очереди. Проверять можно как начало, так и конец очереди. Ограничение доступа только к элементам передней и задней части таким образом является причиной того, что мех использует queue класс.
• Класс priority_queue упорядочивает его элементы таким образом, чтобы самый большой элемент всегда был в верхней позиции. Он поддерживает вставку элемента, а также проверку и удаление верхнего элемента. Хороший аналог такого подхода — очередь из людей, упорядоченная по возрасту, росту или любому другому критерию.

Участники

Конструкторы

Имя	Описание
stack	Создает stack , который является пустым или копией объекта базового контейнера.

Определения типов

Имя	Описание
container_type	Тип, предоставляющий базовый контейнер для принятия stack .
size_type	Целочисленный Typedef без знака, который может представлять число элементов в stack .
value_type	Тип, представляющий тип объекта, который хранится в виде элемента в stack .

Функции

Имя	Описание
empty	Проверяет, является ли stack пустым.
pop	Удаляет элемент из верхней части stack .
push	Добавляет элемент в верхнюю часть stack .
size	Возвращает количество элементов в контейнере stack .
top	Возвращает ссылку на элемент в верхней части stack .

container_type

Тип, предоставляющий базовый контейнер для изменения.

typedef Container container_type; 

Замечания

Этот тип является синонимом для параметра шаблона Container . Все три класса контейнера последовательности стандартной библиотеки C++ — vector класс, list класс и класс deque по умолчанию — соответствуют требованиям, которые необходимо использовать в качестве базового контейнера для stack объекта. Также можно использовать пользовательские типы, удовлетворяющие таким требованиям.

Дополнительные сведения см. в разделе «Примечания Container » раздела stack «Класс «.

Пример

Пример объявления и использования container_type см. в примере stack::stack .

empty

Проверяет, пуст ли стек.

bool empty() const; 

Возвращаемое значение

true Значение , если стек пуст; false Значение , если стек не является непустим.

Пример

// stack_empty.cpp // compile with: /EHsc #include #include int main( ) < using namespace std; // Declares stacks with default deque base container stack s1, s2; s1.push( 1 ); if ( s1.empty( ) ) cout

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

pop

Удаляет элемент из верхней части стека.

void pop(); 

Замечания

Для применения функции-члена стек должен быть непустым. Начало (верх) стека — это положение, занимаемое последним добавленным элементом, которое является последним элементом в конце контейнера.

Пример

// stack_pop.cpp // compile with: /EHsc #include #include int main( ) < using namespace std; stack s1, s2; s1.push( 10 ); s1.push( 20 ); s1.push( 30 ); stack ::size_type i; i = s1.size( ); cout

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

Добавляет элемент в верхнюю часть стека.

void push(const Type& val); 

Параметры

val
Элемент, добавленный в верх стека.

Замечания

Начало (верх) стека — это положение, занимаемое последним добавленным элементом, которое является последним элементом в конце контейнера.

Пример

// stack_push.cpp // compile with: /EHsc #include #include int main( ) < using namespace std; stack s1; s1.push( 10 ); s1.push( 20 ); s1.push( 30 ); stack ::size_type i; i = s1.size( ); cout

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

size

Возвращает количество элементов в стеке.

size_type size() const; 

Возвращаемое значение

Текущая длина стека.

Пример

// stack_size.cpp // compile with: /EHsc #include #include int main( ) < using namespace std; stack s1, s2; stack ::size_type i; s1.push( 1 ); i = s1.size( ); cout

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

size_type

Целочисленный тип без знака, который может представлять количество элементов в стеке.

typedef typename Container::size_type size_type; 

Замечания

Этот тип является синонимом для size_type базового контейнера, адаптированного стеком.

Пример

Пример объявления и использования size_type см. в примере size .

stack

Создает стек, который является пустым или представляет собой копию класса базового контейнера.

stack(); explicit stack(const container_type& right); 

Параметры

right
Контейнер, копией которого должен стать создаваемый стек.

Пример

// stack_stack.cpp // compile with: /EHsc #include #include #include #include int main( ) < using namespace std; // Declares stack with default deque base container stack dsc1; //Explicitly declares a stack with deque base container stack  dsc2; // Declares a stack with vector base containers stack > vsi1; // Declares a stack with list base container stack > lsi; // The second member function copies elements from a container vector v1; v1.push_back( 1 ); stack > vsi2( v1 ); cout

The element at the top of stack vsi2 is 1. 

top

Возвращает ссылку на элемент вверху стека.

reference top(); const_reference top() const; 

Возвращаемое значение

Ссылка на последний элемент в контейнере, вставленный вверху стека.

Замечания

Для применения функции-члена стек должен быть непустым. Начало (верх) стека — это положение, занимаемое последним добавленным элементом, которое является последним элементом в конце контейнера.

Если возвращаемое значение top назначено объекту const_reference , stack объект нельзя изменить. Если возвращаемое значение top назначено объекту reference , stack объект можно изменить.

Пример

// stack_top.cpp // compile with: /EHsc #include #include int main( ) < using namespace std; stack 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 2. The next integer down is 1. 

value_type

Тип, представляющий тип объекта, который хранится в стеке в виде элемента.

typedef typename Container::value_type value_type; 

Замечания

Этот тип является синонимом для value_type базового контейнера, адаптированного стеком.

Пример

// stack_value_type.cpp // compile with: /EHsc #include #include int main( ) < using namespace std; // Declares stacks with default deque base container stack::value_type AnInt; AnInt = 69; cout << "The value_type is AnInt = " << AnInt << endl; stacks1; s1.push( AnInt ); cout

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