栈的表达式求解 只需把printf_s(vs推荐)改成printf就可以再其他上面运行

最新推荐文章于 2023-01-12 10:22:02 发布
最新推荐文章于 2023-01-12 10:22:02 发布
阅读量186 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44065088/article/details/102585382
版权 
#include <iostream>
#include <Windows.h>
#include <string>
#include <sstream>


/***************内存检测区*********************/
#define _CRTDBG_MAP_ALLOC    //*    这个是  相当于一种开关  打开这个内存检测的开关

#include <cstdlib>   //*
#include <crtdbg.h>  //*

#ifdef  _DEBUG         //*
#ifndef DBG_NEW           //*
#define DBG_NEW new (_NORMAL_BLOCK, __FILE__, __LINE__)//*
#define new DBG_NEW        //*
#endif               //*
#endif 

/***************宏定义和类型转换区*****************/
#define MAX_SIZE 128
#define STACK_S typedef

#define ELEM_TYPE int

using namespace std;

/***************结构体区*********************/
STACK_S struct stack_s {

    ELEM_TYPE* base;  // 栈底标记
    ELEM_TYPE* top;      // 栈顶元素

}stack;

static int DeBug = 1;

/***************函数定义区*********************/
bool isEmpty(stack& st);
bool isFull(stack& st);

// 1.初始化栈
bool initStack(stack& st);
// 2.入栈    e是要入栈的元素
bool pushStack(stack& st, ELEM_TYPE e);
// 3.出栈   e是要出栈的元素
bool popStack(stack& st, ELEM_TYPE& e);
// 4.销毁栈
void destroyStack(stack& st);
// 5.栈的遍历
void printStack(stack& st);
// 6.栈的长度
int stackLen(stack& st);
// 7.得到栈顶的指针
ELEM_TYPE* getTop(stack& st);

/***************有关运算式子的函数声明区*******************/

// 判断是否为 运算符
bool isOpt(int a, char *optstr, int lenth);

// 运算符优先级的比较  左大于右 就返回 >   等于的话 就放回 =   否则返回 <
char priority(char lopt, char ropt);

// 计算函数
void oper(ELEM_TYPE outvalue_1, char outopt, ELEM_TYPE outvalue_2, ELEM_TYPE& result);


/***************用户接口区*********************/
int main(void) {

    const char* str = "  16*16*(1+1)+8 =";
    char optstr[] = { '+', '-', '*', '/', '(', ')', '#', '='};

    stack opt;    // 这个是符号栈
    stack value;  // 这个式值栈

    initStack(opt);
    initStack(value);

    pushStack(opt, (int)('#'));        //做一个开始的标记  与第一个进来的相互比较
    ELEM_TYPE result = 0;    //结果   //以为value 内部也是  char 类型
    char buf[128];
    int len = 0;
    char* start = nullptr;
    char* end = nullptr;
    char intbuf[16];

    cout << "***********************************************" << endl; //
    while ((char)(*getTop(opt)) != '#' || str[len] != '=') {

        if (isspace(str[len])) {
            if (DeBug)printf_s("第 %d 个为空！\n", len + 1);
            len++;
            continue;
        }
        ELEM_TYPE ret = (ELEM_TYPE)str[len];    //保存当前读取的  字符
        ELEM_TYPE outvalue_1, outvalue_2;    //用来保存出栈的值
        ELEM_TYPE outopt;
        
        if (!isOpt(ret, optstr, sizeof(optstr) / sizeof(optstr[0]))) {    //不是运算符的话就是  数值

            {// 这个模块是把  连续的 数字字符 转换成 int
                start = (char*)str + len;
                end = start + 1;
                while (!isOpt(int(*end), optstr, sizeof(optstr) / sizeof(optstr[0]))) {
                    end++;
                }
                snprintf(intbuf, sizeof(intbuf), start, end - start);
                ret = atoi(intbuf);
            }
            
            if (DeBug)printf_s("第 %d 个为数字: %d！\n", len + 1, ret);                                                        //入栈之后就继续扫描
            pushStack(value, ret);
            len += end-start;
            continue;
        }else {
            if (DeBug)printf_s("第 %d 个为运算符，正在进行操作 %c ！\n", len + 1, (char)ret);

            switch (priority((char)(*getTop(opt)), (char)ret))
            {
            case '<':
                pushStack(opt, ret);
                if (DeBug)printf_s("第 %d 个为运算符，入栈 %c ！\n", len + 1, ret);
                len++;
                break;
            case '>':
                popStack(opt, outopt);
                popStack(value, outvalue_1);
                popStack(value, outvalue_2);
                oper(outvalue_2, (char)outopt, outvalue_1, result);  //开始运算
                pushStack(value, result);
                if (DeBug)printf_s("**********结果 %d 入栈   %c 出栈！\n", result, outopt);
                break;
            case '=':
                popStack(opt, outopt);
                if (DeBug)printf_s(" ‘=’的情况下 %c 出栈！\n", outopt);
                len++;
                break;
            }
        }
    }

    const char* laopo = "珂珂宝贝1314";
    cout << "开始输出结果！" << endl;
    sprintf_s(buf, "%s %d ", str, *getTop(value));
    cout << buf << endl;

    Sleep(4000);
    cout << "等等， 答案好像不对 ！" << endl;
    Sleep(4000);
    sprintf_s(buf, "%s %d%s ", str, *getTop(value), laopo);

    cout << "应该是  ：";
    cout << buf << endl;
    

    destroyStack(opt);
    destroyStack(value);
    
    system("pause");
    _CrtDumpMemoryLeaks();
    return 0;
}

