10calc

最新推荐文章于 2021-08-04 03:07:35 发布
最新推荐文章于 2021-08-04 03:07:35 发布
阅读量615 收藏
点赞数
分类专栏： 数据结构与算法
本文详细阐述了一个解析并计算复杂数学表达式的算法，包括符号运算、优先级处理和错误检查。通过使用栈数据结构来管理和计算操作符和数字，实现了对不同运算符的正确处理，并对括号进行有效解析，确保了表达式的准确计算。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >


calc/calc.h

#include "stack.h"

enum pre_flag {
    OPR,
    NUM,
};

typedef ssize_t num_t;

struct calc_info {
    const char *expr;
    char *cur;
    struct stack_info opr;
    struct stack_info num;
    enum pre_flag flag;
    num_t (*output)(struct calc_info *, const char *); 
};

void calc_init(struct calc_info *); 
void calc_destroy(struct calc_info *);


calc/calc.c

#include <stdio.h>
#include <assert.h>
#include "calc.h"

#define DEBUG

#ifdef DEBUG
#define DEBUG_PRT(fmt, arg...) printf(fmt, arg)
#else
#define DEBUG_PRT(fmt, arg...)
#endif


#define PUSH_NUM(n) do {info->num.push(&info->num, &n, sizeof(num_t));} while (0)
#define POP_NUM(n) ({info->num.pop(&info->num, &n, sizeof(num_t));})
#define TOP_NUM(n) ({info->num.top(&info->num, &n, sizeof(num_t));})
#define ISEMPTY_NUM ({info->num.isempty(&info->num);})

#define PUSH_OPR(n) do {info->opr.push(&info->opr, &n, sizeof(char));} while (0)
#define POP_OPR(n) ({info->opr.pop(&info->opr, &n, sizeof(char));})
#define TOP_OPR(n) ({info->opr.top(&info->opr, &n, sizeof(char));})
#define ISEMPTY_OPR ({info->opr.isempty(&info->opr);})
static void num_handler(struct calc_info *info)
{
    num_t num = *info->cur - '0';
    num_t pre_num = 0;

    if (info->flag == NUM) {
        assert(!ISEMPTY_NUM);
        POP_NUM(pre_num);
        num += pre_num * 10;
    }
    PUSH_NUM(num);

    info->flag = NUM;
}
static int do_stack(struct calc_info *info)
{
    num_t a = 0;
    num_t b = 0;
    char opr = 0;
    num_t ret = 0;

    assert(!(ISEMPTY_NUM));
    POP_NUM(b);
    assert(!(ISEMPTY_NUM));
    POP_NUM(a);
    assert(!(ISEMPTY_OPR));
    POP_OPR(opr);

    switch (opr) {
        case '+':
            ret = a + b;
            break;
        case '-':
            ret = a - b;
            break;
        case '*':
            ret = a * b;
            break;
        case '/':
            ret = a / b;
            break;
        case '(':
            fprintf(stderr, "?..?..宸?.??n");
            return -1;
        default:
            DEBUG_PRT("%d: %s - wrong elem in stack\n", __LINE__, __FUNCTION__);


 

            assert(0);
    };

    DEBUG_PRT("%ld %c %ld = %ld\n", a, opr, b, ret);

    PUSH_NUM(ret);
    return 0;
}


 

static int opr_level(char opr)
{
    int level = 0;

    switch (opr) {
        case '(':
            break;
        case '+':
        case '-':
            level += 1;
            break;
        case '*':
        case '/':
            level += 2;
            break;
        default:
            DEBUG_PRT("%d: %s - wrong opr in level check\n", __LINE__, __FUNCTION__);
            assert(0);
    };

    return level;
}

static inline int cmp_opr(char opr_a, char opr_b)
{
    return opr_level(opr_a) - opr_level(opr_b);
}


 

static int opr_handler(struct calc_info *info)
{
    char opr = 0;

    if (info->flag == OPR ) {//褰..cur?..璐..
        if (*info->cur != '-') {
            fprintf(stderr, "?..?.?缁.?绠..\n");
            return -1;
        } else {
            //寰€num?.腑?.?涓.锛.舰?.€.-?..琛ㄨ揪寮.??ユ.浠ｈ??
            num_t zero = 0;
            PUSH_NUM(zero);
        }
    } else {//褰..cur?..杩..琛ㄨ揪寮
        while (!(ISEMPTY_OPR || (TOP_OPR(opr), cmp_opr(*info->cur, opr) > 0))) {
            if (do_stack(info) < 0) {
                return -1;
            }
        }
    }

    PUSH_OPR(*info->cur);
    info->flag = OPR;

    return 0;
}


 

