ich würde gerne die std Datentypen wie int, long usw durch Klassen ersetzen.
Nun frage ich mich wieviel Performence ich dadurch verschwenden würde.
Eigentlich dürfte es ja nicht soviel sein, da die operatoren Einzeiler wären.
Dies würde auch für den Construktor gelten. Wenn diese dann inline wären hätte ich ja eigentlich keinen bzw kaumen einen Overhead.

die std Datentypen wie int, long usw

Wie lang lernst du schon C++???

ich würde gerne die std Datentypen wie int, long usw durch Klassen ersetzen.

Was bringt dir das? Und was willst du dann als Basis für deine Datentypen verwenden?

Falls letzteres zutrifft kann ich dir empfehlen mal auf http://www.nist.gov/dads/ die spezifikationen einiger Standartdatenstrukturen (z.B. Stack, LinkedList) anzuschauen und versuchen sie zu implementieren.

Anderenfalls wirst du uns den tieferen Sinn deiner Aktion vllt noch mal erklären müssen

*finally made the post no. 100 *

Int Integer( 45 );
Integer.Sqrt():

Int Integer2( 44 );
Integer2 * Integer.Pow( 3 );

schreiben kann.
Natürlich wird es durch die Klasse langsamer sein,
aber solange ich nichts Performencekritisches mache
ist es ja nicht soo schlimm.

btw: kommst du zufällig von Java?

Ich wollte es einfach so machen, weil ich es so schöner bzw einfacher zu benutzen finde. Ich finde ein einfach schöner wenn ich z.B.

Int Integer( 45 );
Integer.Sqrt():

Int Integer2( 44 );
Integer2 * Integer.Pow( 3 );

schreiben kann.

So programmiert man aber nunmal im allgemeinen nicht in C++. Du versuchst hier, C++ krampfhaft ein Paradigma aus anderen Sprachen aufzuzwängen. Das halte ich für keine gute Idee.

aber ich mag C++ einfach lieber.

Dann benutz die Sprache doch auch so, wie sie geschaffen wurde...

Wenn es Dir egal ist, was an Performance dadurch flöten geht, wieso fragst Du dann überhaupt danach?

Mal davon abgesehen, dass bei einer sauberen Implementierung und einem optimierenden Compiler der Performanceunterschied virtuell sein könnte, d.h. der Wrapper sollte wegoptimiert werden.

Vielen Dank an alle

Danke Konrad,
habe es gerade getestet. Der gcc optimiert alles weg.

Asche auf mein Haupt …

#include <iostream>
#include <cmath>
using namespace std;

template<typename T>
class Number
{
    typedef T value_type;

    template<typename TT>
    friend ostream &operator<<(ostream &, const Number<TT> &);

public:
	Number(T value)
    : m_value(value)
    {
    }

	template<typename F>
	void operator()(const F &func)
	{
	    m_value = func(m_value);
	}

private:
	value_type m_value;
};

template<typename T>
ostream &operator<<(ostream &strm, const Number<T> &num)
{
    return strm << num.m_value;
}

int quad(int a)
{
    return a*a;
}

int main()
{
    Number<int> x = 49;

    x(sqrtf);
    cout << x << "\n";

    x(quad);
    cout << x << endl;
}

@ExtOOS: Mann kann sich auch mit nem Hammer aufn Kopf hauen, das ist auch eine dumme Idee und tut weh.
Ideen haben manche Leute...

- Finde ich auch.

Ich finde das ganze in etwa so sinnvoll, wie die bool - Klasse, die hier rumgegeistert ist.

Aber ganz ehrlich: Wozu sich die Mühe machen? Schreib lieber sinnvollen Code in der Zeit.

Oder nutz die Zeit um folgenden Artikel durchzulesen: http://www.ddj.com/cpp/184401197

#include "types.h" // <- defines class Int and template class IntT
class c
{
   IntT<42> m_x;

public:
   Int GetX() const {return m_x;}
// int GetX() const {return m_x;} <- is also an option
};

void f()
{
   c cObj;
   assert(cObj.GetX() == 42);

   Int i;
   assert(i == 0);
}

Verhält sich schon ein wenig wie im C#, aber das ist erwünscht :).

IntT<42> m_x;

Wow!
Ist dir klar was du da tust, bzw anrichtest ?