C语言中return括号里有判断语句

在C语言中，return语句后面可以跟一个表达式，这个表达式可以是一个值、变量或者一个完整的表达式。当return语句被执行时，它会将这个表达式的值作为函数的返回值返回给调用者。

如果你提到的"括号里有判断语句"是指在return语句中使用条件判断语句，那么是不正确的。在return语句中，我们只能使用一个表达式作为返回值，而不能使用条件判断语句。

例如：

int add(int a, int b) {
    if (a > b) {
        return a;
    }
    else {
        return b;
    }
}

在上面的例子中，我们定义了一个函数add，它接收两个整数参数a和b。在函数内部，我们使用条件判断语句if-else来比较a和b的大小，然后通过return语句返回较大的值作为函数的返回值。

请注意，return语句可以出现在函数的任何地方，但一旦执行到return语句，函数将立即返回并结束执行。因此，在一个函数中，可能会有多个return语句，但只会执行其中一个。

相关问题

括号匹配的c语言代码

这段C语言代码实现了括号匹配的功能。它使用了栈这种数据结构，当输入左括号时，将其压入栈中，当输入右括号时，如果与栈顶的左括号匹配，则将栈顶的左括号出栈。最后判断栈是否为空，如果为空则说明括号匹配成功，否则匹配失败。

代码中使用了一个结构体Stack来表示栈，其中包括栈的长度、栈顶指针和一个字符数组作为栈的存储空间。判断函数judge用来判断输入的字符是哪种括号，方便下面主函数中的if语句的判断条件。

代码中还有一些细节需要注意，比如在输入字符时需要判断是否到达了字符串的结尾，以及在判断括号匹配时需要判断栈是否为空。

下面是这段代码的实现：

#include <stdio.h>
#include <stdlib.h>

char array[] = {'(', '[', '{', '+'};

int judge(char x) {
    if (x == ')') {
        return 0;
    }
    if (x == ']') {
        return 1;
    }
    if (x == '}') {
        return 2;
    }
    else {
        return 3;
    }
}

typedef struct {
    int len;
    int top;
    char a[100];
} Stack;

int main() {
    Stack s;
    s.len = 100;
    s.top = -1;
    int x;
    while (1) {
        scanf("%c", &x);
        if (x == '\n' || x == '\0') {
            break;
        }
        if (s.top == -1 || s.a[s.top] != array[judge(x)]) {
            s.top++;
            s.a[s.top] = x;
        }
        else {
            s.top--;
        }
    }
    if (s.top == -1) {
        printf("yes");
    }
    else {
        printf("no");
    }
    return 0;
}

用c语言实现计算器要求1.加减乘除2.进制转换3.可以判断括号内先加减功能

好的，这是一个比较复杂的问题，需要较多的代码实现。我将分为以下几个部分来回答你的问题。

1. 加减乘除的实现

我们可以使用 switch 语句来实现加减乘除的功能。具体代码如下：

#include <stdio.h>

int main()
{
    char operator;
    double num1, num2, result;

    printf("请输入运算符 (+, -, *, /): ");
    scanf("%c", &operator);

    printf("请输入两个数字: ");
    scanf("%lf %lf", &num1, &num2);

    switch(operator)
    {
        case '+':
            result = num1 + num2;
            break;
        case '-':
            result = num1 - num2;
            break;
        case '*':
            result = num1 * num2;
            break;
        case '/':
            result = num1 / num2;
            break;
        // 如果运算符不是加减乘除之一，则提示错误信息
        default:
            printf("错误！运算符不正确");
            return 0;
    }

    printf("%.2lf %c %.2lf = %.2lf", num1, operator, num2, result);

    return 0;
}

2. 进制转换的实现

我们可以编写函数来实现进制转换的功能。具体代码如下：

#include <stdio.h>
#include <string.h>

// 将十进制数转换为二进制数
void decimalToBinary(int decimal)
{
    int binary[32];
    int i = 0;
    
    while(decimal > 0)
    {
        binary[i] = decimal % 2;
        decimal = decimal / 2;
        i++;
    }

    printf("二进制数为: ");
    for(int j = i - 1; j >= 0; j--)
    {
        printf("%d", binary[j]);
    }
}

// 将二进制数转换为十进制数
void binaryToDecimal(char binary[])
{
    int decimal = 0;
    int len = strlen(binary);

    for(int i = 0; i < len; i++)
    {
        decimal = decimal * 2 + (binary[i] - '0');
    }

    printf("十进制数为: %d", decimal);
}

int main()
{
    int decimal;
    char binary[32];

    printf("请输入一个十进制数: ");
    scanf("%d", &decimal);

    decimalToBinary(decimal);

    printf("\n请输入一个二进制数: ");
    scanf("%s", binary);

    binaryToDecimal(binary);

    return 0;
}

3. 判断括号内先加减的功能的实现

我们可以使用栈来实现括号内先加减的功能。具体代码如下：

#include <stdio.h>
#include <string.h>

