3. Hilfe für Klausur...

Hilfe für Klausur...

  • F

    otze schrieb:

    aber durchaus noch verbesserungswürdig :p

    Was willst du denn noch verbessern? Eine Implementierung für false hinzufügen? 🤡
    Sollte ja auch nur ein kurzes Bsp. sein ...

    @scrub:
    Hier eine kleine Einführung: http://home.earthlink.net/~joshwalker1/writing/TemplateMetaprogramming.html

    0
  • N

    scrub schrieb:

    was sind templates denn nun?

    Das sind Klassen/Funktionen/.../wasauchimmerParametererwartet
    Anstatt zu schreiben:

    Foo(int)
Foo(double
//...

    ->Man will das für alle Datentypen schreiben (Auch benutzergenerierte) -> Man benutzt dann einen Symbolischen Datentyp (meist T,U,V,...) So z.B.:

    template<class /*typename ginge auch*/ T>    //Was für Parameter will ich überhaupt
Foo(T t)
{
    //tue was auch immer nötig ist
};

    Achja: Die Funktionen weden vom kompiler automatisch erzeugt, wenn sie benötigt werden...

    0
  • O

    mithilfe von templates erstellt dir der compiler mehrere Versionen einer Klasse, zb wenn du eine Klasse haben willst, die für int,long,double,float und bool funktioniert, musst du nicht für jede version eine eigene Klasse schreiben, sondern benutzt eine template klasse.

    ich erklärs mal am vector:

    template<class T,...>
class vector{...};

//in der main
vector<int> a;//nimmt jetzt int an
vector<float> b;//nimmt jetzt float an
vector<vector<int> > c;//nimmt jetzt vector<int> an

    templates ersparen dir a) viel schreibarbeit, und b) sind damit einige fortgeschrittene Techniken möglich(wie der compile time assert), die den programmcode dazu bringen können, hochoptimierten code zu erzeugen.

    0
  • G

    Bashar schrieb:

    Nein, Leeranweisungen sind nur solche, die wirklich leer sind. Also ein einsames Semikolon. if (false); ist eine if-Anweisung.

    Sollten ja auch nur Beispiele sein. Ich hoffe du willst nicht bestreiten, dass die Sub-Anweisungen trotzdem Leeranweisungen sind.

    Bashar schrieb:

    Nein, der Inhalt der Headerdatei ist Teil der Übersetzungseinheit.

    Wieso einige Leute immer so penibel sein müssen. Da hab ich wohl den Smiley vergessen. Ich wollte damit eigentlich nur sagen, alles was nicht wahr ist, ist falsch. 😃

    scrub schrieb:

    ja ne, is klar.
    nur halt kein ... *hark* wie soll ichs sagen.. kein code, der irgendwas sinnvolles macht.
    ich mein, int foo(int a); ist natürlich code, aber daraus kann man kein programm machen. weil das dingenskirschens, was daraus ein programm machen soll, gar nicht weiß, was foo eigentlich macht.

    Interpretiere nicht in anderer Leute's Aussagen deine Sichtweise. 😉

    scrub schrieb:

    ka was templates sein sollen... soweit ich weiß parametrisierte klassen, quasi eine art "objekt"makro. kein plan, werd ich wahrscheinlich auch nie brauchen *g*

    Schade für dich. Templates sind ua ein Grund, warum ich kein C, sondern nur noch C++ programmiere.

    scrub schrieb:

    makros... makros gehören dahin, wo der pfeffer wächst, aber sonst nirgendwohin.

    Oder du benutzt sie sinnvoll, zB um portablen Code zu schreiben.

    0
  • S

    Wie wird dieses CTAssert, denn eingesetzt? Also dass es nur _keinen_ Fehler gibt, wenn das ganze auch true ist, ist klar, aber wie verwende ich das nacher im Code?

    0
  • O

    SirLant schrieb:

    Wie wird dieses CTAssert, denn eingesetzt? Also dass es nur _keinen_ Fehler gibt, wenn das ganze auch true ist, ist klar, aber wie verwende ich das nacher im Code?

    normalerweise kommt da en macro rum, welches das ganze in ne typedef/enum packt...

    ein beispiel:

    class Base{};
class Derived:public Base{};
class UnDerived{};
template<class T>
class Test{
    typedef CTAssert<IsDerived<T,Base>::Result> ASSERTER;//je nach compiler muss das ne enum sein,bei manchen reicht ne typedef, bei manchen leider nicht...
    //rest der Klasse...
};

//in der main
Test<Derived> a;//funzt
Test<UnDerived> b;//fehler, nicht von Base abgeleitet

    IsDerived stell ich hier mal nicht vor^^

    0
  • R

    Coole Sache, hab wieder was gelernt 👍

    0
  • C

    Vielleicht sollte man im diesem Zusammenhang noch boost::static_assert erwähnen: 🙂
    http://www.boost.org/libs/static_assert/static_assert.htm

    0
  • O

    was mich bei der boost version stört ist, dass man zwar einen compileabbruch hat, aber im ersten moment keinerlei anhaltspunkt hat wieso, und wo

    hier mal meine version, die sehr deutlich auf den assert hinweist(je nach compiler)

    template<bool,class> struct STATIC_ASSERTION;
template<class T> struct STATIC_ASSERTION<true,T>{};

