this auf 0 prüfen

volkard

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.

volkard

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()
  {
  }
}

jenz

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

drakon

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..

jenz

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

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.

volkard

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.

drakon

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.

volkard

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);

drakon

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