#define MAX_SIZE 100

// 定义栈结构体
typedef struct {
    int data[MAX_SIZE];
    int top;
} Stack;

// 初始化栈
void initStack(Stack *s)
{
    s->top = -1;
}

// 判断栈是否为空
int isEmpty(Stack *s)
{
    if(s->top == -1)
    {
        return 1;
    }

    return 0;
}

// 判断栈是否已满
int isFull(Stack *s)
{
    if(s->top == MAX_SIZE - 1)
    {
        return 1;
    }

    return 0;
}

// 入栈
void push(Stack *s, int value)
{
    if(isFull(s))
    {
        printf("栈已满，无法入栈！");
        return;
    }

    s->top++;
    s->data[s->top] = value;
}

// 出栈
int pop(Stack *s)
{
    if(isEmpty(s))
    {
        printf("栈已空，无法出栈！");
        return -1;
    }

    int value = s->data[s->top];
    s->top--;

    return value;
}

// 获取栈顶元素
int getTop(Stack *s)
{
    if(isEmpty(s))
    {
        printf("栈已空，无法获取栈顶元素！");
        return -1;
    }

    return s->data[s->top];
}

// 判断是否为运算符
int isOperator(char c)
{
    if(c == '+' || c == '-' || c == '*' || c == '/')
    {
        return 1;
    }

    return 0;
}

// 判断运算符优先级
int priority(char c)
{
    if(c == '+' || c == '-')
    {
        return 1;
    }
    else if(c == '*' || c == '/')
    {
        return 2;
    }

    return 0;
}

// 计算表达式的值
int calculate(char expression[])
{
    Stack numStack; // 存储数字的栈
    Stack opStack; // 存储运算符的栈
    initStack(&numStack);
    initStack(&opStack);

    int num = 0;
    int len = strlen(expression);

    for(int i = 0; i < len; i++)
    {
        char c = expression[i];

        if(isdigit(c))
        {
            num = num * 10 + (c - '0');

            // 如果下一个字符不是数字，则将数字推入栈中
            if(i == len - 1 || !isdigit(expression[i + 1]))
            {
                push(&numStack, num);
                num = 0;
            }
        }
        else if(isOperator(c))
        {
            // 如果运算符栈为空，或者栈顶运算符为左括号，则将运算符推入栈中
            if(isEmpty(&opStack) || getTop(&opStack) == '(')
            {
                push(&opStack, c);
            }
            else
            {
                // 如果当前运算符优先级高于或等于栈顶运算符优先级，则将运算符推入栈中
                if(priority(c) >= priority(getTop(&opStack)))
                {
                    push(&opStack, c);
                }
                // 否则，将运算符栈中的运算符弹出，直到当前运算符优先级高于栈顶运算符优先级或者栈为空
                else
                {
                    while(!isEmpty(&opStack) && priority(c) < priority(getTop(&opStack)))
                    {
                        int num2 = pop(&numStack);
                        int num1 = pop(&numStack);
                        char op = pop(&opStack);
                        int result;

                        if(op == '+')
                        {
                            result = num1 + num2;
                        }
                        else if(op == '-')
                        {
                            result = num1 - num2;
                        }
                        else if(op == '*')
                        {
                            result = num1 * num2;
                        }
                        else if(op == '/')
                        {
                            result = num1 / num2;
                        }

                        push(&numStack, result);
                    }

                    push(&opStack, c);
                }
            }
        }
        else if(c == '(')
        {
            push(&opStack, c);
        }
        else if(c == ')')
        {
            // 将运算符栈中的运算符弹出，直到遇到左括号为止
            while(getTop(&opStack) != '(')
            {
                int num2 = pop(&numStack);
                int num1 = pop(&numStack);
                char op = pop(&opStack);
                int result;

                if(op == '+')
                {
                    result = num1 + num2;
                }
                else if(op == '-')
                {
                    result = num1 - num2;
                }
                else if(op == '*')
                {
                    result = num1 * num2;
                }
                else if(op == '/')
                {
                    result = num1 / num2;
                }

                push(&numStack, result);
            }

            pop(&opStack);
        }
    }

    // 将运算符栈中的运算符全部弹出
    while(!isEmpty(&opStack))
    {
        int num2 = pop(&numStack);
        int num1 = pop(&numStack);
        char op = pop(&opStack);
        int result;

        if(op == '+')
        {
            result = num1 + num2;
        }
        else if(op == '-')
        {
            result = num1 - num2;
        }
        else if(op == '*')
        {
            result = num1 * num2;
        }
        else if(op == '/')
        {
            result = num1 / num2;
        }

        push(&numStack, result);
    }

    return getTop(&numStack);
}

int main()
{
    char expression[100];

    printf("请输入一个表达式: ");
    scanf("%s", expression);

    int result = calculate(expression);

    printf("计算结果为: %d", result);

    return 0;
}

以上就是用 C 语言实现计算器的全部代码。希望能帮到你！