Rechenoperator einer Variable zuweisen?

Hallo, ist es möglich einer Variable einen Rechenoperator zuzuweisen?
z.B.
int a=5;
int b;
int c=2;

und dann b einen Rechenoperator zuweisen z.b. addition und dann
a=(a)b(c);
wo dann 7 rauskommt.

Kóyaánasqatsi

Nein. Fragt sich nur was das bringen sollte Aber falls du sowas unbedingt machen möchtest, bau ne Klasse mit gewünschter Operatorenüberladung.

SeppJ

Es gäbe da noch Funktionszeiger, um so etwas ähnliches zu erreichen. Wenn's sein muss, geht das auch sehr gut mit Makros.

Ok, hab ich mir schon gedacht..
Was das bringen soll? Ganz einfach.
Als Hausaufgabe soll ich ein Programm schreiben bei dem man aussucht ob Multiplikation oder Addition, dann Zahlen eingeben und die mit dem gewählten Rechenoperator Addieren oder Multiplizieren..
Jetzt würde ich 2 If abfragen machen und die rechenoperation für Multiplikation und Addition machen, wenn mein gedanke ginge müsste ich nur einer Variable den Operator zuweisen und dann den Schritt der Berechnung damit

SeppJ

poko schrieb:

Jetzt würde ich 2 If abfragen machen und die rechenoperation für Multiplikation und Addition machen, wenn mein gedanke ginge müsste ich nur einer Variable den Operator zuweisen und dann den Schritt der Berechnung damit

Das geht nicht. Die Zeichen + oder * haben während des Programmablaufs keine besondere Bedeutung. Irgendeine Art von Abfrage bräuchtest du auf jeden Fall.

Th69

Das Übliche bei so einer Anfängeraufgabe ist dann die Ablage des Operators in eine char-Variable ('+', '*', ...) und dann mittels einer switch-case-Anweisung die einzelnen Operationen auszuführen.

DrakoXP

Mit sehr viel langer Weile kann man es auch so machen :p

Operator.hpp:

#ifndef OPERATOR_HPP
#define	OPERATOR_HPP

#include <iostream>

class Operator
{
private:
    char m_op;
    friend std::istream& operator >> (std::istream &in, Operator &op);
    friend std::ostream& operator << (std::ostream &out, const Operator &op);
public:
    Operator(void);

    template <typename DataType>
    inline DataType operator () (const DataType &rhs, const DataType &lhs)
    {
        switch (m_op)
        {
            case '+': return (rhs + lhs);
            case '-': return (rhs - lhs);
            case '*': return (rhs * lhs);
            case '/': return (rhs / lhs);
        }
        return DataType();
    }
};

std::istream& operator >> (std::istream &in, Operator &op);
std::ostream& operator << (std::ostream &out, const Operator &op);

#endif	/* OPERATOR_HPP */

Operator.cpp:

#include "Operator.hpp"

using namespace std;

Operator::Operator(void)
: m_op('?')
{
}

istream& operator >> (istream &in, Operator &op)
{
    in >> op.m_op;
    if (op.m_op != '+' && op.m_op != '-' && op.m_op != '*' && op.m_op != '/')
        op.m_op = '?';
    return in;
}

ostream& operator << (ostream &out, const Operator &op)
{
    return (out << op.m_op);
}

main.cpp:

#include "Operator.hpp"
using namespace std;

int main(int argc, char** argv)
{
    int a, b;
    Operator op;
    cout << "Expression: ";
    cin >> a >> op >> b;
    cout << "Solution: " << op(a, b) << endl;
    return 0;
}

Die Operator-Klasse arbeitet hier zwar intern auch mit switch-case, aber zumindest entspricht jetzt die main-Funktion in etwa deiner Vorstellung

Ein Durchlauf des Programms sieht dann etwa so aus:

Expression: 6 * 7
Solution: 42