C++ для начинающих. Динамические структуры данных. СТЕК

Опубликовано 05.09.2012 | Автор: admin

В этот раз я опишу создание стека. На самом деле стек уже описывался на странице: С++ для начинающих. Однонаправленный список LIFO. Но первое время я не различал, что есть стек, а что есть список и не понимал, что тот стек — это тот же список. Поэтому получилось две темы: одна расписывает наиболее полно, вторая коротко обозначает понятие стека как динамической структуры данных.

Стек — это такой линейный список, в котором и добавление новых и удаление существующих элементов возможно только с головного элемента.

Часто стек сравнивают с ящиком, в который, например, складывают кирпичи; часто — со стопкой тарелок. Также стек часто называют LIFO, что обозначает "последним пришёл, первым ушёл". Наверное, последнее может быть непонятно, поэтому поясню на цифрах.

Вводим: 1,2,3,4,5
На выходе 5,4,3,2,1

Организацию стека можно представлять следующим образом: (см. картинку-анимашку)

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

Указатель, который сохраняет адреса объектов, ниже в коде назван Next. Несмотря на то, что он переводится как следующий, фактически мы направляем его на элемент, уходящий в прошлое. Т. е. если пытаться воспринять его самым привычным образом, то он как указатель на предыдущий элемент. Поскольку началом постоянно обозначается самый последний сцепленный элемент, то следующим для него (при обходе всех его элементов) будет предпоследний, а следующий для предпоследнего идущий перед ним. Это как обход в обратном направлении. Отправная точка — последний элемент.

Как правило, для стека определены следующие операции:

Проверка стека на пустоту
Добавление элемента в стек
Считывание головного элемента
Удаление головного элемента
Очистка стека

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

Не буду описывать код слишком подробно, ограничусь описанием в комментариях. Для создания и использования стека (или динамического списка LIFO) будем использовать 4 функции: (main(), Добавить в список, Показать список, Удалить список из памяти).

//Листинг #1
#include <iostream>

using namespace std;
/*НАША СТРУКТУРА*/
struct List
{
    int x;                                              //информационный элемент
    List *Next,*Head;                                   //Голова стека и указатель на следующий элемент
};

/*ФУНКЦИЯ ДОБАВЛЕНИЯ ЭЛЕМЕНТА В СТЕК (в список LIFO)*/
void Add(int x, List *&MyList)                          //Принимаем элемент стека и указатель на стек, при этом говорим, что принимаемый указатель будет сам по себе указателем
{
    List *temp = new List;                              //Выделяем память для нового элемента
    temp->x = x;                                        //Записываем в поле x принимаемый в функцию элемент x
    temp->Next = MyList->Head;                          //Указываем, что следующий элемент это предыдущий
    MyList->Head = temp;                                //Сдвигаем голову на позицию вперед
}

/*ФУНКЦИЯ ОТОБРАЖЕНИЯ СТЕКА*/
void Show(List *MyList)                                 //Нужен только сам стек
{
    List *temp = MyList->Head;                          //Объявляем указатель и Указываем ему, что его позиция в голове стека
    //с помощью цикла проходим по всему стеку
    while (temp != NULL)                                //выходим при встрече с пустым полем
    {
        cout << temp->x << " ";                         //Выводим на экран элемент стека
        temp = temp->Next;                              //Переходим к следующему элементу
    }
}

/*ФУНКЦИЯ УДАЛЕНИЯ СТЕКА ИЗ ПАМЯТИ*/
void ClearList(List *MyList)
    {
    while (MyList->Head != NULL)                        //Пока по адресу не пусто
    {
        List *temp = MyList->Head->Next;                    //Временная переменная для хранения адреса следующего элемента
        delete MyList->Head;                                //Освобождаем адрес обозначающий начало
        MyList->Head = temp;                                //Меняем адрес на следующий
    }
}

int main()
{
    List *MyList = new List; //Выделяем память для стека


    MyList->Head = NULL; //Во избежание ошибок инициализируем первый элемент

    for (int i=0; i<10; i++) Add(i,MyList); //Заносим данные в стек
    Show(MyList); //Выводим стек на экран

    ClearList(MyList); //Очищаем память.
    delete MyList->Head;
    delete MyList;
}

