eine stilfrage

otze

also, ich hab nen container namens "attVector",Vector steht für den std::vector, dh das teil verhält sich wie ein vector(bis auf die iteratoren) und att steht für attachment,der vector hat dem namen nach die Eigenschaft andere Container dieses Typs "angehängt" zu bekommen,und ist somit auch befähigt, auf diese Elemente zugreifen zu können.Bevor ihr nun weiterlest, lasst eure innere Wut über so eine offensichtlich miese idee an der nächsten Wand aus .

nun zum stilproblem:
jeder vector muss natürlich selber daten speichern können, also brauch er schonmal sowas in der art:

std::vector<value_type,Allocator> data;

aber um andere Vectoren angehänht zu bekommen brauch er auch das:

std::vector<AttVector<value_type,allocator_type>*,allocator_type> attachments;

Ok, nun zum problem:
wenn ich nun eine funktion schreibe,die über den op[] einen wert zurückgibt lande ich automatisch bei einem problem, wenn ich diese beiden vectoren in coexistenz lasse:

std::vector<Type,Allocator> data;
std::vector<AttVector<Type,allocator_type>*,allocator_type> attachments;

rein theoretisch müsste ich zuerst immer data überprüfen, ob er das gesuchte element enthält,wenn er dies nich tut, muss ich in attachments rein.
nun, diese "extrawurst" für data sieht im code nich besonders schön aus:

reference getElementById(unsigned int ID){
    if(data.size()>ID){
        return data[ID];//extrawurst
    }
    unsigned int position=data.size()-1;
    for(int i=0;i<attachments.size();++i){
        if(position+=attachments[i]->size()>=ID){
            return (*attachments[i])[ID-position];
        }
        position+=attachments[i]->size();
    }
    assert(0);
}

da wär das doch viel schöner:

reference getElementById(unsigned int ID){
   unsigned int position=0; 
   for(int i=0;i<attachments.size();++i){
        if(position+=attachments[i]->size()>=ID){
            return (*attachments[i])[ID-position];
        }
        position+=attachments[i]->size();
    }
    assert(0);
}

ausserdem verstößt der Container mit den beiden vectoren gegen die regel:one class one responsability.

was meint ihr, soll ich das so lassen?(jetzt mal abgesehen davon, dass ihr die idee dumm findet),oder sollte ich versuchen, alles in attachments reinzuwerfen, wenn ja, wie sollte ich das am besten anstellen?
Was sagen euer goldenes Stilregelbuch dazu?
(achtung, das war jetzt nach dem ganzen block die frage )

ps: wenn ihr diesen post seht,wird er das ergebnis einer 20 minütigen überlegung sein,die ich während des schreibens getätigt hab, is mir nämlich eigentlich nicht so recht, euch mit sowas nerven zu müssen

Shade Of Mine

Das klingt ein bisschen als wolltest du eine liste implementieren

Naja, ich würde es so machen (wobei mir der Sinn dieses Konstrukts nicht klar ist)

reference operator[](unsigned index)
{
  if(index<data.size())
    return data[index];

  assert(!attachments.empty());

  index-=data.size();
  for(unsigned i=0; i<attachments.size(); ++i)
  {
    if(attachments[i]->size() >= index)
      return (*attachments[i])[index];
    index-=attachments[i]->size();
  }
  assert(0);
}

otze

ne, ne liste is es nicht,obwohl es listen character hat,zugegebenermaßen