Sample that check input string on opened and closed brackets.

brackets.cpp

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2022 https://github.com/TheVice/
 *
 */

#include <list>
#include <string>
#include <utility>
#include <algorithm>

bool isValid(const std::string& source)
{
    static const char bracket_open_1 = '(';
    static const char bracket_open_2 = '[';
    static const char bracket_open_3 = '{';
    //
    static const char bracket_close_1 = ')';
    static const char bracket_close_2 = ']';
    static const char bracket_close_3 = '}';
    //
    std::list<std::pair<size_t, size_t>> list_1;
    std::list<std::pair<size_t, size_t>> list_2;
    std::list<std::pair<size_t, size_t>> list_3;
    //
    auto pair_1 = std::make_pair(std::string::npos, std::string::npos);
    auto pair_2 = std::make_pair(std::string::npos, std::string::npos);
    auto pair_3 = std::make_pair(std::string::npos, std::string::npos);

    for (auto n = source.cbegin(); n != source.cend(); ++n)
    {
        bool pass = false;

        switch (*n)
        {
        case bracket_open_1:
            if (std::string::npos != std::get<0>(pair_1))
            {
                list_1.push_back(pair_1);
            }
            std::get<0>(pair_1) = std::distance(source.cbegin(), n);
            break;
        case bracket_open_2:
            if (std::string::npos != std::get<0>(pair_2))
            {
                list_2.push_back(pair_2);
            }
            std::get<0>(pair_2) = std::distance(source.cbegin(), n);
            break;
        case bracket_open_3:
            if (std::string::npos != std::get<0>(pair_3))
            {
                list_3.push_back(pair_3);
            }
            std::get<0>(pair_3) = std::distance(source.cbegin(), n);
            break;
        case bracket_close_1:
            pass = false;
            if (std::string::npos == std::get<0>(pair_1))
            {
                for (auto& n_ : list_1)
                {
                    if (std::string::npos == std::get<1>(n_))
                    {
                        pass = true;
                        std::get<1>(n_) = std::distance(source.cbegin(), n);
                        break;
                    }
                }

                if (!pass)
                {
                    return false;
                }
            }
            if (!pass)
            {
                std::get<1>(pair_1) = std::distance(source.cbegin(), n);
            }
            break;
        case bracket_close_2:
            pass = false;
            if (std::string::npos == std::get<0>(pair_2))
            {
                for (auto& n_ : list_2)
                {
                    if (std::string::npos == std::get<1>(n_))
                    {
                        pass = true;
                        std::get<1>(n_) = std::distance(source.cbegin(), n);
                        break;
                    }
                }

                if (!pass)
                {
                    return false;
                }
            }

            if (!pass)
            {
                std::get<1>(pair_2) = std::distance(source.cbegin(), n);
            }
            break;
        case bracket_close_3:
            pass = false;
            if (std::string::npos == std::get<0>(pair_3))
            {
                

                for (auto& n_ : list_3)
                {
                    if (std::string::npos == std::get<1>(n_))
                    {
                        pass = true;
                        std::get<1>(n_) = std::distance(source.cbegin(), n);
                        break;
                    }
                }

                if (!pass)
                {
                    return false;
                }
            }
            if (!pass)
            {
                std::get<1>(pair_3) = std::distance(source.cbegin(), n);
            }
            break;
        }

        if (std::string::npos != std::get<0>(pair_1) &&
            std::string::npos != std::get<1>(pair_1))
        {
            list_1.push_back(pair_1);
            std::get<0>(pair_1) = std::get<1>(pair_1) = std::string::npos;
        }

        if (std::string::npos != std::get<0>(pair_2) &&
            std::string::npos != std::get<1>(pair_2))
        {
            list_2.push_back(pair_2);
            std::get<0>(pair_2) = std::get<1>(pair_2) = std::string::npos;
        }

        if (std::string::npos != std::get<0>(pair_3) &&
            std::string::npos != std::get<1>(pair_3))
        {
            list_3.push_back(pair_3);
            std::get<0>(pair_3) = std::get<1>(pair_3) = std::string::npos;
        }
    }

    if ((std::string::npos != std::get<0>(pair_1) &&
        std::string::npos == std::get<1>(pair_1)) ||
        (std::string::npos == std::get<0>(pair_1) &&
            std::string::npos != std::get<1>(pair_1)))
    {
        return false;
    }

    if ((std::string::npos != std::get<0>(pair_2) &&
        std::string::npos == std::get<1>(pair_2)) ||
        (std::string::npos == std::get<0>(pair_2) &&
            std::string::npos != std::get<1>(pair_2)))
    {
        return false;
    }

    if ((std::string::npos != std::get<0>(pair_3) &&
        std::string::npos == std::get<1>(pair_3)) ||
        (std::string::npos == std::get<0>(pair_3) &&
            std::string::npos != std::get<1>(pair_3)))
    {
        return false;
    }

    for (const auto n1 : list_1)
    {
        for (const auto n2 : list_2)
        {
            if (std::get<0>(n2) < std::get<0>(n1) &&
                std::get<0>(n1) < std::get<1>(n2) &&
                std::get<1>(n2) < std::get<1>(n1))
            {
                return false;
            }
        }
    }

    for (const auto n1 : list_2)
    {
        for (const auto n2 : list_1)
        {
            if (std::get<0>(n2) < std::get<0>(n1) &&
                std::get<0>(n1) < std::get<1>(n2) &&
                std::get<1>(n2) < std::get<1>(n1))
            {
                return false;
            }
        }
    }

    for (const auto n1 : list_1)
    {
        for (const auto n2 : list_3)
        {
            if (std::get<0>(n2) < std::get<0>(n1) &&
                std::get<0>(n1) < std::get<1>(n2) &&
                std::get<1>(n2) < std::get<1>(n1))
            {
                return false;
            }
        }
    }

    for (const auto n1 : list_3)
    {
        for (const auto n2 : list_1)
        {
            if (std::get<0>(n2) < std::get<0>(n1) &&
                std::get<0>(n1) < std::get<1>(n2) &&
                std::get<1>(n2) < std::get<1>(n1))
            {
                return false;
            }
        }
    }

    for (const auto n1 : list_2)
    {
        for (const auto n2 : list_3)
        {
            if (std::get<0>(n2) < std::get<0>(n1) &&
                std::get<0>(n1) < std::get<1>(n2) &&
                std::get<1>(n2) < std::get<1>(n1))
            {
                return false;
            }
        }
    }

    for (const auto n1 : list_3)
    {
        for (const auto n2 : list_2)
        {
            if (std::get<0>(n2) < std::get<0>(n1) &&
                std::get<0>(n1) < std::get<1>(n2) &&
                std::get<1>(n2) < std::get<1>(n1))
            {
                return false;
            }
        }
    }

    return true;
}