//Листинг #1

#include <iostream>

using namespace std;

/*НАША СТРУКТУРА*/

struct List

{

int x; //информационный элемент

List *Next,*Head; //Голова стека и указатель на следующий элемент

};

/*ФУНКЦИЯ ДОБАВЛЕНИЯ ЭЛЕМЕНТА В СТЕК (в список LIFO)*/

void Add(int x, List *&MyList) //Принимаем элемент стека и указатель на стек, при этом говорим, что принимаемый указатель будет сам по себе указателем

{

List *temp = new List; //Выделяем память для нового элемента

temp->x = x; //Записываем в поле x принимаемый в функцию элемент x

temp->Next = MyList->Head; //Указываем, что следующий элемент это предыдущий

MyList->Head = temp; //Сдвигаем голову на позицию вперед

}

/*ФУНКЦИЯ ОТОБРАЖЕНИЯ СТЕКА*/

void Show(List *MyList) //Нужен только сам стек

{

List *temp = MyList->Head; //Объявляем указатель и Указываем ему, что его позиция в голове стека

//с помощью цикла проходим по всему стеку

while (temp != NULL) //выходим при встрече с пустым полем

{

cout << temp->x << " "; //Выводим на экран элемент стека

temp = temp->Next; //Переходим к следующему элементу

}

/*ФУНКЦИЯ УДАЛЕНИЯ СТЕКА ИЗ ПАМЯТИ*/

void ClearList(List *MyList)

{

while (MyList->Head != NULL) //Пока по адресу не пусто

{

List *temp = MyList->Head->Next; //Временная переменная для хранения адреса следующего элемента

delete MyList->Head; //Освобождаем адрес обозначающий начало

MyList->Head = temp; //Меняем адрес на следующий

}

int main()

{

List *MyList = new List; //Выделяем память для стека

MyList->Head = NULL; //Во избежание ошибок инициализируем первый элемент

for (int i=0; i<10; i++) Add(i,MyList); //Заносим данные в стек

Show(MyList); //Выводим стек на экран

ClearList(MyList); //Очищаем память.

delete MyList->Head;

delete MyList;

}

Я смотрю на свой первоначальный код (LIFO Первое знакомство), там с классами. И меня посещают мысли: "Неужели так сложно дать то, что так просто?" Я ведь много страниц тогда перерыл и не нашел этого.

Чтобы привести этот код к классическому пониманию стека, достаточно заменить мои temp -переменные на (*MyList) и тогда даже при простом просмотре просмотренные данные будут сразу теряться. Удаляться не будут, но связь потеряется. И если так сделаете, то будут паразитировать эти призраки стека и пожирать вашу память отныне и вовеки веков. При работе с динамическими данными надо быть очень внимательным к памяти и не нужно этого забывать.

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

В моем примере стек был построен на основе линейного связного списка, но стеки могут реализовываться на различных структурах данных: на одномерных статических и динамических массивах, на линейных списках, с помощью файлов… В общем, стек можно реализовать на любой структуре, в которой есть возможность хранить несколько элементов и если есть то, куда можно сохранять данные.

==============================================================
Ещё один пример стека:

//Листинг #2        Стек        LIFO
#include <iostream>

struct stek
{
    int value;
    struct stek *next;                      // указатель на следующий элемент списка (стека)
};

void push(stek* &NEXT, const int VALUE)
{
    stek *MyStack = new stek;               // объявляем новую динамическую переменную типа stek
    MyStack->value = VALUE;                 // записываем значение, которое помещается в стек
    MyStack->next = NEXT;                   // связываем новый элемент стека с предыдущим
    NEXT = MyStack;                         // новый элемент стека становится его вершиной
}

int pop(stek* &NEXT)
{
    int temp = NEXT->value;                 // извлекаем в переменную temp значение в вершине стека
    stek *MyStack = NEXT;                   // запоминаем указатель на вершину стека, чтобы затем
                                            // освободить выделенную под него память
    NEXT = NEXT->next;                      // вершиной становится предшествующий top элемент
    delete MyStack;                         // освобождаем память, тем самым удалили вершину
    std::cout << temp;                      //Вывод текущего элемента на экран
    return temp;                            // возвращаем значение, которое было в вершине
}

int main()
{
    stek *p=0;

    push(p,100);                            //Положили в стек 100
    push(p,200);                            //Положили в стек 200

    pop(p);                                 //вывели на экран текущий элемент стека = 200
    pop(p);                                 //вывели на экран текущий элемент стека = 100

    return 0;
}

//Листинг #2 Стек LIFO

#include <iostream>

struct stek

{

int value;

struct stek *next; // указатель на следующий элемент списка (стека)

};

void push(stek* &NEXT, const int VALUE)

{

stek *MyStack = new stek; // объявляем новую динамическую переменную типа stek

MyStack->value = VALUE; // записываем значение, которое помещается в стек

MyStack->next = NEXT; // связываем новый элемент стека с предыдущим

NEXT = MyStack; // новый элемент стека становится его вершиной

}

int pop(stek* &NEXT)

{

int temp = NEXT->value; // извлекаем в переменную temp значение в вершине стека

stek *MyStack = NEXT; // запоминаем указатель на вершину стека, чтобы затем

// освободить выделенную под него память

NEXT = NEXT->next; // вершиной становится предшествующий top элемент

delete MyStack; // освобождаем память, тем самым удалили вершину

std::cout << temp; //Вывод текущего элемента на экран

return temp; // возвращаем значение, которое было в вершине

}

int main()

{

stek *p=0;

push(p,100); //Положили в стек 100

push(p,200); //Положили в стек 200

pop(p); //вывели на экран текущий элемент стека = 200

pop(p); //вывели на экран текущий элемент стека = 100

return 0;

}

Рубрика: LIFO, Базовые знания, level "classer", Динамические структуры, Знакомства, Классы, Структуры

Аноним:

08.01.2013 в 1:59 пп

Малочик!

Ответить

Qasta:

13.01.2013 в 3:48 дп

Спасибо!!!

Den4ik:

21.02.2013 в 9:53 дп

Спасибо, большое.

Ксю и Даша:

07.03.2013 в 12:22 пп

СПАСИБО огромное!
благодаря тебе мы сдадим лабу!!! :****

02.04.2013 в 11:56 пп

😳 🙂 👿 😛 ❓ 😛 🙁

25.12.2013 в 2:42 пп

LIFO (Last In, First Out) — последний пришел, первый ушел. Смотрите абзац: Часто стек сравнивают с ящиком…

Andrey:

30.12.2013 в 1:04 дп

спасибо огромное!!!!!

вывыаа:

28.02.2014 в 3:03 пп

пасиба памагли

02.04.2014 в 12:58 дп

Это самый лучший стек который я видел, огромный респект автору,кратко,четко, по существу, очень помог, спасибо!

глупый анон:

31.05.2014 в 11:20 пп

ОГРОМНОЕ СПАСИБО АВТОРУ!!! ВСЕ ЗДОРОВО ВСЕ ПОНЯТНО теперь получу допуск к экзамену)

только вот компилятор ругался на эти строки

temp->Next=(*MyList)->Head; //Указываем, что следующий элемент это предыдущий
(*MyList)->Head=temp; //Сдвигаем голову на позицию вперед

1 2	temp->Next=(MyList)->Head; //Указываем, что следующий элемент это предыдущий (MyList)->Head=temp; //Сдвигаем голову на позицию вперед

я заменил так и все заработало)