static int bracket_handler(struct calc_info *info)
{
    char opr = 0;

    switch (*info->cur) {
        case '(':
            PUSH_OPR(*info->cur);
            info->flag = OPR;
            break;
        case ')':
            assert(!ISEMPTY_OPR);
            while (!(TOP_OPR(opr) < 0) && (opr != '(')) {
                if (do_stack(info) < 0) {
                    return -1;
                }
            }
            if (opr == '(') {
                POP_OPR(opr);
            } else { //宸?.?风己?.??..?..?..
                fprintf(stderr, "?..?..?虫.??n");
                return -1;
            }
            break;
        default:
            DEBUG_PRT("%d: %s - wrong opr in bracket_handler\n", __LINE__, __FUNCTION__);
            assert(0);
    };

    return 0;
}


 

static num_t calc(struct calc_info *info, const char *expr)
{
    //init
    info->expr = expr;
    info->cur = (char*)info->expr;
    stack_init(&info->opr);
    stack_init(&info->num);
    info->flag = OPR;

    for (; *info->cur; ++(info->cur)) {
        switch (*info->cur) {
            case '0'...'9':
                num_handler(info);
                break;
            case '+':
            case '-':
            case '*':
            case '/':
                if (opr_handler(info) < 0) {
                    goto error;
                }
                break;
            case '(':
            case ')':
                if (bracket_handler(info) < 0) {
                    goto error;
                }
                break;
            default:
                break;
        };
    }


    while (!(ISEMPTY_OPR)) {
        if (do_stack(info) < 0) {
            goto error;
        }
    }

    num_t ret = 0;
    POP_NUM(ret);

    DEBUG_PRT("%s = %ld\n", info->expr, ret);

    stack_destroy(&info->num);
    stack_destroy(&info->opr);

    return ret;

error:
    stack_destroy(&info->num);
    stack_destroy(&info->opr);
    return -1;
}

void calc_init(struct calc_info *info)
{
    info->output = calc;
}

void calc_destroy(struct calc_info *info)
{

}


calc/list.h

struct node_info {
    struct node_info *prev;
    struct node_info *next;
    char priv[];
};

struct list_info {
    struct node_info *head;
    void (*add)(struct list_info *,
            const void *data_entry,
            size_t data_size);
    void (*add_tail)(struct list_info *,
            const void *data_entry,
            size_t data_size);
    void (*del)(struct list_info *,
            struct node_info *,
            size_t data_size);
};

#define list_for_each(cur, head) \
    for (cur = (head)->next; \
        (cur) != (head); \
        cur = (cur)->next)

#define list_for_each_safe(cur, tmp, head) \
    for (cur = (head)->next, tmp = (cur)->next; \
        (cur) != (head); \
        cur = tmp, tmp = (tmp)->next)

#define ENTRY(node, type) ((type*)(node->priv))

void list_init(struct list_info*);
void list_destroy(struct list_info*);


calc/list.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "list.h"


static void __list_add(struct node_info *prev,
        struct node_info *next,
        const void *data_entry,
        size_t data_size)
{
    struct node_info *node = (struct node_info *)malloc(sizeof(struct node_info) + data_size);
    memcpy(node->priv, data_entry, data_size);

    node->prev = prev;
    node->next = next;
    prev->next = node;
    next->prev = node;
}

static void list_add(struct list_info *info,
        const void *data_entry, size_t data_size)
{
    __list_add(info->head, info->head->next,
            data_entry, data_size);
}

static void list_add_tail(struct list_info *info,
        const void *data_entry, size_t data_size)
{
    __list_add(info->head->prev, info->head,
            data_entry, data_size);
}


 

static void list_del(struct list_info *info,
        struct node_info *node,
        size_t data_size)
{
    node->prev->next = node->next;
    node->next->prev = node->prev;
    node->prev = node;
    node->next = node;

    if (data_size) {
        memset(node->priv, 0, data_size);
    }
    free(node);
}

void list_init(struct list_info *info)
{
    info->head = (struct node_info *)malloc(sizeof(struct node_info));
    info->head->prev = info->head;
    info->head->next = info->head;

    info->add = list_add;
    info->add_tail = list_add_tail;
    info->del = list_del;
}

void list_destroy(struct list_info *info)
{
    struct node_info *cur = info->head->next;

    for (; cur != info->head; cur = info->head->next) {
        list_del(info, cur, 0);
    }

    free(info->head);
}


calc/Makefile

TGT := calc
SRCS := list.c stack.c calc.c test.c

CFLAGS :=

