如何使用char数组索引的排列作为运算符?

时间:2014-11-04 09:32:16

标签: c++ c arrays operators

请查看我的c ++程序。

#include<stdio.h>
int main()
{
char sign[]={'+','-','/','*'};

int i,j,k,l=0;
for(i=0;i<=3;i++)
{
    for(j=0;j<=3;j++)
    {
        for(k=0;k<=3;k++)
        {
            if(sign[j]!=sign[i]&&sign[k]!=sign[i]&&sign[k]!=sign[j])
            {

            printf("%c %c %c\n",sign[i],sign[j],sign[k],l);

            }

        }
    }
}

return 0;
}

这个程序的输出是这样的..

+ - /
+ - *
+ / -
+ / *
....

我想在数字之间使用它们......  喜欢这个..

#include<stdio.h>
int main()
{
char sign[]={'+','-','/','*'};

int i,j,k,l=0;
for(i=0;i<=3;i++)
{
    for(j=0;j<=3;j++)
    {
        for(k=0;k<=3;k++)
        {
            if(sign[j]!=sign[i]&&sign[k]!=sign[i]&&sign[k]!=sign[j])
            {
                int l;
                l=18sign[i]12sign[j]4sign[k]5;
                printf("18%c12%c4%c5=%d",sign[i],sign[j],sign[k],l);

            }

        }
    }
}

return 0;
}

我想要像这样的输出..

18+12-4/5=29
18+12-4*5=10
18+12/4-5=16
18+12/4*5=33
.....

那么这个代码是什么? [我不能使用开关标签,因为我必须申报24个案例。有没有办法将索引用作运算符??]

4 个答案:

答案 0 :(得分:2)

没有

C(和C ++)是静态编译语言。您无法在运行时做出需要不同代码的决策,因为编译器不再需要生成该代码。

在C ++中,您可以执行各种模板技巧,使编译器在编译时为各种情况生成代码,但在此处不太清楚它是如何应用的。

答案 1 :(得分:0)

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

typedef struct exp {
    char op;
    char *term;
    struct exp *left;
    struct exp *right;
} Exp;

Exp *make_exp2(char *str){
    if(!str || !*str) return NULL;//*str == '\0' is format error.
    char *mul = strrchr(str, '*');
    char *div = strrchr(str, '/');
    Exp *node = malloc(sizeof(*node));
    if(mul == NULL && div == NULL){
        node->op = '\0';
        node->term = str;
        node->left = node->right = NULL;
        return node;
    }
    char *op;
    op = mul < div ? div : mul;
    node->op = *op;
    *op = '\0';
    node->left  = make_exp2(str );
    node->right = make_exp2(op+1);
    return node;
}

Exp *make_exp(char *str){
    if(!str || !*str) return NULL;//*str == '\0' is format error.
    char *minus = strrchr(str, '-');
    char *plus  = strrchr(str, '+');
    if(minus == NULL && plus == NULL)
        return make_exp2(str);
    char *op;
    Exp *node = malloc(sizeof(*node));
    op = minus < plus ? plus : minus;
    node->op = *op;
    *op = '\0';
    node->left  = make_exp(str );
    node->right = make_exp(op+1);
    return node;
}

int multiplication(int a, int b){
    return a * b;
}
int division(int a, int b){
    return a / b;
}
int addition(int a, int b){
    return a + b;
}
int subtraction(int a, int b){
    return a - b;
}

int calc(Exp *exp){
    switch(exp->op){
    case '*' :
        return multiplication(calc(exp->left), calc(exp->right));
    case '/' :
        return division(calc(exp->left), calc(exp->right));
    case '+' :
        return addition(calc(exp->left), calc(exp->right));
    case '-' :
        return subtraction(calc(exp->left), calc(exp->right));
    default :
        return atoi(exp->term);
    }
}

void drop_exp(Exp *exp){
    if(exp){
        drop_exp(exp->left);
        drop_exp(exp->right);
        free(exp);
    }
}

int main(void) {
    char expstr[128];
    sprintf(expstr, "18%c12%c4%c5", '+', '-', '/');//18+12-4/5
    Exp *exp = make_exp(expstr);
    printf("%d\n", calc(exp));//30
    drop_exp(exp);
    return 0;
}

答案 2 :(得分:0)

您必须使用表达式解析器才能处理正确的运算符优先级。请查看Infix Calculator Expression Parser以获取可能的解决方案。

答案 3 :(得分:0)

以下可能会有所帮助:

int main()
{
    int numbers[] = {18, 12, 4, 5};
    char signs[] = {'+', '-', '/', '*'};
    std::map<char, std::function<int(int, int)>> m = {
        {'+', [](int a, int b){ return a + b; }},
        {'-', [](int a, int b){ return a - b; }},
        {'/', [](int a, int b){ return a / b; }},
        {'*', [](int a, int b){ return a * b; }},
    };

    std::sort(std::begin(signs), std::end(signs));

    do {
        int res = m[signs[2]](m[signs[1]](m[signs[0]](numbers[0], numbers[1]), numbers[2]), numbers[3]);

        std::cout << numbers[0] << signs[0] << numbers[1] << signs[1]
            << numbers[2] << signs[2] << numbers[3] << " = " << res << std::endl;

    } while (std::next_permutation(std::begin(signs), std::end(signs)));
    return 0;
}

Live demo