/***************函数定义区*********************/
bool initStack(stack& st) {
    st.base = new ELEM_TYPE[MAX_SIZE];
    if (!st.base) {
        return false;
    }
    st.top = st.base;
    return true;
}

bool pushStack(stack& st, ELEM_TYPE e) {
    if ((st.top - st.base) == MAX_SIZE) {//栈已经满了
        return false;
    }
    *(st.top++) = e;
    return true;
}

bool popStack(stack& st, ELEM_TYPE& e) {
    if (st.base == st.top) {//栈为空
        return false;
    }
    e = *(--st.top);
    return true;
}

void destroyStack(stack& st) {

    st.top = nullptr;

    if (st.base) delete[] st.base;

    return;
}

inline bool isEmpty(stack& st) {
    if (st.base == st.top) {
        return true;
    }
    else {
        return false;
    }
}

inline bool isFull(stack& st) {

    if (st.top - st.base == MAX_SIZE) {
        return true;
    }
    else {
        return false;
    }
}

void printStack(stack& st) {
    auto tmp = st.base;
    int i = 1;
    while (tmp != st.top) {
        printf_s(" %c       \n", *tmp);
        tmp++;
    }
    return;
}

inline int stackLen(stack& st) {
    auto len = st.top - st.base;
    return len;
}

inline ELEM_TYPE* getTop(stack& st) {
    if (!isEmpty(st)) {
        return st.top - 1;
    }
    else
        return nullptr;
}

bool isOpt(int a, char* optstr, int lenth) {

    for (int i = 0; i < lenth; i++) {
        if ((char)a == optstr[i])
            return true;
    }
    return false;
}

char priority(char lopt, char ropt) {
    switch (lopt) 
    {
    case '+':
        switch (ropt)
        {
        case '=':
        case '+':
        case '-':
        case ')':
        case '#':
            return '>';
        default:
            return '<';
        }
        
    case '-':
        switch (ropt) 
        {
        case '=':
        case '+':
        case '-':
        case ')':
        case '#':
            return '>';
        default:
            return '<';
        }
        
    case '*':
        switch (ropt) 
        {
        case '(':
            return '<';
        default:
            return '>';
        }
        
    case '/':
        switch (ropt) 
        {
        case '(':
            return '<';
        default:
            return '>';
        }
        
    case '(':
        switch (ropt) 
        {
        case ')':
            return '=';
        default:
            return '<';
        }

    case '#':
        switch (ropt)
        {
        case '#':
        case '=':
            return '=';
        default:
            return '<';
        }
    }
    return '\0';
}

void oper(ELEM_TYPE outvalue_1, char outopt, ELEM_TYPE outvalue_2, ELEM_TYPE& result) {

    int result_1 = 0;

    int value_1 = outvalue_1;
    int value_2 = outvalue_2;
    
    switch (outopt) {
    case '+':
        result_1 = value_1 + value_2;
        break;
    case '-':
        result_1 = value_1 - value_2;
        break;
    case '*':
        result_1 = value_1 * value_2;
        break;
    case '/':
        result_1 = value_1 / value_2;
        break;
    default:
        break;
    }
    result = result_1 ;
    return;
    
}

 

