3. this auf 0 prüfen

this auf 0 prüfen

  • J

    Hallo,

    ist das eigentlich grundsätzlich korrekt oder comilerabhängig`?

    void class::memberfunction() {
  if (!this) {
    return;
  }
}

    damit könnte ich nämlich folgendes eleganter lösen:

    class *c = get_object_aus_einer_liste();
if (c) {
  c->memberfunction();
}
// und hier noch 7 mal eine abfrage auf eine liste um ein objekt zu bekommen

    daraus würde dann einfach:

    get_object_aus_einer_liste()->memberfunction();

    get_object_aus_einer_liste() würde dann halt 0 zurückgeben, wenn es kein passendes objekt findet.

    ich habe eine gekachelte darstellung und möchte, wenn ich auf eine kachel zugreife die umliegenden kacheln auch markieren oder was auch immer.

    frohe weihnachten
    jenz

    0
  • V

    aufruf von 0->foo() ist bereits undefiniert! damit ist drinnen die abfrage nicht mehr sinnvoll, wenn man code schreiben will, der vom standard abgedeckt wird. leider.

    0
  • J

    schade.

    danke.

    auf 0->foo() hätte ich auch mal kommen können, dann hätte ich mir mein ganzes geschreibsel sparen können...

    0
  • V

    jenz schrieb:

    auf 0->foo() hätte ich auch mal kommen können, dann hätte ich mir mein ganzes geschreibsel sparen können...

    Nein, das hätte ich niemals verstanden und hätte nur doof geguckt. Geschreibsel ist schon gut. Ich durfte 0->foo() in der Antwort nur schreiben, weil durch dein Geschreibsel der Kontext klar war, fürchte ich.

    0
  • V

    trotzdem muß das doofe

    if (c)

    nicht immer in den nutzcode rein. wenn der nutzcode schon verdammt kompliziert ist, irgendwelceh baumeinfügesachen, mache ich gerne mal

    class foo
{
  static void tuwasfallsduexistierst(foo* c)
  {
    if(c)
      c->tues();
  }
  void tues()
  {
  }
}
    0
  • J

    bei mir ists folgendermaßen:
    1. gekachelte fläche
    2. wenn man mit der maus drüber fährt soll die über der die maus ist größer werden
    3. gleichzeitig sollen die umliegenden kleiner werden.

    8 funktionion für die umliegenden kacheln habe ich:
    tl,t,tr,l,r,bl,b,br (tl = topleft usw.)

    jede kachel muss anders behandelt werden (alle sind an der linke oberen ecke festgenagelt):
    tl: höhe und breite
    t: höhe
    tr: höhe und breite und nach rechts verschieben
    l: breite
    r: breite und nach rechts
    bl: breite/höhe und nach unten
    b: höhe und nach unten
    br: höhe breite und nach rechts und nach unten

    da sehe ich jetzt eigentlich nur noch jeweils:

    piece *p(tl);
if (p) {
  p->size(x,y);
}

    und so weiter für alle anderen.

    klar kann man jetzt noch mal für alle einzeln kapseln, aber davon habe ich auch nicht viel, also alles in eine methode.
    die hat dann statt 8 zeilen gleich 32.

    so wäre es sooooo schön:

    tl()->sizerel(-x,-y);
  t()->sizerel(0,-y);
  tr()->sizerel(-x,-y)->move(x,0);
  l()->sizerel(-x,0);
  r()->sizerel(-x,0)->move(x,0);
  bl()->sizerel(-x,-y)->move(0,y);
  b()->sizerel(0,-y)->move(0,y);
  br()->sizerel(-x,-y)->move(x,y);

    grüße
    jens

    0
  • D

    klar kann man jetzt noch mal für alle einzeln kapseln, aber davon habe ich auch nicht viel, also alles in eine methode.

    Warum hast du da nicht so viel davon?
    Ist doch eine gute Methode..

    0
  • J

    weil ich davon einfach keinen gewinn habe.

    so habe ich jetzt eine funktion mit 32 zeilen, und die funktion werde ich wohl sonst nirgends brauchen.

    wenn ich da jetzt für jede kachel eine extra funktion draus baue, dann habe ich 8 funktionen mit jeweils 5 zeilen plus eine 8 zeilen funktion um die alle aufzurufen.
    und dann brauche ich diese einzelnen funktionen auch nie wieder, also lasse ich lieber alles in einer.

    jenz

    0
  • ?

    dann nimm doch ein nullobjekt:

    whatever *tr()
{
    static whatever;

    if (something)
        return tollesobjekt;

    //return 0; // nein!
    return &whatever;
}

    natürlich darf das objekt nichts machen oder andere objekte beeiflussen.
    musst du irgentwie markieren, oder du leitest eine nullklasse von deiner
    hauptklasse ab.
    dafür kannst du das aber so schreiben wie du möchtest. 🙂

    0
  • V

    tippgeber schrieb:

    dann nimm doch ein nullobjekt:

    whatever *tr()
{
    static whatever;

    if (something)
        return tollesobjekt;

    //return 0; // nein!
    return &whatever;
}

    natürlich darf das objekt nichts machen oder andere objekte beeiflussen.
    musst du irgentwie markieren, oder du leitest eine nullklasse von deiner
    hauptklasse ab.
    dafür kannst du das aber so schreiben wie du möchtest. 🙂

    Und Laufzeit bezahlen. Nee, häßlich.

    0
  • D

    Ich verstehe immer noch nicht, was an volkards Vorschlag so schlecht sein soll?

    foo::sizerel(t1,-x,-y);
  foo::sizerel(t,0,-y);
  foo::sizerel(tr,-x,-y)->move(x,0);
  foo::sizerel(l,-x,0);
  foo::sizerel(r,-x,0)->move(x,0);
  foo::sizerel(b1,-x,-y)->move(0,y);
  foo::sizerel(b,0,-y)->move(0,y);
  foo::sizerel(br,-x,-y)->move(x,y);

    Ist doch nicht so viel unleserlicher, als auf die -> Art. Und vor allem hast du keinen Copy/Paste Code..

    Ich denke mit ein wenig boost::bind und boost::function könnte man da auch was sehr schönes, allgemeines machen.

    0
  • V

    Hihi, Du mußt ja voll im Weihnachtsstreß sein. :xmas1:

    foo::sizerel(tr,-x,-y)->move(x,0);//ist 0->move() erlaubt?

    foo::move(foo::sizerel(tr,-x,-y),x,0);//java?

    //noch ein syntax-trick
  if(tile* t= tl() ) t->sizerel(-x,-y);
  if(tile* t= t()  ) t->sizerel(0,-y);
  if(tile* t= tr() ) t->sizerel(-x,-y)->move(x,0);
  if(tile* t= l()  ) t->sizerel(-x,0);
  if(tile* t= r()  ) t->sizerel(-x,0)->move(x,0);
  if(tile* t= bl() ) t->sizerel(-x,-y)->move(0,y);
  if(tile* t= b()  ) t->sizerel(0,-y)->move(0,y);
  if(tile* t= br() ) t->sizerel(-x,-y)->move(x,y);
    0
  • D

    Hehe. Hups, ja stimmt. Das macht das ganze natürlich nicht mehr soo trivial. 🙂

    0
Anmelden zum Antworten