Thread: A beginner question on how to use a variable as an operator

I have a question could a variable act as an operator such as "+" to add two numbers if so how do i write that? so what I would like to do would be answer = (a b c)
where a is some number b is an operator (such as +) and c is another number, Im not sure how to write that so i could get that line to work and help would be really appreciated

basically trying to a calculator without all the cases

Sorry, but that capability does not exist in C++. You might find it in a dynamically-typed language, although I can't think of one that would allow that.

O_o

Can you explain more why you want the "variable as an operator"?

Soma

What Elkvis said. Not possible in C++, you need a workaround with an if-statement, for example.

Code:

if (b == '+') {
    answer = a + b;
} else if (b == '-') {
    answer = a - b;
} else ...

Originally Posted by spaghetticode

...with an if-statement, for example.

That's what the OP was hoping to avoid.

Interestingly enough, there's a library available for GCC (C/C++ compiler) called libgccjit, that allows you to generate executable code programmatically, so you could have your calculator take its input, then generate a function based on that input, then call it, and get the result. Much more complex than using switch or if...else if.

Originally Posted by Elkvis

Sorry, but that capability does not exist in C++. You might find it in a dynamically-typed language, although I can't think of one that would allow that.

You could do it in any language that can interpret its own code as a runtime script (C# could do this, for example, with the Roslyn compiler or CS-Script). Here, your main program would substitute the value of b (i.e. it would create the string "answer = a + c") and then execute that string as code.

That said, I certainly wouldn't use that approach in C#. That would make the solution more complex, not less.

Just for funsies, this is how you do it:

Code:

int main()
{
	int x, y;
	std::cout << "Enter two numbers: ";
	std::cin >> x >> y;

	char Op;
	std::cout << "Enter op (+ or -): ";
	std::cin >> Op;
	
	typedef int(__fastcall OpFnc_t)(int, int);
	uint8_t Code[] = { 0x8b, 0xc1, 0x00, 0xc2, 0xc3 };
	uint8_t OpTable['-' + 1];
	OpTable['+'] = 0x03;
	OpTable['-'] = 0x2B;
	Code[2] = OpTable[Op];
	auto * CodeBuf = VirtualAlloc(nullptr, 4096, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
	memcpy(CodeBuf, Code, sizeof(Code) / sizeof(Code[0]));
	OpFnc_t* OpFnc = (OpFnc_t*)CodeBuf;

	int z = OpFnc(x, y);
	std::cout << z << "\n";
}

Compiles and runs on VS2015. This goes without saying, but... DON'T DO THIS IN YOUR PRODUCTION CODE. This is just for fun.

https://youtu.be/UL3FHtCq97U

Originally Posted by Elysia

Just for funsies, this is how you do it:

Code:

int main()
{
	int x, y;
	std::cout << "Enter two numbers: ";
	std::cin >> x >> y;

	char Op;
	std::cout << "Enter op (+ or -): ";
	std::cin >> Op;
	
	typedef int(__fastcall OpFnc_t)(int, int);
	uint8_t Code[] = { 0x8b, 0xc1, 0x00, 0xc2, 0xc3 };
	uint8_t OpTable['-' + 1];
	OpTable['+'] = 0x03;
	OpTable['-'] = 0x2B;
	Code[2] = OpTable[Op];
	auto * CodeBuf = VirtualAlloc(nullptr, 4096, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
	memcpy(CodeBuf, Code, sizeof(Code) / sizeof(Code[0]));
	OpFnc_t* OpFnc = (OpFnc_t*)CodeBuf;

	int z = OpFnc(x, y);
	std::cout << z << "\n";
}

Compiles and runs on VS2015. This goes without saying, but... DON'T DO THIS IN YOUR PRODUCTION CODE. This is just for fun.

https://youtu.be/UL3FHtCq97U

Wow. That has to be the jankiest way I've ever seen of embedding assembly (or rather, machine) language instructions. I am equal parts impressed and horrified

Originally Posted by DawnOfMe

what I would like to do would be answer = (a b c)
where a is some number b is an operator (such as +) and c is another number

You can use function pointers for this. (a b c) is the same as saying b(a,c), where b is a function that performs arithmetic such as adding two numbers. For example, define these two functions:

Code:

int op_plus(int a, int b)
{
    return a+b;
}

int op_minus(int a, int b)
{
    return a-b;
}

Now the appropriate function can be placed in a function pointer at runtime:

Code:

int main()
{
    int a = 100;
    int c = 200;

    cout << "Enter + or -: ";
    char q;
    cin >> q;

    typedef int (*FT)(int,int);
    FT b = nullptr;

    switch(q) {
    case '+': b = static_cast<FT>(op_plus);
        break;
    case '-': b = static_cast<FT>(op_minus);
        break;
    }

    if (b) {
        cout << "answer = " << b(a,c) << endl;
    }
}

There are many ways to map your operator input parameter '+', '-', etc into operations. And you'll probably extend and change it as development goes on, so it might be a good idea to move the function pointer stuff into a class:

Code:

struct Operation {
    typedef int (*FT)(int,int);
    FT b = nullptr;

    Operation(char q)
    {
        switch(q) {
        case '+': b = static_cast<FT>(op_plus);
            break;
        case '-': b = static_cast<FT>(op_minus);
            break;
        }
    }

    int operator()(int a, int c) const { return b(a,c); }
    operator int() const { return (int)b; }
};

Now the main code becomes:

Code:

#include <iostream>
using namespace std;

/* ... declarations here */

int main()
{
    int a = 100;
    int c = 200;

    cout << "Enter + or -: ";
    char q;
    cin >> q;

    Operation b(q);

    if (b) {
        cout << "answer = " << b(a,c) << endl;
    }
}

Originally Posted by c99tutorial

You can use function pointers for this. (a b c) is the same as saying b(a,c), where b is a function that performs arithmetic such as adding two numbers.

This crossed my mind the first time I read post #1, but the problem is that DawnOfMe was "basically trying to a calculator without all the cases". With a function pointer or function object approach, you still need to "map your operator input parameter '+', '-', etc into operations", and for that you will most likely consider the various cases, whether you literally use a switch with case or an if-else chain.

Originally Posted by c99tutorial

And you'll probably extend and change it as development goes on, so it might be a good idea to move the function pointer stuff into a class:

The static_cast to FT is not necessary. Instead of the conversion function to int, define an explicit conversion function to bool:

Code:

explicit operator bool() const
{
    return b != nullptr;
}

Though it might be better to throw an exception from the constructor instead.

Then again, if you are going with a class, maybe you might as well go with a function object class hierarchy.