3. Eigene Datentypen definieren

Eigene Datentypen definieren

  • C

    Hallo zusammen!

    Habe folgende Frage, und zwar wie kann ich eigene Datentypen definieren. Mithilfe von Klassen? 😕

    Möchte nämlich mal einen Datentyp definieren, welcher einen größeren Wertbereich hat als unsigned long.

    Danke im voraus
    Caipi 🙂

    0
  • S

    Caipi schrieb:

    Hallo zusammen!

    Habe folgende Frage, und zwar wie kann ich eigene Datentypen definieren. Mithilfe von Klassen? 😕

    Möchte nämlich mal einen Datentyp definieren, welcher einen größeren Wertbereich hat als unsigned long.

    Aha, du willst also eine Klasse schreiben, die sich wie ein Integer verhält, allerdings einen größeren Wertebereich hat. Und wo ist jetzt das Problem?

    0
  • E

    Dafür ist C++ wie geschaffen. Das Werkzeug der Wahl ist die Klasse. Damit kann man sich selbst (fast) beliebige eigene Datentypen schaffen. Was du suchst, gibt es natürlich schon.

    Siehe: long long (auch _int64 bei MS)
    Siehe: boost

    0
  • C

    Das das mit Klassen funktioniert habe ich mir schon fast gedacht, aber wie??
    (Sorry für diese blöde Frage, bin blutiger Anfänger 🙂 )

    Caipi

    0
  • I

    Caipi schrieb:

    Das das mit Klassen funktioniert habe ich mir schon fast gedacht, aber wie??
    (Sorry für diese blöde Frage, bin blutiger Anfänger 🙂 )

    Caipi

    Das ist keine Frage für ein Forum sondern ein Fall für ein C++Buch/Tutorial.

    0
  • E

    Wenn du wissen willst, wie eine Klasse generell funktioniert:
    http://www.cpp-tutor.de/cpp/le09/le09_01.htm

    Ansonsten solltest du einfach zunächst long long verwenden, das reicht schon in den Trillionenbereich:
    http://www.henkessoft.de/cpp_konsole.htm (siehe Collatz-Folge mit unsigned long long, ganz unten)

    Solche mathematischen Integer-Klassen sind recht komplex und müssen auf Effizienz ausgelegt sein, absolut nichts für einen Neueinsteiger in C++, sorry. Solltest du das nicht akzeptieren, lege einfach los, wir greifen dir unter die Arme. 😉

    siehe auch: http://www.andreaswarnke.de/proj/cc_Tools/

    Hilft dir dies weiter?

    0
  • C

    @Erhard Henkes: Vielen Dank für deine Bemühungen. Habe mir die header-files (von deinem Link) heruntergeladen. Hast recht, das ist noch etwas zu hoch für mich 😞 Ich mach erstmal bei meinen anderen Sachen weiter. Später werde ich vielleicht diesbezüglich nochmal anfragen. (Wenn ich es bis dahin nicht schon selbst geschaft habe 🙂 )

    Auf jeden Fall vielen Dank euch allen für die Antworten

    Caipi

    0
  • E

    Nur Mut, und viel Spaß. Du solltest aber keine Sachen entwickeln, die es schon gibt. Schau dir zunächst die umfangreiche Klassensammlung von boost an. Für Dev-C++ gibt es da ein Dev-Pak, falls du Probleme haben solltest, das in deine IDE einzuspielen. http://www.c-plusplus.net/forum/viewtopic.php?t=83475

    0
  • I

    Erhard Henkes schrieb:

    Nur Mut, und viel Spaß. Du solltest aber keine Sachen entwickeln, die es schon gibt.

    Das sehe ich anders. Gerade bei der Implementierung von Standardklassen wie String, Vektoren, Listen kann man enorm viel lernen.

    Schau dir zunächst die umfangreiche Klassensammlung von boost an.

    Du rätst einem absoluten Anfänger, der noch Probleme mit Klassen hat, zu boost? 🙄

    0
  • E

    @interpreter: du hast recht, der richtige Weg liegt in der Mitte. Aus einer eigenen String-/Complex-/Rational-Klasse kann man viel lernen. Man sollte aber parallel beginnen, die vorhandenen Werkzeuge (zumindest STL und boost) einzusetzen. Das ist doch die Grundidee der OOP. Modular entwickeln und das Rad nicht immer neu erfinden, d.h. vorhandene fremde und eigene Klassen verwenden.

    Das Verständnis kann durch boost in manchen Fällen sogar leichter erfolgen, Beispiel Singleton:

    #include <iostream>
#include <conio.h>
#include <boost/utility.hpp>
using namespace std;

class X : boost::noncopyable
{
  public:
      static X* Instance()
      {
          static X inst;
          return &inst;
      }
      const int getA() const { return a_; }      
  protected:
      X(){a_=42; cout << &a_ << endl;};
  private:
      int a_;  
};

int main()
{
    X& obj1 = *X::Instance();
    cout << &obj1 << " " << obj1.getA() << endl;
    X* obj2 = X::Instance();
    cout <<  obj2 << " " << obj2->getA() << endl;
    X* obj3 = obj2->Instance();
    cout <<  obj3 << " " << obj3->getA() << endl; 
    getch();
}

    //boost/noncopyable.hpp (Ausschnitt)
class noncopyable
{
 protected:
    noncopyable() {}
    ~noncopyable() {}
 private:  // emphasize the following members are private
    noncopyable( const noncopyable& );
    const noncopyable& operator=( const noncopyable& );
};

    Durch die Klasse boost::noncopyable wird die konkrete Umsetzung des Designprinzips Singleton durch die Aufteilung in zwei aufeinander aufbauende Teile besser einprägbar.

    0
  • R

    @Erhard
    richtig leicht macht man singletons anders

    class foo_singleton {
  int bop;
public:
  foo_singleton() : bob(10) { }
  void set_bob(int i) { bob=i; }
  int get_bob() const { return bob; }
};

typedef singleton<foo_singleton> foo;

int main() {
  foo::instance().set_bob(12);
}

    Und das implementieren von Standard Dingen ist IMHO eine gute Übung!

    Außerdem hat Boost doch gar keine Klasse für beliebig große Zahlen. Blitz++ und GNU MP gibt es dafür.

    0
Anmelden zum Antworten