* überladen

ich will gerne in einer neuen Klasse den Operator * überladen, der folgendes macht:
aus 2 zahlen jeweils 16% abziehen und die dann multipliezieren.

habt ihr ne idee?

miller_m

http://tutorial.schornboeck.net/operatoren_ueberladung.htm
http://www.cpp-tutor.de/cpp/le12/le12_04.htm

Shade Of Mine

den operator* nicht überladen. weil * multiplizieren und nicht "subtrahieren und dann multiplizieren" heisst.

das ists schon klar, aber kann man nicht das so machen dass man erst die zahlen ändern (sprich 16% abziehen) und dann multiplizieren..so dass wenn die operation * in der klasse benutzt wird dass er erst 16% abzieht un dann multipliziert?

sorry bin ziemlich anfänger!

miller_m

was spricht gegen eine aussagekräftige methode?

@shade
jetzt hast du dich ja selber zitiert, mir war schon klar das er es nicht lesen würde.

geht das nur mit operatorenüberladung nicht?

miller_m

Overload schrieb:

geht das nur mit operatorenüberladung nicht?

doch natürlich, aber es ein frage des sinnes bzw. des stils, wie shade schon
gesagt hat.

Wenn Du unbedingt willst:

#include <iostream>

using namespace std;

template <typename T>
class confusion
{
public:
       confusion(T value):m_value(value){}

       confusion<T> operator*(confusion c)
       {
              return confusion<T>( (m_value-.16*m_value) * (c.m_value-.16*c.m_value) );
       }

       friend ostream& operator<<(ostream &stream, confusion conf)
       {
              return stream<<conf.m_value;
       }

private:
        T m_value;
};

int main(int argc, char *argv[])
{   
    confusion<double> a(10),b(5);

    cout<<a*b<<endl;    
    cout<< (10-10*.16) * (5-5*.16) <<endl;

    system("PAUSE");
}

Oder besser so:

template <typename T>
class confusion
{
public:
       confusion(T value):m_value(value){}

       confusion<T> operator*(const confusion<T> &c) const
       {
              return confusion<T>( (m_value-.16*m_value) * (c.m_value-.16*c.m_value) );
       }

       friend ostream& operator<<(ostream &stream, const confusion<T> &conf)
       {
              return stream<<conf.m_value;
       }

private:
        T m_value;
};

Ich finds eigentlich sinnvoller, binäre Operatoren nicht als member zu implementieren. Ich denke

#include <ostream>

template <typename T>
class confusion
{
public:
  confusion(T value) : m_value(value){}

  inline T const &get_value() const { return m_value; }

private:
  T m_value;
};

template<typename T> 
confusion<T> operator*(confusion<T> const &c, confusion<T> const &d) {
  return confusion<T>((c.get_value() - .16 * c.get_value()) *
                      (d.get_value() - .16 * d.get_value()));
}

template<typename T>
std::ostream &operator<<(std::ostream &out, confusion<T> const &c) {
  return out << c.get_value();
}

wär da schöner.

super..vielen dank

Hallo leute....

suche Erläuterung für : using namespace std:

suche Erläuterung für : system("Pause");

Ich bin eigentlich C-Programmierer und weiss im Moment nicht genau,
was diese Zeilen bedeuten....

würd mich über eine Erklärung freuen....

miller_m

einen neuen thread zu eröffnen wäre besser gewesen

1.) http://tutorial.schornboeck.net/namespace.htm
2.) ruft einen systembefehl auf, in diesem fall pause

audacia

tutorial.schornbeck.net schrieb:

Man kann alle Operatoren überladen: &&, ||, , ->,... Ausnahmen sind: -> und ,

Man kann ->* und , durchaus überladen! Ausnahmen sind: ., .*, :: und sizeof !

Michael E.

sizeof weiß ich nicht. Man darf aber auch ?: nicht überladen (nur so als Ergänzung).

otze

sizeof darf nicht überladen werden, da c++ das intern zur bestimmung der exakten größe des typs braucht(soweit ich weis, arbeitet zb new damit), eine überladung die nicht die exakte größe zurückgeben würde wäre fatal.