Checking balanced parantheses code is not behaving as per expectation

Question

I am solving a question in which I have to check if the input string of parentheses are balanced or not, and if not, code is expected to return the 1-based index of unmatched closing parenthesis, and if not found, return the 1-based index of the opening parenthesis. My code runs fine if I implement only the parenthesis checking part, but as I try to implement the returning index part, the code starts giving 'success' output for all the input. Here is the code:

#include<iostream>
#include<string>
#include<algorithm>
#include<stack>

using namespace std;

int process_input( string value );
bool closing_bracket_match(char opening_bracket, char closing_bracket);

bool closing_bracket_match(char opening_bracket , char closing_bracket){ 
    if( (opening_bracket == '{' && closing_bracket == '}') || (opening_bracket == '(' && closing_bracket == ')') || (opening_bracket == '[' &&
     closing_bracket == ']') ){
       
        return true;
    }
    else{
        return false;
    }
}

int process_input( string value ){
    stack<char> processed_input{};
    int unmatched_index{};

    for( size_t i{}; i< value.size() ; ++i ){
        
        if( value.at(i) == '{' || value.at(i) == '(' || value.at(i) == '[' ){ // check for opening brackets
            
            processed_input.push(value.at(i)); // Appending opening bracket into the stack
        
        }
        
        else if( (value.at(i) == '}' || value.at(i) == ')' || value.at(i) == ']') && (processed_input.empty() == false) &&
         closing_bracket_match(processed_input.top(),value.at(i)) ){ // the bracket in stack would be popped
            
            processed_input.pop(); // matching brackets ar removed

        }
    }
    if( processed_input.empty()==true ){
        return 0;
    }//This part is causing the bug
    if(processed_input.empty() == false){
        auto it = find( value.begin(), value.end(), processed_input.top() );
        if( it!= value.end() ){
            unmatched_index = distance(value.begin() , it)+1;  //returning the 1 -based index of unmatched bracket
        }
    return unmatched_index;
    }
}

int main(){
    string input{};
    cout<<"Please enter the code here: "; // debug line
    cin>> input;

    int result{};
    result = process_input(input);

    if( result == 0 ){
        cout<<"Success";
    }
    else{
        cout<<result;
    }
}

Answer 1

If you want to return a position of the last (innermost) unmatched paren, you need to store it together with its position on the stack. Seeking for it leads to errors.

Which of potentially several items equal to the one you seek will find() find?

For example, in "(((" there are three unmatched opening parentheses, and all of them are equal to '('. Which one do you want to return as a result? Which one do you actually return?

And how about this input: "()("...?

---

Added

Here is a possible solution. Please note how it does not find() anything, but it stores on a stack all information necessary to produce the desired output.

#include<iostream>
#include<string>
#include<stack>

using std::string;
using std::stack;

bool is_opening(char c) {
    return c == '(' || c == '[' || c == '{';
}

bool is_closing(char c) {
    return c == ')' || c == ']' || c == '}';
}

bool is_matching(char opn, char cls) {
    switch(opn) {
        case '(':  return cls == ')';
        case '[':  return cls == ']';
        case '{':  return cls == '}';
    }
    return false;
}

int process_input( string value )
{
    stack<char> opn_parens{};
    stack<size_t> positions{};

    for( size_t i{}; i < value.size() ; ++i )
    {        
        const char ch = value.at(i);

        if( is_opening(ch) )
        {            
            opn_parens.push(ch);
            positions.push(i);
        }
        else if( is_closing(ch) )
        {
            if( opn_parens.empty() ) // a closing paren with no unmatched opening one
                return i + 1;

            const char opn_ch = opn_parens.top();
            const size_t opn_pos = positions.top();
            
            if( ! is_matching(opn_ch, ch) ) // unmatched closing paren
                return opn_pos + 1;

            opn_parens.pop(); // remove a matched paren
            positions.pop();
        }
    }

    if( ! positions.empty() ) // some unmatched parens remain
        return positions.top() + 1;

    return 0;
}

int main(){
    std::cout << process_input("hello(mum[]{(dad()[bro!])})") << std::endl;
    std::cout << process_input("))") << std::endl;
    std::cout << process_input("([") << std::endl;
    std::cout << process_input("([)") << std::endl;
    std::cout << process_input("([{") << std::endl;
}

You can see it working at https://godbolt.org/z/e8fYW5fKz