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

danke.

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

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.

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

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

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

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

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.

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.

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.

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