temp->Next=MyList->Head; //Указываем, что следующий элемент это предыдущий
    MyList->Head=temp; //Сдвигаем голову на позицию вперед

1 2	temp->Next=MyList->Head; //Указываем, что следующий элемент это предыдущий MyList->Head=temp; //Сдвигаем голову на позицию вперед

27.09.2014 в 11:37 дп

Здрааасьте)

Ann:

17.11.2014 в 6:49 пп

Спасибо

Александр:

31.01.2015 в 3:38 пп

Только что попробовал запустить программу, компилятор выдал ошибку, что Х не объявлен в функции добавления. Я исправил немного код, необходимо было еще добавить (temp->x). Я просто подумал может кому-то понадобиться.

cout<<temp->x<<" "; //Выводим на экран элемент стека
temp=temp->Next; //Переходим к следующему элементу

1 2	cout<<temp->x<<" "; //Выводим на экран элемент стека temp=temp->Next; //Переходим к следующему элементу

Андрей:

26.02.2015 в 11:34 дп

Автор, в первом примере стека у Вас утечка памяти. Внимательно проверьте код еще раз. Как вообще можно было такое написать? Последний элемент всегда занимает память и не освобождается. К краху это не приводит, но память съедается.

admin:

26.02.2015 в 12:35 пп