template<int x> struct INTERNAL_STATIC_ASSERT{};
namespace FAILURE{
    class CAN_NOT_CONVERT{};
    class FALSE_TEMPLATE_PARAMETER{};
    class DIVISION_THROUGH_NULL{};
    class OUT_OF_RANGE{};
};
#define STATIC_ASSERT(b,msg) typedef INTERNAL_STATIC_ASSERT<STATIC_ASSERTION< b,msg>::Value> ASSERT;

    so sieht dann unter dem gcc ein solcher Fehler aus:

    test.cpp:9: error: incomplete type `STATIC_ASSERTION<false,
FAILURE::FALSE_TEMPLATE_PARAMETER>' does not have member `Value'
test.cpp:9: error: template argument 1 is invalid
test.cpp:9: error: ISO C++ forbids declaration of `ASSERT' with no type

    man beachte: datei, zeilenangabe und fehlerart.

    0
  • S

    otze schrieb:

    [...]
    IsDerived stell ich hier mal nicht vor^^

    Doch zeig mal 🙂

    0
  • S

    Bashar schrieb:

    scrub schrieb:

    hm... was hat das mit den inlinefunktionen auf sich? das sind doch auch funktionen, die man deklarieren kann, und damit gehören ihre schnittstellen natürlich ebenfalls in den header. sag ich doch...

    Ich rede aber nicht von ihren Deklarationen, sondern von ihren Definitionen. Für deinen Grad von Ahnung diskutierst du mit ziemlich viel Elan, das muss man dir lassen. Ich hoffe, das ist bei deinen politischen Diskussionsbeiträgen nicht auch so.

    ein klassischer fall von aneinandervorbeireden. 😃

    keine sorge, ich weiß, daß ich nichts weiß. das hindert mich natürlich nicht, zu sagen, was ich weiß. und von politik hab ich .... SEHR viel mehr ahnung als von programmierung. warum? mit programmierung beschäftige ich mich erst seit wenigen monaten, meine C64- rumspielphase mal nicht mitgezählt, mit politik und geschichte aber sehr viel länger.
    alles, was ich weiß, hab ich aus (mehr oder weniger schlauen) büchern. in denen so sachen stehen wie "makros sind schlimm schlecht und böse" oder "irgendwann wir die implizite annahme von int als returnwert wegfallen" oder "void(main)". was ich darüber hinaus weiß, hab ich von dem typen, der über mir wohnte, oder hier ausm forum oder von sonstwem.

    0
  • O

    SirLant schrieb:

    otze schrieb:

    [...]
    IsDerived stell ich hier mal nicht vor^^

    Doch zeig mal 🙂

    uff, da verlangst du heute aber viel von mir(insbesondere, da ich den code atm nicht zu verfügung habe^^)

    ich versuchs aber mal zusammenzukriegen:

    das ganze ist eigentlich ein primitiver test auf umwandelbarkeit derived->base.
    dieser test auf Umwandelbarkeit basiert auf dem sizeof operator und überladenen funktionen.

    template<class T,class U>
class IsConvertable{
    private:
        typedef char Small;
        class Big{char dummy[2];};
        Small test(U);
        Big test(...);
        T makeT();
    public:
        enum{Result=sizeof(Small)==sizeof(test(makeT()))};
};

    prinzip sollte klar sein:
    man hat 2 funktionen, eine, die die nach Base konvertierbaren Typen annimmt, und die ellipse die den ganzen rest schluckt.
    je nachdem, welche funktion genommen wird, ist der rückgabetyp anders.
    mithilfe von sizeof wird am ende nurnoch bestimmt, welcher rückgabetyp genommen wird->Small=kann gecasted werden Big=kann nicht gecastet werden.

    leider reicht das nicht, da

    IsConvertible<char,short>

    auch true zurückgibt, aber char/short sind ja keine klassen, und erstrecht nicht voneinader abgeleitet 😉
    Dh, man muss alle standard C++ Typen rauswerfen, da die garantiert von nichts abgeleitete sind.

    um fundamentale typen zu erkennen, reicht eine denkbar einfache konstruktion:

    template<class T>
struct IsFundamental{
    enum{Result=false};
};
template<> struct IsFundamental<char>{
    enum{Result=true};
};
template<> struct IsFundamental<int>{
    enum{Result=true};
};
//...

    alternativ kann man das auch mit typlisten machen, ist weniger copy&paste aber leider auch nicht ganz so schnell, da man viele rekursionen haben kann, und zeit ist das, was man beim compilen nicht hat :D.

    Und so sieht das dann in etwa aus:

    template<class Base,class Derived>
struct IsDerived{
     private:
         enum{Fundamental=IsFundamental<Base>::Result||IsFundamental<Derived>::Result};
     public:
enum{Result=!(Fundamental)&&IsConvertable<Base,Derived>::Result};
};

    ein test fehlt aber noch: Base!=Derived

    template<class T> struct IsDerived<T,T>{
    enum{Result=false};
};

    falls ich fehler drin haben sollte,bzw irgendeinen test nicht drin haben sollte, bitte nicht köpfen, habs ausm kopf gemacht^^.

    ps: den test auf function/methodpointer hab ich jetzt mal nicht gemacht, da a) zu faul, b) wird das eh niemand versuchen wollen 😃

    0
  • P

    Ahhh.
    Wieso ist iostream den veraltet?? Ich dachte das wäre die modere Variante und stdio
    sei alt. Oder benutz man keins von beiden mehr? Wenn nicht was dann??
    Eigene überladene Operatoren mit Itentoren kann man ja auch benutzen, aber ist das nicht mehr Aufwand?
    Helft mir, mein Weltbild ist zerstört!

    0
  • O

    iostream.h ist veraltet

    0
  • P

    otze schrieb:

    iostream.h ist veraltet

    Ach so!

    0
Anmelden zum Antworten