阿翔同学
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++——scanf_s与printf_s
Wannna的博客
01-12 3680
1.scanf是C语言的输入变量的方法，C++有类似的方法进行输入，采用sacnf_s的方法。 下面是一个输入样式： (代码中的%X表示格式化的类型，将在下文中讲到) int a, b; scanf_s("%d%d", &a, &b); 其实scanf_s还有一个int型的返回值，得到正常输入的变量个数，常用来判断输入是否是格式化的类型。看下面的例子 int a, b; int ...
C语言利用栈实现对后缀表达式的求解
08-19
C语言利用栈实现对后缀表达式的求解 本文主要介绍了C语言利用栈实现对后缀表达式的求解。后缀表达式，又称逆波兰表达式，是一种特殊的表达式形式。在计算机科学中，后缀表达式是一种常用的表达式形式，它可以方便...
关于vs2013中printf printf_s的错误问题的解决方法
dingding0403的专栏
05-19 7998
一、错误 1 error C4996: 'scanf': This function or variable may be unsafe. Consider using scanf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details. d:\documents\
printf_s在debug模式下打印未初化变量
ddzw5533的博客
03-20 165
今天在调试内核输出的时候发现的 printf_s在打印已经初始化的变量的时候正常输出，但是在打印未初始化的时候出现未料到的数据。 原码是这样的 char buf[15]; DWORD bfread; ReadFile(device, buf, 10, &bfread, NULL); for (int i = 0; i < 10; i+...
printf()格式化输出详解
weixin_33943836的博客
04-05 711
printf的格式控制的完整格式： % - 0 m.n l或h 格式字符 下面对组成格式说明的各项加以说明： ①%：表示格式说明的起始符号，不可缺少。 ②-：有-表示左对齐输出，如省略表示右对齐输出。 ③0：有0表示指定空位填0,如省略表示指定空位不填。 ④m.n：m指域宽，即对应的输出项在输出设备上所占的字符数。N指精度。用于说明输出的实型数的小数位数。对数值型的来说，未指定n时，隐含的精度为n...
关于printf_s与printf问题的解决方法
m0_74312445的博客
01-12 1765
1.引入: 在初学C语言时，我们用旧的版本的VS如VS2010，经常用到printf与scanf这两个函数，在使用新的版本VS(如VS2019 2022等)，发现这两个函数需要加_s才可以到到预期结果。 2.分析: 看报错栏，看第一个错误，我们来浅浅的翻译一下 'scanf': This function or variable may be unsafe. Consider using scanf_s instead. 翻译: “scanf”：此函数或变量可能不安全。考虑改用sca
《数据结构中》利用栈来求解表达式，
11-01
利用栈求解表达式的值 #include #include #include typedef struct Fnode/*符号单链表*/ { int yxj; char fh; struct Fnode *next; }Fnode; 。。。。。。。。。。。。。。。。。。。。。 main() { Fnode *fh; ...
栈求表达式的值（C语言实现）
最新发布
12-28
本主题将深入讲解如何使用 C 语言通过栈来求解表达式的值。 在 C 语言中，我们可以自定义数据结构来模拟栈的行为，或者利用标准库中的数据结构如`<stdio.h>`，`<stdlib.h>`和`<stdbool.h>`来实现。对于求表达式值的...
数据结构中 用栈实现迷宫求解
04-14
### 数据结构中用栈实现迷宫求解 #### 背景与意义 在计算机科学领域，迷宫求解是一个经典的问题，它不仅涉及到数据结构的应用，还涉及到算法的设计与优化。通过解决这类问题，我们可以更好地理解算法的工作原理...
jsq.rar_C语言 计算器_C语言计算器_c计算器源代码_计算器 C语言_计算器C语言
09-24
栈遵循后进先出（LIFO）的原则，对于解析和求解数学表达式十分有用。 7. **错误处理**：良好的计算器程序会考虑用户可能输入的无效数据，如除数为零或非数字输入。因此，程序应包含错误检测和处理机制，以防止程序...
printf_s与printf的异同
热门推荐
xupeng1644的博客
09-25 1万+
MSDN的解释为： The main difference between printf_s and printf is that printf_s checks the format string for valid formatting characters, whereas printf only checks if the format string is a null pointer....
C语言中如何不用_s,c语言中printf _s的用法 怎么才能正确使用，
weixin_39894233的博客
05-18 866
一 printf()函数是格式化输出函数, 一般用于向标准输出设备按规定格式输出信息。在编写程序时经常会用到此函数。printf()函数的调用格式为:printf("", );其中格式化字符串包括两部分内容: 一部分是正常字符, 这些字符将按原样输出; 另一部分是格式化规定字符, 以"%"开始, 后跟一个或几个规定字符,用来确定输出内容格式。参量表是需要输出的一系列参数, 其个数必须与格式化字符...
解决在VS2013中使用scanf和printf的报错
haroroda的博客
02-07 1万+
在源文件（.c或.cpp)或工程属性中定义符号_CRT_SECURE_NO_WARNINGS就行。就是在源文件的开头加上一句#define_CRT_SECURE_NO_WARNINGS   在工程中定义更省心，方法如下： 　　1、在解决方案管理器的工程上右键，点属性 2、在弹出的属性页中，点击左边的“C/C++”，之后再点“预处理器” 3、点“预处理器定义”右边
C语言VS环境下，scanf()和scanf_s()
u013354678的博客
09-28 4342
c语言，VS2013环境，scanf()安全性问题，_CRT_SECURE_NO_WARNINGS，scanf_s()函数， error C4996:‘scanf’:This function or variable may be unsafe. Consider using scanf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNING.See online help for details.
printf "%.*s"
GKoSon的博客
04-11 4858
第一种：没有点 不过 printf("%*s", len, str) 是有这种写法的， 这时 printf 额外接受一个参数作为域宽。 如果 str 的长度小于 len ，会用空格使长度补足。 printf("%*s", 30, id) ; 第2种：有点 https://www.cnblogs.com/yuaqua/archive/2011/10/21/2219856.html ...
printf,sprintf,sprintf_s,_snprintf_s,vsprintf,vsnprintf,_vsnprintf_s,_vscprintf等格式化字符串使用与区别
xianzongtanxun的专栏
08-15 8354
最近在为新做的项目找个好用的第三方日志库，感觉log4cpp挺好用的，日志输出使用了格式化字符串，不同的函数功能不同，而且变异版本比较多，自己都有点搞昏了，网上搜索也比较笼统，下面是自己coding测试格式化字符串的过程（vs2015,win10  x64环境），供参考 有C语言写作历史的程序员往往特别喜欢printf 函数。即使可以使用更简单的命令（例如puts），但printf 出现在Ker...
用c语言栈库函数实现表达式求解
04-22
我理解你的问题了。实现表达式求解需要用到一个栈来存储运算符和操作数，并按照一定的优先级进行计算。以下是一个示例程序，其中用到了几个重要的栈库函数（如stack_push、stack_pop等）： ``` #include <stdio.h> #include <stdlib.h> #include <string.h> #include <ctype.h> typedef struct { int capacity; int top; int* data; } Stack; Stack* stack_new(int capacity) { Stack* s = (Stack*)malloc(sizeof(Stack)); s->capacity = capacity; s->top = -1; s->data = (int*)malloc(capacity * sizeof(int)); return s; } void stack_push(Stack* s, int value) { if (s->top == s->capacity - 1) { fprintf(stderr, "Error: stack is full.\n"); exit(1); } s->top++; s->data[s->top] = value; } int stack_pop(Stack* s) { if (s->top == -1) { fprintf(stderr, "Error: stack is empty.\n"); exit(1); } int value = s->data[s->top]; s->top--; return value; } int stack_top(Stack* s) { if (s->top == -1) { fprintf(stderr, "Error: stack is empty.\n"); exit(1); } return s->data[s->top]; } int is_operator(char ch) { return ch == '+' || ch == '-' || ch == '*' || ch == '/'; } int operator_precedence(char op) { switch (op) { case '+': case '-': return 1; case '*': case '/': return 2; default: fprintf(stderr, "Error: unsupported operator '%c'.\n", op); exit(1); } } int evaluate_expression(char* expression) { Stack* operands = stack_new(strlen(expression)); Stack* operators = stack_new(strlen(expression)); int i = 0; while (expression[i]) { if (isdigit(expression[i])) { int value = expression[i] - '0'; i++; while (isdigit(expression[i])) { value = value * 10 + (expression[i] - '0'); i++; } stack_push(operands, value); } else if (is_operator(expression[i])) { while (!stack_top(operators)) { char op = stack_top(operators); if (operator_precedence(op) >= operator_precedence(expression[i])) { int b = stack_pop(operands); int a = stack_pop(operands); switch (op) { case '+': stack_push(operands, a + b); break; case '-': stack_push(operands, a - b); break; case '*': stack_push(operands, a * b); break; case '/': stack_push(operands, a / b); break; default: fprintf(stderr, "Error: unsupported operator '%c'.\n", op); exit(1); } stack_pop(operators); } else { break; } } stack_push(operators, expression[i]); i++; } else if (isspace(expression[i])) { i++; } else { fprintf(stderr, "Error: invalid character '%c'.\n", expression[i]); exit(1); } } while (!stack_top(operators)) { char op = stack_top(operators); int b = stack_pop(operands); int a = stack_pop(operands); switch (op) { case '+': stack_push(operands, a + b); break; case '-': stack_push(operands, a - b); break; case '*': stack_push(operands, a * b); break; case '/': stack_push(operands, a / b); break; default: fprintf(stderr, "Error: unsupported operator '%c'.\n", op); exit(1); } stack_pop(operators); } int result = stack_pop(operands); free(operands->data); free(operands); free(operators->data); free(operators); return result; } int main() { char* expression = "3 * ( 4 + 5 ) - 6 / 2"; int result = evaluate_expression(expression); printf("%s = %d\n", expression, result); return 0; } ``` 这个程序能够处理带括号的表达式，并按照正确的优先级进行计算。你可以尝试将其复制到本地环境中运行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值