$(TGT): $(SRCS)
    $(CC) $(CFLAGS) -o $@ $^

clean:
    $(RM) $(TGT)
~


calc/stack.h

#include "list.h"

struct stack_info {
    struct list_info list;
    void (*push)(struct stack_info *,
            const void *data_entry,
            size_t data_size);
    int (*pop)(struct stack_info *,
            void *data_entry,
            size_t data_size);
    int (*top)(struct stack_info *,
            void *data_entry,
            size_t data_size);
    int (*isempty)(struct stack_info *); 
};

void stack_init(struct stack_info *); 
void stack_destroy(struct stack_info *); 
~


calc/stack.c

#include "stack.h"


static void stack_push(struct stack_info *info,
        const void *data_entry,
        size_t data_size)
{
    info->list.add(&info->list, data_entry, data_size);
}

static int stack_isempty(struct stack_info *info)
{
    return info->list.head->next == info->list.head;
}

static int stack_top(struct stack_info *info,
        void *data_entry,
        size_t data_size)
{
    if (stack_isempty(info)) {
        return -1; 
    }   

    if (data_entry) {
        memcpy(data_entry, info->list.head->next->priv, data_size);
    }   
    return 0;
}


 

static int stack_pop(struct stack_info *info,
        void *data_entry,
        size_t data_size)
{
    if (stack_top(info, data_entry, data_size) < 0) {
        return -1; 
    }

    //?..绗.?涓..?..?
    info->list.del(&info->list, info->list.head->next, data_size);
    return 0;
}

void stack_init(struct stack_info *info)
{
    list_init(&info->list);
    info->push = stack_push;
    info->pop = stack_pop;
    info->top = stack_top;
    info->isempty = stack_isempty;
}

void stack_destroy(struct stack_info *info)
{
    list_destroy(&info->list);
}


calc/test.c

#include <stdio.h>
#include "calc.h"

int main(int argc, char **argv)
{
    const char *expr = "(115+(-( -126 - (-2) )))* (84 / (41 + (-1)))";

    const char *banner = "璁＄.???ㄦ?锛..浠?琛ㄨ揪寮.n?

    struct calc_info calc;
    calc_init(&calc);

    if (argc == 1) {
        printf("%ld\n", calc.output(&calc, expr));
    }   
    else if (argc == 2) {
        printf("%ld\n", calc.output(&calc, argv[1]));
    } else {
        fprintf(stderr, "%s\n", banner);
    }   

    calc_destroy(&calc);

    return 0;
}


calc/macro_test.c

#include <stdio.h>

#define DEBUG_PRT(fmt, arg...) printf(fmt, arg)

#define ABC(a, b...) ""#b""
/*#define ABC(a, b...) "b"*/

#define DEF(a, b) a##hello##b

void func(int a, ...)
{

}

int main()
{
    DEBUG_PRT("%s %c %d\n", "abc", 'X', 100);

    func(100, 200, 300, 400);

    printf("%s\n", ABC(aa, bb, cc, dd));

    int DEF(aa, bb) = 1234;

    printf("%d\n", aahellobb);

    return 0;
}


 

