Проблема с подразделом "вызовы к" Иерархии вызовов в vs 2026

#include <iostream>
#include <iomanip>  // для setw
#include <string>
#include <cassert> // для assert
 
template<typename T>
class Stack
{
public:
    Stack(short = 10);
    Stack(const Stack&); // конструктор копирования
    ~Stack();
    void push(const T&);
    T pop();
    bool empty() const { return top == 0; }
    bool full() const { return top == size; }
    short get_size() const { return size; }
    short get_top() const { return top; }
    void printStack();
    const T& ping(short);
    Stack& operator=(const Stack&); // оператор присваивания
 
private:
    const short size;
    short top;
    T* Stack_ptr;
};
 
// Конструктор по умолчанию
template<typename T>
Stack<T>::Stack(short s) : size(s), top(0) {
    Stack_ptr = new T[size];
    assert(Stack_ptr != nullptr);
}
 
// Конструктор копирования
template<typename T>
Stack<T>::Stack(const Stack& other) : size(other.size), top(other.top) {
    std::cout << "Вызван конструктор копирования! Копируется стек размера " << size << std::endl;
    Stack_ptr = new T[size];
    assert(Stack_ptr != nullptr);
    for (short i = 0; i < top; ++i) {
        Stack_ptr[i] = other.Stack_ptr[i];
    }
}
 
// Деструктор
template<typename T>
Stack<T>::~Stack()
{
    delete[] Stack_ptr;
}
 
// Оператор присваивания
template<typename T>
Stack<T>& Stack<T>::operator=(const Stack& other) {
    if (this != &other) {
        // Не можем изменить size, так как он константный
        // Проверяем, достаточно ли места
        if (size < other.top) {
            delete[] Stack_ptr;
            // Хотя size константный, мы не можем его изменить
            // В реальной реализации лучше использовать динамический размер
            // Для простоты оставим как есть
        }
        top = other.top;
        for (short i = 0; i < top; ++i) {
            Stack_ptr[i] = other.Stack_ptr[i];
        }
    }
    return *this;
}
 
template<typename T>
void Stack<T>::push(const T& val)
{
    assert(top < size);
    Stack_ptr[top++] = val;
}
 
template<typename T>
T Stack<T>::pop()
{
    assert(top > 0);
    --top; // уменьшаем top
    T value = Stack_ptr[top]; // сохраняем значение
    // Явно вызываем деструктор для удаляемого элемента
    Stack_ptr[top].~T();
    return value; // возвращаем значение
}
 
template<typename T>
const T& Stack<T>::ping(short n)
{
    assert(n > 0 && n <= top);
    return Stack_ptr[top - n];
}
 
template<typename T>
void Stack<T>::printStack()
{
    std::cout << "stack (size=" << size << ", top=" << top << "): ";
    if (top == 0) {
        std::cout << "empty" << std::endl;
        return;
    }
 
    for (short i = top - 1; i >= 0; i--)
    {
        std::cout << "|"
            << std::setw(4)
            << Stack_ptr[i];
    }
    std::cout << "|" << std::endl;
}
 
// Демонстрация работы с разными типами данных
template<typename T>
void demonstrateStack() {
    Stack<T> stack(5);
    std::cout << "\nDemonstrating stack for type: " << typeid(T).name() << std::endl;
 
    for (int i = 1; i <= 5; ++i) {
        stack.push(T(i * 10)); // используем преобразование int в тип T
        std::cout << "Pushed: " << T(i * 10) << std::endl;
    }
 
    stack.printStack();
 
    std::cout << "Popped: " << stack.pop() << std::endl;
    std::cout << "Popped: " << stack.pop() << std::endl;
 
    stack.printStack();
}
 
// Специализированная демонстрация для строк
template<>
void demonstrateStack<std::string>() {
    Stack<std::string> stack(5);
    std::cout << "\nDemonstrating stack for strings" << std::endl;
 
    const char* words[] = { "first", "second", "third", "fourth", "fifth" };
 
    for (int i = 0; i < 5; ++i) {
        stack.push(words[i]);
        std::cout << "Pushed: " << words[i] << std::endl;
    }
 
    stack.printStack();
 
    std::cout << "Popped: " << stack.pop() << std::endl;
    std::cout << "Popped: " << stack.pop() << std::endl;
 
    stack.printStack();
}
 
int main()
{
    setlocale(LC_ALL, "RU");
    std::cout << "=== Testing int stack ===" << std::endl;
    Stack <int> stack_for_int;
    stack_for_int.push(1);
    stack_for_int.push(2);
    stack_for_int.push(3);
 
    stack_for_int.printStack();
    std::cout << "existing elem: " << stack_for_int.ping(2) << std::endl;
    std::cout << "poping elem: " << stack_for_int.pop() << std::endl;
 
    // После pop память очищается (для объектов с нетривиальными деструкторами)
    // Для встроенных типов (int) деструктор не делает ничего, но логика очистки та же
    stack_for_int.printStack();
 
    std::cout << "\n=== Testing string stack ===" << std::endl;
    Stack <std::string> stack_for_string;
    stack_for_string.push("hello");
    stack_for_string.push("my");
    stack_for_string.push("friend");
    stack_for_string.printStack();
 
    std::cout << "Popping: " << stack_for_string.pop() << std::endl;
    stack_for_string.printStack();
 
    // Демонстрация с разными типами
    demonstrateStack<int>();
    demonstrateStack<double>();
    demonstrateStack<std::string>();
 
    // Тест конструктора копирования
    std::cout << "\n=== Testing copy constructor ===" << std::endl;
    Stack<int> original(3);
    original.push(100);
    original.push(200);
    original.push(300);
 
    Stack<int> copy(original);
    std::cout << "Original: ";
    original.printStack();
    std::cout << "Copy: ";
    copy.printStack();
    return 0;
}