Работа со стеком (проверить правильность расстановки скобок)

#include <vcl.h>
#pragma hdrstop
#include <string.h>
#include <stdio.h>
#include <stack.h>
#pragma argsused
int main()
{
string s;
stack <string> st;
s="{x+(g-[f+h]*c)-(q+w)}";
printf("%s", s); // пыталась вывести строку на экран,но чего то не работает
for (int i=1;i<=s.size() ;i++)
{
if (s.substr(i,1)=="{" || s.substr(i,1)=="[" || s.substr(i,1)=="(")
st.push(s.substr(i,1));
if (s.substr(i,1)=="}" || s.substr(i,1)=="]" || s.substr(i,1)==")")
st.pop(s.substr(i,1));
}
if (st.empty()) printf("good");
else  printf("gbad");
getchar();
return 0;
}

#include "MTL_Stack.h"
#include <string>
#include <iostream>
#include <iomanip>
 
bool foo(std::string & sourcestr){
    std::string openstr="([{";
    std::string closestr=")]}";
    std::string::size_type pos_offset=0;
    MTL::Stack<std::string::size_type> st;
    for(std::string::iterator it=sourcestr.begin();it!=sourcestr.end();++it){
        if ((pos_offset=openstr.find(*it,0))!=std::string::npos){
            st.push(pos_offset);
        }else{
            if((pos_offset=closestr.find(*it,0))!=std::string::npos){
                if(st.empty()){
                    return false;
                }
                if(pos_offset==st.top()){
                    //Совпадение
                    st.pop();
                }else{
                    //Ожидается другая скобка
                    return false;
                }
            }
        }
    }
    return st.empty();
}
 
 
 
int main(){
    std::string sourcestr="[(2+2)*2+((2+4)+6)-[({}{}){}]]";
    std::cout<<std::boolalpha<<foo(sourcestr)<<std::endl;
}

#include <ctime>
#include <cstdlib>
#include <iostream>
#include <string>
#include <stack>
 
bool isOpenBracket(char symbol) {
  return symbol == '(' || symbol == '{' || symbol == '[';
}
 
bool isClosingBracket(char symbol) {
  return symbol == ')' || symbol == '}' || symbol == ']';
}
 
char getOpenBracketPair(char bracket) {
  return (bracket == '}') ? '{' : (bracket == ')') ? '(' :
    (bracket == ']') ? '[' : '\0';
}
 
bool areParenthesesGood(const std::string &source) {
  std::stack<char> stack;
  for (size_t i = 0; i < source.size(); ++i) {
    if (isOpenBracket(source[i])) {
      stack.push(source[i]);
    } else {
      if (isClosingBracket(source[i])) {
        char openBracket = getOpenBracketPair(source[i]);
        if (!stack.empty() && stack.top() == openBracket) {
          stack.pop();
        } else {
          return false;
        }
      }
    }
  }
  return stack.empty();
}
 
int main(int argc, char *argv[]) {
  srand(time(0));
 
  std::string expression = "{x+(g-[f+h]*c)-(q+w)}";
  std::cout << areParenthesesGood(expression) << std::endl;
  
  std::cin.get();
  return 0;
}

bool isPosl(std::string& some)
{
    int brackets = 0;
    return (std::find_if(some.begin(), some.end(), [&brackets](char ch)
    {
        brackets += (ch == '(');
        brackets -= ((ch == ')') && (brackets > 0));
 
        return brackets == 0;
    }) != some.end()) ? true : false;
}

#include <iostream>
#include <string>
 
int main() {
    
    std::string s = "[(2+2)*2+(2+4)+6)-[({}{}){}]]";
    
    int brackets = 0;
    for (char ch : s) {
        brackets += (ch == '(' || ch == '[' || ch == '{');
        brackets -= (ch == ')' || ch == ']' || ch == '}');
    }
    
    (brackets == 0) ? std::cout << "well" : std::cout << "ugly";
    
    return 0;
}

#include <iostream>
#include <string>
#include <map>
#include <stack>
 
std::map<char, char> brackets = {
    {')', '('},
    {'}', '{'},
    {']', '['}
};
 
inline bool open_brackets(char ch) {
    return ch == '(' || ch == '{' || ch == '[';
}
 
inline bool close_brackets(char ch) {
    return ch == ')' || ch == '}' || ch == ']';
}
 
bool good_sequence(std::string& str) 
{
    std::stack<char> st;
    for (auto ch : str) {
        if (open_brackets(ch)) st.push(ch);
        else if (close_brackets(ch)) {
            if (!st.empty() && st.top() == brackets[ch]) 
                st.pop();
            else 
                return false;
        }
    }
    return st.empty();
}
 
int main()
{
    std::string s = "([]))";
    (good_sequence(s)) ? std::cout << "yes" : std::cout << "no";
    system("pause");
    return 0;
}