### 思路
1. **初始化栈**：创建一个空栈用于存储左括号。
2. **遍历字符串**：逐个字符检查：
   - 如果是左括号（`(` 或 `[`），则入栈。
   - 如果是右括号（`)` 或 `]`），则检查栈是否为空：
     - 如果栈为空，说明缺少左括号，输出错误信息。
     - 如果栈不为空，弹出栈顶元素并检查是否匹配：
       - 如果匹配，继续检查下一个字符。
       - 如果不匹配，输出错误信息。
3. **检查栈是否为空**：遍历结束后，如果栈为空，说明括号匹配；否则，说明缺少右括号。

### 伪代码
```
function InitStack(S):
    allocate memory for S.base of size STACK_INIT_SIZE
    S.top = S.base
    S.stacksize = STACK_INIT_SIZE
    return OK

function StackEmpty(S):
    return S.top == S.base

function Push(S, e):
    if S.top - S.base >= S.stacksize:
        reallocate memory for S.base with size S.stacksize + STACKINCREMENT
        S.top = S.base + S.stacksize
        S.stacksize += STACKINCREMENT
    S.top = e
    S.top += 1
    return OK

function Pop(S, e):
    if S.top == S.base:
        return ERROR
    S.top -= 1
    e = S.top
    return OK

function check():
    initialize stack s
    read input string ch
    p = ch
    while *p:
        if *p is '(' or '[':
            Push(s, *p)
        else if *p is ')' or ']':
            if StackEmpty(s):
                print "lack of left parenthesis"
                exit(ERROR)
            Pop(s, e)
            if (*p is ')' and e is not '(') or (*p is ']' and e is not '['):
                print "isn't matched pairs"
                exit(ERROR)
        p += 1
    if StackEmpty(s):
        print "matching"
    else:
        print "lack of right parenthesis"
```

### C++代码
 

#include <iostream>
#include <cstdlib>
using namespace std;

typedef char SElemType;
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;
#define STACK_INIT_SIZE 10
#define STACKINCREMENT 2

struct SqStack {
    SElemType *base;
    SElemType *top;
    int stacksize;
};

Status InitStack(SqStack &S) {
    S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
    if (!S.base) exit(ERROR);
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
    return OK;
}

Status StackEmpty(SqStack S) {
    return S.top == S.base ? TRUE : FALSE;
}

Status Push(SqStack &S, SElemType e) {
    if (S.top - S.base >= S.stacksize) {
        S.base = (SElemType *)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));
        if (!S.base) exit(ERROR);
        S.top = S.base + S.stacksize;
        S.stacksize += STACKINCREMENT;
    }
    *S.top++ = e;
    return OK;
}

Status Pop(SqStack &S, SElemType &e) {
    if (S.top == S.base) return ERROR;
    e = *--S.top;
    return OK;
}

void check() {
    SqStack s;
    SElemType ch[80], *p, e;
    if (InitStack(s)) {
        cin >> ch;
        p = ch;
        while (*p) {
            switch (*p) {
                case '(':
                case '[':
                    Push(s, *p);
                    p++;
                    break;
                case ')':
                case ']':
                    if (!StackEmpty(s)) {
                        Pop(s, e);
                        if ((*p == ')' && e != '(') || (*p == ']' && e != '[')) {
                            cout << "isn't matched pairs" << endl;
                            exit(ERROR);
                        } else {
                            p++;
                            break;
                        }
                    } else {
                        cout << "lack of left parenthesis" << endl;
                        exit(ERROR);
                    }
                default:
                    p++;
            }
        }
        if (StackEmpty(s))
            cout << "matching" << endl;
        else
            cout << "lack of right parenthesis" << endl;
    }
}

int main() {
    check();
    return 0;
}