Да, есть утечка, исправлю. Чем кроме этого вас такое написание не устраивает?

26.02.2015 в 1:28 пп

К первому больше нечего придираться. А вот ко второму… В функции pop в аргументе Вы передаете указатель на ссылку. По Вашим утверждением в комментариях, мол не будет создаваться копия, на самом деле все равно будет, но копия переданной переменной-указателя, то есть копия адреса все равно создается. К слову можно юбыло обойтись просто указателем. Все вроде.

26.02.2015 в 1:53 пп

Почему она должна создаваться и чем это отличается от создаётся локальная копия адреса внутри функции, мне кажется тут вы заблуждаетесь. Происходит обычная передача указателя по ссылке.

26.02.2015 в 2:33 пп

Может быть заблуждаюсь, однако по Стивену Прата и Страуструпу:

Там говорится о том, что сама переменная-аргумент, даже в таком виде:

void func (int *arg);

Так вот адрес попеёод переменную arg также выделяется память для хранения копии адреса переданного ууеазателя.
т.е

int a = 5;
int *p_a = &a;

func (p_a);

В данном случае действительно данные из а не копируются, а вот значение переменной p_a, то есть адрес переменной а передается в новый указатель arg. Если бы этого не происходило, то Вы могли бы в функции func написать такое:

arg = какой-какой-то адрес;

И указатель p_a поменял бы свое значение и указывал бы на что-то другое и пятерка бы не вывелась. Этого не происходит так как в действительности мы все равно работаем с копией, только уже копией адреса. В общем проверьте пример, посиотрите что Стивен Прата пишет, Вы поймете.

26.02.2015 в 3:36 пп

Есть более простой пример доказать мне мою неправоту.

#include <iostream>

void foo(int *Arr){
        std::cout<<  (void *)&Arr << "\n";
}

void foo2(int **Arr){
        std::cout<<  (void *)&Arr << "\n";
}

int main(){
    int x=10;
    int *A=&x;

    std::cout<<"int  *arr == "<<(void *)&A<<"  "; foo(A);
    std::cout<<"int **arr == "<<(void *)&A<<"  "; foo2(&A);
}

