Поиск в тексте неодинаковых открытой и закрытой дужек или кавычек

/////////////////////////////////////////////////////////////////////////////////////////
//разработать программу по поиску в тексте неодинаковых открытой и закрытой скобок или кавычек.
//Исправить ошибки и сохранить файл
/////////////////////////////////////////////////////////////////////////////////////////
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
const   char    PARENTHESIS_LEFT    =   '(';
const   char    PARENTHESIS_RIGHT   =   ')';
 
const   char    BRACKET_LEFT        =   '[';
const   char    BRACKET_RIGHT       =   ']';
 
const   char    BRACE_LEFT          =   '{';
const   char    BRACE_RIGHT         =   '}';
 
const   char    SINGLE_QUOTE        =   '\'';
const   char    DOUBLE_QUOTE        =   '"';
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string             T_str;
typedef std::stack  < char  >   T_char_stack;
/////////////////////////////////////////////////////////////////////////////////////////
bool    is_left_bracket( char   symb )
{
    switch( symb )
    {
    case    PARENTHESIS_LEFT    :
    case    BRACKET_LEFT        :
    case    BRACE_LEFT          :
        return  true;
 
    default                     :
        return  false;
    }//switch
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    is_right_bracket( char   symb )
{
    switch( symb )
    {
    case    PARENTHESIS_RIGHT   :
    case    BRACKET_RIGHT       :
    case    BRACE_RIGHT         :
        return  true;
 
    default                     :
        return  false;
    }//switch
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    is_quote( char  symb )
{
    return      symb    ==  SINGLE_QUOTE
            ||  symb    ==  DOUBLE_QUOTE;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    is_bracket_or_quote( char   symb )
{
    return      is_left_bracket     ( symb )
            ||  is_right_bracket    ( symb )
            ||  is_quote            ( symb );
}
/////////////////////////////////////////////////////////////////////////////////////////
char    get_right_symb_for_left_symb_of_couple( char    L_symb )
{
    switch( L_symb )
    {
    case    PARENTHESIS_LEFT    :
        return  PARENTHESIS_RIGHT;
 
    case    BRACKET_LEFT        :
        return  BRACKET_RIGHT;
 
    case    BRACE_LEFT          :
        return  BRACE_RIGHT;
 
    default                     :
        return  L_symb;
    }//switch
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    left_and_right_symb_are_good_couple
    (
        char    L,
        char    R
    )
{
    return  R  ==  get_right_symb_for_left_symb_of_couple( L );
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    left_and_right_symb_are_bad_couple
    (
        char    L,
        char    R
    )
{
    return          is_left_bracket     ( L )
                &&  is_right_bracket    ( R )
 
            ||      is_quote            ( L )
                &&  is_quote            ( R );
}
/////////////////////////////////////////////////////////////////////////////////////////
void    for_left_symb_adjusted_right_symb
    (
        char        L,
        char    &   R
    )
{
    R  =   get_right_symb_for_left_symb_of_couple( L );
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    is_left_quote_for_stack
    (
        char                        symb,
        T_char_stack    const   &   char_stack
    )
{
    return      is_quote( symb )
 
            &&  (
                        char_stack.empty()
 
                    ||  !is_quote   (
                                        char_stack.top()
                                    )
                );
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    were_made_changes_of_incorrect_closing_brackets_or_quotes( T_str    &   text_str )
{
    T_char_stack    char_stack;
    bool            were_changes    =   false;
 
    for( size_t  i = 0; i < text_str.size(); ++i )
    {
        auto    &   cur_symb    =   text_str[i];
 
        if  (
                is_bracket_or_quote( cur_symb )
            )
        {
            if  (
                        is_left_bracket( cur_symb )
 
                    ||  is_left_quote_for_stack
                            (
                                cur_symb,
                                char_stack
                            )
                )
            {
                char_stack.push( cur_symb );
            }
            else//Текущий символ - правая скобка или кавычка.
            {
                if  (
                        char_stack.empty()
                    )
                {
                    std::ostringstream  sout;
 
                    sout    <<  "Позиция "
                            <<  i + 1
                            <<  ". Правая "
 
                            <<  (
                                    is_quote( cur_symb )
                                        ?   "кавычка"
                                        :   "скобка"
                                )
 
                            <<  " не имеет парной левой.";
 
                    throw   std::invalid_argument
                                (
                                    sout.str()
                                );
                }
                else if (
                            left_and_right_symb_are_good_couple
                                (
                                    char_stack.top(),
                                    cur_symb
                                )
                        )
                {
                    char_stack.pop();
                }
                else if (
                            left_and_right_symb_are_bad_couple
                                (
                                    char_stack.top(),
                                    cur_symb
                                )
                        )
                {
                    for_left_symb_adjusted_right_symb
                        (
                            char_stack.top(),
                            cur_symb
                        );
 
                    were_changes    =   true;
                    char_stack.pop();
                }
                else
                {
                    std::ostringstream  sout;
 
                    sout    <<  "Левая "
 
                            <<  (
                                    is_quote    (
                                                    char_stack.top()
                                                )
                                        ?   "кавычка"
                                        :   "скобка"
                                )
 
                            <<  ", расположенная левее позиции "
                            <<  i + 1
                            <<  " не имеет парной правой.";
 
 
                    throw   std::invalid_argument
                                (
                                    sout.str()
                                );
                }//else
            }//else
        }//if
    }//for
 
    if  (
            !char_stack.empty()
        )
    {
        throw   std::invalid_argument( "Не хватает правых скобок или кавычек." );
    }
 
    return  were_changes;
}
/////////////////////////////////////////////////////////////////////////////////////////
int     get_rand_val_in_segment
    (
        int     L,
        int     R
    )
{
    return  rand() % ( R - L + 1 ) + L;
}
/////////////////////////////////////////////////////////////////////////////////////////
T_str   get_rand_text_str()
{
    int                     rand_str_len    =   get_rand_val_in_segment( 4, 10 );
    static  const   T_str   SYMB_STR        =   "ABCDEFGHIJKLMNOPQRST'\"'\"'\"'\"()()[][]{}{},;: ";
    T_str                   res_str;
 
    for( int  i = 0; i < rand_str_len; ++i )
    {
        res_str.push_back
            (
                SYMB_STR    [
                                rand() % SYMB_STR.size()
                            ]
            );
    }//for
 
    return  res_str;
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    srand(unsigned(time(0)));
 
    for(;;)
    {
        for(;;)
        {
            T_str   text_str    =   get_rand_text_str();
 
            std::cout   <<  std::endl
                        <<  std::endl
                        <<  std::endl
                        <<  text_str
                        <<  std::endl;
 
            try
            {
                std::cout   <<  (
                                    were_made_changes_of_incorrect_closing_brackets_or_quotes( text_str )
                                        ?   "В тексте закрывающие скобки или кавычки заменены на корректные."
                                        :   "Текст корректен и оставлен без изменений."
                                )
 
                            <<  std::endl
                            <<  text_str
                            <<  std::endl
                            <<  std::endl;
 
                break;
            }
            catch( std::exception   const   &   e )
            {
                std::cout   <<  e.what()
                            <<  std::endl;
            }
        }//for
 
        system("pause");
    }//for
}