win10-calc-计算器工具.zip
03-12
标题“win10-calc-计算器工具.zip”表明这是一个与Windows 10操作系统相关的计算器应用的压缩文件。这个压缩包包含了一个名为"calc.exe"的文件，这通常是Windows 10计算器程序的可执行文件。 在Windows 10中，...
Win10计算器（独立程序）
12-04
兼容性强：能在大多数 Windows 10 系统上无缝运行，确保稳定的计算体验. 保持原生体验：完整保留了 Windows 10 计算器的界面和功能，包括标准计算、科学计算等模式，用户无需适应新的界面和操作方式. 便携式设计：...
Win10 calc.exe 无法打开计算器的解决方法
wangchaoqi1985的博客
12-07 3010
Win10 calc.exe 无法打开计算器的解决方法
不识别calc_解决win10计算器calc.exe程序打不开的方法
weixin_33303595的博客
12-24 6805
在使用Win10系统的过程中，有很多用户有遇到无法打开计算器calc.exe程序的问题，其实这个我们可以通过很多方法来解决，不过当然首先要做的都是要下载一个新的calc.exe应用程序，之后才能继续操作，接下来就和小编一起来看一下具体解决方法吧。希望可以帮助大家。win10系统计算器calc.exe打不开的解决方法：win10系统计算器calc.exe打不开怎么办?下载calc.exe应用程序，直...
calc ie支持,IE 10 + 11：使用calc（）的CSS转换不起作用
weixin_42515177的博客
12-20 190
I am animating a container on mouseover from right to the left with CSS transitions. This works fine in all browsers except Internet Explorer. The reason is that I am using (and need to use) calc() in...
calc
Linjing127218的博客
01-10 368
今天在开发项目的时候，突然发现个问题，calc在谷歌不起作用，原本以为是谷歌的兼容问题，检查下，兼容写了，可还是不起作用，原来 需要注意的是，运算符前后都需要保留一个空格，例如：width: calc(100% - 10px)；calc()能让你给元素的做计算，你可以给一个div元素，使用百分比、em、px和rem单位值计算出其宽度或者高度，比如说“width:calc(50% + 2e
less-calc()
qq_42855675的博客
04-06 523
calc() 只作用于属性值 不能在媒体查询中使用 /* 无效 */ @media (min-width: calc(40rem + 1px)) { /* Wider than 40rem */ } 与预处理器数学比较 .foot { width: calc(10px + 50px); } //组合不同单元; .foot元素总是小于它父元素宽度 50px; //使用 calc()，计算值是表达式它自己，而非表达式的结果 .foot { width: calc(100% - 50px); }
calc ie支持_带有calc（）的CSS过渡在IE10 +中不起作用
weixin_39970855的博客
12-20 339
我正在用CSS过渡在鼠标悬停时从右到左设置一个容器动画。在InternetExplorer以外的所有浏览器中，此功能均正常运行。原因是我在CSSleft属性中使用了(并且需要使用)calc()。CSS看起来像这样：div {background: red;width: 100px;height: 100px;position: absolute;top: 100px;left: 90%;-webk...
css之calc,CSS之calc()
weixin_36109375的博客
08-04 409
calc() 函数支持任意CSS长度单位的混合计算，遵循标准数学运算优先级规则，可以动态计算长度值。注意，calc()函数内部的运算符两侧各加一个空白符，否则会产生解析错误。calc()使用的难点在于百分比，理解了百分比定位，使用calc()就非常便捷。譬如以background-position中使用为例。将背景图片偏移距离底部10px可以采用采用关键字的形式.container {width:...
less中calc 使用
weixin_40551876的博客
10-10 6599
发现在less中 calc(100% -4rem) 等带单位混合运算会被less解析忽略单位，全部按照百分比计算，此例中的计算被less编译成calc(96%)。 解决方案 max-height: calc(~"100vh - 69px"); 结合less使用特点 @postHeight: 46px; @postBorderHeight: 1px; ...
calc()的使用
时清云的博客
06-25 2748
之前对于calc()接触的很少，也很少用，但是真正接触之后发现，这个用处还不小
Calc Easy-开源
05-29
【标题】"Calc Easy-开源"是一个开源软件项目，它提供了一个相当简单的快速计算器的实现。这个项目的重点在于它的开源特性，意味着源代码是公开的，任何人都可以查看、学习、修改或分发这个计算器的代码。开源软件的...
DDR3 PHY Calc v10.xlsx
05-25
"DDR3 PHY Calc v10.xlsx" 是一个专门为DDR3初始化参数计算而设计的工具，对于那些在DSP或FPGA平台上进行DDR3内存系统设计的工程师来说，这是一个非常实用的工具。 DDR3内存系统的设计涉及到多个关键参数的计算，...
Phase10-Calc
03-28
在Swift编程语言中，"Phase10-Calc"可能是一个项目或者库的名称，它可能涉及到游戏、数学计算或逻辑处理等元素。由于没有提供具体的源代码或详细描述，我将根据这个标题和标签，围绕Swift编程语言以及可能的相关主题...
卫星通信技术在智能交通中的应用.doc
05-24
卫星通信技术在智能交通中的应用.doc
商场无线网络专项方案.doc
05-24
商场无线网络专项方案.doc
《国际项目管理专业资质认证(IPMP)》培训之三.pdf
最新发布
05-24
《国际项目管理专业资质认证(IPMP)》培训之三.pdf
商店销售网站的设计与实现.docx
05-24
商店销售网站的设计与实现.docx
PMSM永磁同步电机的三电平SVPWM与双环矢量控制仿真及MATLAB实现 全集
05-24
内容概要：本文详细介绍了PMSM（永磁同步电机）的仿真研究及其两种关键控制方法：三电平SVPWM矢量控制和双环矢量控制。首先阐述了PMSM在现代电机驱动系统中的重要地位及其广泛的应用领域，如电动汽车、机器人和风力发电等。接着讨论了PMSM仿真的重要性，包括电气特性、机械特性和热特性等方面的考量。然后深入探讨了三电平SVPWM矢量控制技术的工作原理及其对电机性能的提升效果，如提高运行效率和减少谐波失真。随后介绍了PMSM双环矢量控制的具体实现方式，即内环电流控制和外环速度控制相结合的方法，强调了这种方法在提高电机动态性能和稳定性方面的优势。最后对比了传统三电平控制方法和双环矢量控制方法的特点，指出了各自的优势和应用场景。 适合人群：从事电机控制系统研究的技术人员、高校相关专业师生、对电机控制感兴趣的工程技术人员。 使用场景及目标：适用于需要深入了解PMSM控制技术和仿真实现的研究项目和技术开发。目标是帮助读者掌握PMSM的仿真建模方法，理解并应用三电平SVPWM和双环矢量控制技术，以优化电机性能。 其他说明：本文不仅提供了理论分析，还通过MATLAB进行了详细的仿真演示，使读者能够直观地看到不同控制方法的效果。这对于实际工程项目的设计和优化具有重要的指导意义。
html中calc
03-11
<think>好的，我现在需要回答用户关于HTML中calc()函数的用法和示例的问题。首先，我要确保自己正确理解calc()函数的作用和适用场景。calc()是CSS中的一个函数，用于动态计算长度、百分比、时间等数值，允许在声明CSS属性值时执行数学运算。用户可能想知道如何在HTML中使用它，但需要注意，calc()实际上属于CSS，而非HTML本身。 接下来，我需要整理calc()的基本语法和使用规则。例如，运算符周围必须留有空格，支持加减乘除，操作数可以使用不同的单位。同时要提到浏览器的兼容性，虽然现代浏览器普遍支持，但旧版本可能需要前缀。 然后，考虑用户可能需要常见的应用场景，比如布局中的响应式设计，如侧边栏固定宽度，主内容区域自适应剩余空间。或者垂直居中元素，通过计算高度和边距。还可以举例说明如何结合不同单位，比如百分比和像素的混合运算。 需要检查是否有常见的错误用法，比如运算符之间没有空格，或者使用了不兼容的单位，例如在乘除中使用不同单位。同时，提醒用户calc()的嵌套使用，虽然可能，但需谨慎处理。 接下来，根据用户提供的引用，我需要查看是否有相关内容可以引用。不过用户提供的引用[1]到[4]似乎与calc()函数无关，涉及的是JavaScript生成器、SQL函数删除、PostgreSQL与Smarty模板插件、以及Python类的构造函数。因此，可能无法直接引用这些内容来支持答案，但需要确保答案的准确性和完整性，可能需依赖其他知识来源。 然后，生成相关问题。用户的问题可能扩展出calc()函数的浏览器兼容性、常见错误、与预处理器（如SASS）中的calc区别、动态计算的实际案例等。 最后，确保回答结构清晰，分点说明基本用法、注意事项、示例，并附上相关问题。同时，按照用户要求，使用中文回答，数学表达式用$...$，独立公式用$$...$$，但在这个问题中可能较少涉及数学公式，除非提到计算表达式，如calc(50% - 20px)，需要用$包裹。</think>关于HTML中calc()函数的用法，实际上这是CSS3提供的计算函数，主要用于在样式表中进行动态数值计算。以下是详细说明： ### 一、基本用法 1. **语法结构** `calc(数学表达式)` 支持四则运算：`+`、`-`、`*`、`/` 示例：`width: calc(100% - 80px);` 2. **单位混合计算** 允许不同单位混合运算，如： $$ \text{calc}(50\% - 20\text{px}) $$ 这在响应式布局中特别有用[^1]。 ### 二、注意事项 1. **运算符空格规则** `+`和`-`运算符两侧必须保留空格，例如： ✅ `calc(100% - 10px)` ❌ `calc(100%-10px)` 2. **除法特殊要求** 除数必须是纯数字： ✅ `calc(100px / 3)` ❌ `calc(100px / 3em)` 3. **兼容性前缀** 部分旧浏览器需添加前缀： ```css width: -webkit-calc(100% - 20px); width: -moz-calc(100% - 20px); width: calc(100% - 20px); ``` ### 三、应用示例 1. **两栏自适应布局** ```css .sidebar { width: 250px; } .main { width: calc(100% - 250px); } ``` 2. **垂直居中定位** ```css .box { position: absolute; top: calc(50% - 15px); left: calc(50% - 100px); } ``` 3. **动态栅格系统** ```css .grid-item { width: calc((100% - 30px)/4); /* 4列布局含间隙 */ margin-right: 10px; } .grid-item:last-child { margin-right: 0; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值