Проверить строку на сбалансированность скобок

#pragma once
#include <iostream>
#include <fstream>
#include <functional>
#include <string>
#define _CRTDBG_MAP_ALLOC//проверка корректности данных
#include <crtdbg.h>
#define DBG_NEW new(_NORMAL_BLOCK,__FILE__,__LINE__)
#define newDBG_NEW
 
 
template <typename TInfo>
struct NODE
{
    TInfo info;
    NODE* next;
    NODE(TInfo info, NODE* ptr = nullptr) :info(info), next(ptr) {}
    ~NODE()
    {
        next = nullptr;
    }
};
 
template <typename TInfo>
class STACKLIST
{
using ptrNODE = NODE<TInfo>*;
private:
    ptrNODE head;
public:
    STACKLIST()
    {
        head = NULL;
    }
    ~STACKLIST()
    {
        while (!empty())
            pop();
    }
    TInfo top()
    {
        if (!empty())
            return head->info;
    }
    bool empty()
    {
        return head;
    }
    void push(TInfo elem) {
        ptrNODE p = new NODE<TInfo>(elem, head);
        head = p;
    }
    void pop() {
        ptrNODE node;
        if (!head == NULL)
        {
            node = head;
            head = head->next;
            delete node;
        }
    }
    void print() {
        if (empty())
            std::cout << "Список пуст!\n";
        else
        {
            ptrNODE p = head;
            while (p)
            {
                std::cout << p->info << ' ';
                p = p->next;
            }
            std::cout << '\n';
        }
    }
};

#include "STACKARR.h"
#include "STACKLIST.h"
#include <sstream>
using namespace std;
 
 
bool is_correct(const std::string& str)
{
    STACKLIST<char> stack;
 
    for (int i = 0; i < (int)str.length(); ++i)
    {
        if (str[i] == '(' || str[i] == '{' || str[i] == '[')
        {
            stack.push(str[i]);
        }
        else if (str[i] == ')' || str[i] == '}' || str[i] == ']')
        {
            if
                (
                    !stack.empty()
                    || ((str[i] == ')') ^ (stack.top() == '('))
                    || ((str[i] == '}') ^ (stack.top() == '{'))
                    || ((str[i] == ']') ^ (stack.top() == '['))
                    )
            {
                return false;
            }
 
            stack.pop();
        }
    }
 
    return stack.empty();
}
 
int main()
{
    setlocale(LC_ALL, "Russian");
    std::string str;
    std::cin >> str;
 
    std::cout << (is_correct(str) ? "Yes" : "No") << std::endl;
    return 0;
}

// проверка правильной расстановки скобок в строке s
#define push(sp, value)  (*sp++ = (value))
#define pop(sp) (*--sp)
 
bool check_brackets(char* s)
{
  unsigned len = strlen(s);
  if (!len) return true;
  
  char *stack = new char[len], *sp = stack; 
  bool error = false;
  
  for (; !error && *s; s++)  
    switch (*s)
    {
      case '(': push(sp, ')'); break;
      case '[': push(sp, ']'); break;
      case '{': push(sp, '}'); break;
      case ')':
      case ']': 
      case '}': error = (sp == stack) || (pop(sp) != *s);
    } 
  
  error |= sp != stack;
  delete []stack; 
  return !error; 
}

    void pop() {
        ptrNODE node;
        if (head)
        {
            node = head;
            head = head->next;
            delete node;
        }
    }

#include <iostream>
#include <stdexcept>
 
template <typename T> // сократил имя параметра типа
struct Node { // имя класса больше не орёт
    T value; // более семантически значимое имя
    Node* next;
    Node(T value, Node* ptr = nullptr) : value(value), next(ptr) {}
    // деструктор не нужОн
};
 
template <typename T> // сократил имя параметра типа
class LinkedListStack { // переименовал в семантически более значимое имя и оно больше не кричит на меня
    // using ptrNODE = Node<T>*; // избавился, это не нужно
public:
    LinkedListStack() : head(nullptr) {} // инициализация переехала в блок инициализации, используется типизированный nullptr
 
    // Добавлены конструктор копирования
    LinkedListStack<T> &operator=(const LinkedListStack<T> &) = delete;
    // и оператор присваивания
    LinkedListStack(const LinkedListStack<T> &) = delete;
 
    ~LinkedListStack() {
        while (!empty()) {
            pop();
        }
    }
 
    const T &top() const { // исправлена сигнатура на константный метод, возвращающий константную ссылку
        // убран if -- с ним возвращается бред, добавлено исключение
        if (empty()) {
            throw std::underflow_error("stack is empty");
        }
        return head->value;
    }
    bool empty() const { // сигнатура теперь константного метода
        return head == nullptr; // исправлена проверка на пустоту
    }
    // параметр исправлен с передачи по значению на передачу по константной ссылке
    void push(const T &value) {
        head = new Node<T>(value, head); // так короче
    }
    void pop() {
        // добавлено исключение в случае извлечения из пустого стека
        if (empty()) {
            throw std::underflow_error("stack is empty");
        }
        // убрана проверка на null и временная переменная объявляется и назначается в одной строке
        Node<T> *tmp = head;
        head = head->next;
        delete tmp;
    }
 
    // метод print заменён для удобства на оператор вывода в поток
    friend std::ostream &operator<<(std::ostream &out, const LinkedListStack<T> &stack) {
        // убрал вывод сообщения "список пуст!"
        // и сделал вывод в цикле for, так существенно короче
        for (Node<T> *i = stack.head; i != nullptr; i = i->next) {
            out << i->value << ' ';
        }
        return out;
    }
 
private: // блок private переехал в конец класса, так привычнее
    Node<T> *head; // заменил именованный тип на действительный
};
 
// имена поменяны на более семантически близкие мне
bool isCorrect(const std::string &value) {
    LinkedListStack<char> stack;
    for (char c : value) { // краткая форма прохода по итерируемым объектам
        // if перешел в case, поменяны местами случаи открывающих и закрывающих скобок -- так короче
        switch (c) {
            case '(': stack.push(')'); break;
            case '[': stack.push(']'); break;
            case '{': stack.push('}'); break;
            case ')':
            case ']':
            case '}':
                // если стек пуст или зкрывающая скобка не та
                if (stack.empty() || stack.top() != c) {
                    return false; // некорректная расстановка скобок
                }
                stack.pop();
                break;
        }
    }
    return stack.empty(); // расстановка скобок корректа только если по завершению стек пустой
}
 
int main() {
    std::string str;
    std::cin >> str;
 
    std::cout << (isCorrect(str) ? "Yes" : "No") << std::endl;
    return 0;
}