help me to converting a char (-) into an operator (+)

[tnmashamba]

Anyone help me.i'm trying to convert a char (+) inputed by the user into a c++ operator (+)

[Moschops]

That makes no sense. I think you might be asking this:

A user can enter a char. If that char is '+', I want the program to do some kind of addition on some numbers. How can I do this?

Is that what you're asking?

[kbw]

You can't.

You have to read the character, then do addition within your program. If you show your program, someone can provide some helpful advice.

[viliml]

In fact, you most certanly can!

template<typename T>
using operator_t=T(*)(const T&, const T&);

template<typename T>
operator_t<T> char_to_op(char c)
{
	switch(c)
	{
		case '+':
			return [](const T& a, const T& b){return a+b;};
			break;
                case '-':
			return [](const T& a, const T& b){return a-b;};
			break;
		case '*':
			return [](const T& a, const T& b){return a*b;};
			break;
		case '/':
			return [](const T& a, const T& b){return a/b;};
			break;
		case '^':
			return [](const T& a, const T& b){return T(pow(a, b));};
			break;
		}
}

[viliml]

Of course, you need c++11, but I guess everyone should have at least some of it by now!

[vlad from moscow]

@viliml

case '^':
	return [](const T& a, const T& b){return T(pow(a, b));};
	break;

Shall the compiler issue an error because it does not know which overloaded function pow to call?

[viliml]

No, it shall not! I tried it out with this example:cout<<char_to_op<int>('^')(3, 2);
Do you have any examples that really DON'T work?

[viliml]

Also, you might add this:

case '=':
	return [](const T& a, const T& b){return const_cast<T&>(a)=b;};
	break;

It totally works like every thing else!

[Zephilinox]

that's actually...really cool...

[viliml]

Thanks! I was playing around with it and this is the latest code:

template<typename T>
using operator_t=T(*)(const T&, const T&);

template<typename T>
using comp_t=bool(*)(const T&, const T&);

struct not_an_op: exception
{
	virtual const char* what() const throw()
	{
		return "Not an operator!";
		}
};

struct not_a_comp: exception
{
	virtual const char* what() const throw()
	{
		return "Not a comparator!";
		}
};

template<typename T>
operator_t<T> char_to_op(char c)
{
	switch(c)
	{
		case '+':
			return [](const T& a, const T& b){return a+b;};
			break;
		case '-':
			return [](const T& a, const T& b){return a-b;};
			break;
		case '*':
			return [](const T& a, const T& b){return a*b;};
			break;
		case '/':
			return [](const T& a, const T& b){return a/b;};
			break;
		case '^':
			return [](const T& a, const T& b){return T(pow(a, b));};
			break;
		case '=':
			return [](const T& a, const T& b){return const_cast<T&>(a)=b;};
			break;
		default:
			throw not_an_op();
		}
}

template<typename T>
comp_t<T> string_to_comp(string a)
{
	if (a=="==") return [](const T& a, const T& b){return a==b;};
	if (a=="!=") return [](const T& a, const T& b){return a!=b;};
	if (a=="<") return [](const T& a, const T& b){return a<b;};
	if (a==">") return [](const T& a, const T& b){return a>b;};
	if (a=="<=") return [](const T& a, const T& b){return a<=b;};
	if (a==">=") return [](const T& a, const T& b){return a>=b;};
	throw not_a_comp();
}

[Zephilinox]

you may be on your way to creating your own mini-mathmatical scripting language ^."

[TheIdeasMan]

My 1 cent worth :D

Don't forget to check for divide by zero !!!!!!!

[viliml]

Hey, it's up for the programmer to check if he's calling the function returned by that function for dividing with the second argument 0! That's not up for the program!

[viliml]

BTW, the author of this thread didn't say one word after the original post! Isn't that a bit odd?

[Zephilinox]

maybe when he saw cplusplus was down he didn't bother trying to come back.

[viliml]

Cplusplus was down? I didn't notice... Probably was asleep.

[Zephilinox]

several times in the last few days for several hours each time, so yeah.

[viliml]

So, back to the topic, does anyone know how to improve my functions?

[viliml]

Here, I added some more:

template<typename T>
using operator_t=T(*)(const T&, const T&);

template<typename T>
using comp_t=bool(*)(const T&, const T&);

template<typename T1, typename T2>
using log_t=bool(*)(const T1&, const T2&);

struct not_an_op: exception
{
	virtual const char* what() const throw()
	{
		return "Not an operator!";
		}
};

struct not_a_comp: exception
{
	virtual const char* what() const throw()
	{
		return "Not a comparator!";
		}
};

struct not_a_log: exception
{
	virtual const char* what() const throw()
	{
		return "Not a logical operator!";
		}
};

template<typename T>
operator_t<T> char_to_op(char c) throw(not_an_op)
{
	switch(c)
	{
		case '+':
			return [](const T& a, const T& b){return a+b;};
			break;
		case '-':
			return [](const T& a, const T& b){return a-b;};
			break;
		case '*':
			return [](const T& a, const T& b){return a*b;};
			break;
		case '/':
			return [](const T& a, const T& b){return a/b;};
			break;
		case '^':
			return [](const T& a, const T& b){return T(pow(a, b));};
			break;
		case '=':
			return [](const T& a, const T& b){return const_cast<T&>(a)=b;};
			break;
		default:
			throw not_an_op();
		}
}

template<typename T>
comp_t<T> string_to_op(string a) throw(not_an_op)
{
	if (a=="==") return [](const T& a, const T& b){return a==b;};
	if (a=="!=") return [](const T& a, const T& b){return a!=b;};
	if (a=="<") return [](const T& a, const T& b){return a<b;};
	if (a==">") return [](const T& a, const T& b){return a>b;};
	if (a=="<=") return [](const T& a, const T& b){return a<=b;};
	if (a==">=") return [](const T& a, const T& b){return a>=b;};
	throw not_a_comp();
}

template<typename T1=bool, typename T2=bool>
log_t<T1, T2> string_to_log(string a) throw(not_a_log)
{
	if (a=="&&") return [](const T1& a, const T2& b){return a&&b;};
	if (a=="||") return [](const T1& a, const T2& b){return a&&b;};
	if (a=="^^") return [](const T1& a, const T2& b){return a||b && a!=b;};
        throw not_a_log();
}

I could really make a parser!

[viliml]

Anything I might add?