void foo(int *Arr){

std::cout<< (void *)&Arr << "\n";

void foo2(int **Arr){

int main(){

int x=10;

int *A=&x;

std::cout<<"int *arr == "<<(void *)&A<<" "; foo(A);

std::cout<<"int **arr == "<<(void *)&A<<" "; foo2(&A);

И все встает на свои места. Я ошибся. Надо не **, а *&
Спасибо, что указали на этот момент. Я считал, что ** то же, что и *&, а оно вон он какое хитрое оказывается.

Если на что еще наткнетесь, дайте знать. Спасибо за помощь.

admin:

26.02.2015 в 3:45 пп

Если обойтись просто указателем, то, вроде бы, должно действовать общее правило для всех локальных переменных. По завершению функции копия указателя уничтожается. Любое обращение к тому что там было — это как обращение к мусорным переменным, что может вызвать крах программы.

(Я могу ошибаться, но по моей логике так)

Ответить

26.02.2015 в 1:31 пп

Для очистки стека кстати можно было бы просто while звзаменить на do — while и перед циклом проверку на непостоту текущего элемента вставить.

admin:

26.02.2015 в 2:58 пп

Я поправил немного не как вы просили. Проблема с утечкой решена?

Ответить
- Андрей:
  
  26.02.2015 в 9:33 пп
  
  Да, так решена.
  
  Ответить

Freerider:

25.04.2015 в 10:38 дп

Накатал свой вариант стека совместил несколько программ может кому-нибудь понадобится

#include <iostream>
#include <string.h>
#include "vld.h"
using namespace std;
#define MAX 8;
typedef int MyType;
struct Elem
{

 

MyType data;
Elem *prev;
};
class Stack
{
// Указатель на вершину стека
int CountElem;
Elem *Head;
public:
// Конструктор
Stack();
~Stack();
// Добавление элемента
void Push(MyType);
// Извлечение элемента
MyType Pop();
// Очистка стека
void Clear();
// Проверка существования элементов в стеке
bool IsEmpty();
// Проверка на переполнение стека
bool IsFull();
// Количество элементов в стеке
int GetCount();
};
Stack::Stack()
{
// Изначально стек пуст
CountElem=0;
Head=NULL;
}
Stack::~Stack()
{
Clear();
}
void Stack::Clear()
{
Elem *temp;
while(Head!=NULL)
{
temp=Head;
Head=Head->prev;
delete temp;
}
}

bool Stack::IsEmpty()
{
// Пуст?
return CountElem == 0;
}

bool Stack::IsFull()
{
// Полон?
return CountElem == MAX;
}

int Stack::GetCount()
{
// Количество присутствующих в стеке элементов
return CountElem;
}

void Stack::Push(MyType d)
{
if(!IsFull())
{
Elem *temp=new Elem;
temp->data=d;
temp->prev=NULL;
if(Head!=NULL)
temp->prev=Head;

Head=temp;
CountElem++;
}
}

MyType Stack::Pop()
{
if(!IsEmpty())
{
Elem *temp=Head;
Head=Head->prev;
int x=temp->data;
delete temp;
CountElem–;
return x;
}
else throw 0;

}

void main()
{
Stack ST;

for (int i = 0; i < 10; i++)
{
ST.Push(i);
}

try
{
while(1)
{
cout<<ST.Pop()<<endl;
}
}
catch(int g){}
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

#include <string.h>

#include "vld.h"

#define MAX 8;

typedef int MyType;

struct Elem

MyType data;

Elem *prev;

class Stack

// Указатель на вершину стека

int CountElem;

Elem *Head;

public:

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

Stack();

~Stack();

// Добавление элемента

void Push(MyType);

// Извлечение элемента

MyType Pop();

// Очистка стека

void Clear();

// Проверка существования элементов в стеке

bool IsEmpty();

// Проверка на переполнение стека

bool IsFull();

// Количество элементов в стеке

int GetCount();

Stack::Stack()

// Изначально стек пуст

CountElem=0;

Head=NULL;

Stack::~Stack()

Clear();

void Stack::Clear()

Elem *temp;

while(Head!=NULL)

temp=Head;

Head=Head->prev;

delete temp;

bool Stack::IsEmpty()

// Пуст?

return CountElem == 0;

bool Stack::IsFull()

// Полон?

return CountElem == MAX;

int Stack::GetCount()

// Количество присутствующих в стеке элементов

return CountElem;

void Stack::Push(MyType d)

if(!IsFull())

Elem *temp=new Elem;

temp->data=d;

temp->prev=NULL;

if(Head!=NULL)

temp->prev=Head;

Head=temp;

CountElem++;

MyType Stack::Pop()

if(!IsEmpty())

Elem *temp=Head;

int x=temp->data;

CountElem–;

return x;

else throw 0;

void main()

Stack ST;

for (int i = 0; i < 10; i++)

ST.Push(i);

try

while(1)

cout<<ST.Pop()<<endl;

catch(int g){}

27.04.2015 в 4:03 пп

помогите)) где нужно прописать этот код класса со стеком!? я его прописывала в
Microsoft Visual Studio, c расширением «.с» где найти как поэтапно создать эту программу с правильным расширением и настройками

#include <iostream>
class stack {
private:
int size;
int* data;
size_t ptr;
public:
stack(int valid_stack_size) {
this->size = valid_stack_size;
this->ptr = 0;
this->data = new int[valid_stack_size];
}~stack() {
delete[] this->data;
}
void push(int value) {
if (this->ptr >= (size_t)this->size)
throw “stack is full\n”;
this->data[this->ptr++] = value;
}
int pop() {
if (this->ptr == 0)
throw “stack is empty”;
return this->data[–this->ptr];
}
};
int main() {
stack* f=new stack(10);
f->push(1);
f->push(2);
f->push(3);
std::cout<<f->pop()<<“\n”;
std::cout<<f->pop()<<“\n”;
std::cout<<f->pop()<<“\n”;
return 0;
}

class stack {

private:

int size;

int* data;

size_t ptr;

stack(int valid_stack_size) {

this->size = valid_stack_size;

this->ptr = 0;

this->data = new int[valid_stack_size];

}~stack() {

delete[] this->data;

void push(int value) {

if (this->ptr >= (size_t)this->size)

throw “stack is full\n”;

this->data[this->ptr++] = value;

int pop() {

if (this->ptr == 0)

throw “stack is empty”;

return this->data[–this->ptr];

stack* f=new stack(10);

f->push(1);

f->push(2);

f->push(3);

std::cout<<f->pop()<<“\n”;

admin:

27.04.2015 в 5:35 пп

В основном окне программы. Так же само как HelloWorld на экран вывести

Ответить

Дима:

01.07.2015 в 12:41 пп

1 2	temp->Next=MyList->Head; //Указываем, что следующий элемент это предыдущий MyList->Head=temp; //Сдвигаем голову на позицию вперед

Объясните, пожалст — в 1-й строчке:

каким образом работают эти строчки? указателю «Next» становится равен указатель » Head». Почему на «Next» указывает указатель «temp», а на » Head » указатель «MyList»?

во 2-й строчке:

указателю «Head» на который указывает » MyList » приравнивается значение указателя » temp» ?

01.07.2015 в 12:45 пп

А чему тогда равно значение указателя ” temp” ?

admin:

02.07.2015 в 4:07 пп

temp Просто указывает на область памяти, которая хранит блок стека. Для удобства можно воспринимать этот temp блоком памяти, хотя он блоком памяти не является. А из этого блока памяти нам доступны отдельные кусочки этого блока, эти кусочки нам и нужны. Их я в примере и задействываю. temp — это указатель на начало такого блока памяти.

Ответить

Алексей:

02.07.2015 в 7:39 пп

Есть предложение заменить во втором примере аргументы d и next на другие переменные, а то так запутаться можно.

08.07.2015 в 12:38 пп

спасибо!

ДМ:

17.05.2016 в 6:51 дп

Если нужно сначала ввести число в стек (диалог с пользователем), после ввода числа вывести массив из чисел.

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

igor:

10.06.2019 в 4:41 пп

а почему тут копия указателя, а не *& для изменений
/*ФУНКЦИЯ УДАЛЕНИЯ СТЕКА ИЗ ПАМЯТИ*/
void ClearList(List *MyList)

10.06.2019 в 11:09 пп

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

#include <iostream>

using namespace std;


void foo1(int *ptr){
    int x = 20;     //<-- внутренняя обработка
    ptr = &x;
}

void foo2(int *&ptr){
    int x = 30;     //<-- влияние на внешнюю сущность
    ptr = &x;
}

int main()
{
    int a = 10;
    int *ptr1 = &a;
    int *ptr2 = &a;

    foo1(ptr1);
    cout << "foo1(*) \t ptr1 = " << *ptr1 << '\n';

    foo2(ptr2);
    cout << "foo2(*&) \t ptr2 = " << *ptr2 << '\n';

}

void foo1(int *ptr){

int x = 20; //<-- внутренняя обработка

ptr = &x;

void foo2(int *&ptr){

int x = 30; //<-- влияние на внешнюю сущность

int a = 10;

int *ptr1 = &a;

int *ptr2 = &a;

foo1(ptr1);

cout << "foo1(*) \t ptr1 = " << *ptr1 << '\n';

foo2(ptr2);

cout << "foo2(*&) \t ptr2 = " << *ptr2 << '\n';

Почистить память можно и внутренним обходительством.

23.06.2019 в 5:09 пп

😳

апвпв:

04.01.2020 в 6:21 пп

До чего уродливое оформление! Автору кол в сердце!

Последние комментарии

Александр к записи Хороший стиль программирования
Аноним к записи Список тем сайта
Аноним к записи Список тем сайта

C++ для начинающих. Динамические структуры данных. СТЕК

36 комментариев на «“C++ для начинающих. Динамические структуры данных. СТЕК”»

Добавить комментарий Отменить ответ

Поиск

Последние темы

Случайная книга в электронном формате

Последние комментарии

Мета