请使用C语言实现一个计算器系统。n功能要求：n1利用栈结构n2能够完成支持嵌套功能的四则运算并正确输出结果n3支持小数级别的运算n4能够完成幂的运算能够进行根号的运算

由于计算器系统的复杂性较高，需要使用较多的代码实现。在此，我将给出一个简单的实现，仅供参考。

首先，我们需要定义一个栈结构，用于存储运算符和操作数。

typedef struct StackNode {
    float data;
    char op;
    struct StackNode *next;
} StackNode, *Stack;

其中，data表示操作数的值，op表示运算符，next表示下一个节点的地址。

接下来，我们需要定义一些基本的操作函数，包括创建栈、入栈、出栈、获取栈顶元素等。

Stack createStack() {
    Stack s = (Stack)malloc(sizeof(StackNode));
    s->next = NULL;
    return s;
}

void push(Stack s, float data, char op) {
    StackNode *new_node = (StackNode *)malloc(sizeof(StackNode));
    new_node->data = data;
    new_node->op = op;
    new_node->next = s->next;
    s->next = new_node;
}

void pop(Stack s) {
    if (s->next != NULL) {
        StackNode *temp = s->next;
        s->next = temp->next;
        free(temp);
    }
}

float top(Stack s) {
    if (s->next != NULL) {
        return s->next->data;
    }
    return 0;
}

char top_op(Stack s) {
    if (s->next != NULL) {
        return s->next->op;
    }
    return '\0';
}

int is_empty(Stack s) {
    return s->next == NULL;
}

有了基本的栈操作函数，我们就可以进行四则运算的计算了。我们可以使用中缀表达式转后缀表达式的方法，然后再计算后缀表达式的值。具体实现如下：

float calculate(char *expr) {
    Stack op_stack = createStack();
    Stack num_stack = createStack();
    char *p = expr;
    while (*p != '\0') {
        if (isdigit(*p) || *p == '.') {
            float num = atof(p);
            push(num_stack, num, '\0');
            while (isdigit(*p) || *p == '.') p++;
        } else if (*p == '+' || *p == '-') {
            while (!is_empty(op_stack) && top_op(op_stack) != '(') {
                float num2 = top(num_stack);
                pop(num_stack);
                float num1 = top(num_stack);
                pop(num_stack);
                char op = top_op(op_stack);
                pop(op_stack);
                float result = calculate_operation(num1, num2, op);
                push(num_stack, result, '\0');
            }
            push(op_stack, 0, *p);
            p++;
        } else if (*p == '*' || *p == '/') {
            while (!is_empty(op_stack) && top_op(op_stack) != '(' &&
                   top_op(op_stack) != '+' && top_op(op_stack) != '-') {
                float num2 = top(num_stack);
                pop(num_stack);
                float num1 = top(num_stack);
                pop(num_stack);
                char op = top_op(op_stack);
                pop(op_stack);
                float result = calculate_operation(num1, num2, op);
                push(num_stack, result, '\0');
            }
            push(op_stack, 0, *p);
            p++;
        } else if (*p == '(') {
            push(op_stack, 0, *p);
            p++;
        } else if (*p == ')') {
            while (!is_empty(op_stack) && top_op(op_stack) != '(') {
                float num2 = top(num_stack);
                pop(num_stack);
                float num1 = top(num_stack);
                pop(num_stack);
                char op = top_op(op_stack);
                pop(op_stack);
                float result = calculate_operation(num1, num2, op);
                push(num_stack, result, '\0');
            }
            pop(op_stack);
            p++;
        } else if (*p == '^' || *p == 's') {
            push(op_stack, 0, *p);
            p++;
        } else {
            p++;
        }
    }
    while (!is_empty(op_stack)) {
        float num2 = top(num_stack);
        pop(num_stack);
        float num1 = top(num_stack);
        pop(num_stack);
        char op = top_op(op_stack);
        pop(op_stack);
        float result = calculate_operation(num1, num2, op);
        push(num_stack, result, '\0');
    }
    return top(num_stack);
}

float calculate_operation(float num1, float num2, char op) {
    switch (op) {
        case '+':
            return num1 + num2;
        case '-':
            return num1 - num2;
        case '*':
            return num1 * num2;
        case '/':
            return num1 / num2;
        case '^':
            return pow(num1, num2);
        case 's':
            return sqrt(num1);
        default:
            return 0;
    }
}

在代码中，calculate函数接收一个表达式，然后将其转换为后缀表达式，并计算其值。calculate_operation函数用于计算两个操作数之间的运算。

至此，我们就完成了一个简单的计算器系统的实现。需要注意的是，此实现仅为一个简单的示例，还有很多需要优化和改进的地方。