3. Vector of Arrays

Vector of Arrays

  • G

    Hi zusammen !

    eine Frage zu Vektoren:
    Ich besitze eine Klasse CrossPoint und möchte davon ViererPacks in Form eines Arrays. Schließlich soll ein Vektor diese Arrays aufnehmen.

    class CrossPoint{
	public:
		int myContent
};

vector<CrossPoint[4]> myCrossPoints;

    Der Compiler gibt allerdings die Fehlermeldung aus
    c:\Anwendungen\Programmierung\Microsoft Visual Studio .NET 2003\Vc7\include\vector(810): error C2075: '_Tmp': für die Initialisierung eines Arrays sind geschweifte Klammern erforderlich

    Wäre super wenn mir da einer weiterhelfen könnte !!! 🙂

    Gruß,
    GiantGeorge

    0
  • ?

    Da mußt du schon ein paar mehr Klimmzüge machen - eine Bedingung an vector<>-Elemente ist, daß sie mit = zugewiesen werden können, was für normale Arrays nicht geht. Du könntest das Array aber in eine struct verpacken, dann dürfte es wieder funktionieren:

    class CrossPoint{...};

struct cpArray
{
  CrossPoint data[4];
};

vector<cpArray> myCrossPoints;

    (oder du nimmst gleich vector<vector<CrossPoint> >)

    0
  • G

    hmm ja, danke schonmal !

    ich wunder mich nur über die doch recht eindeutige und verheißungsvolle Compilermeldung. Ich kenn mich da zu wenig aus, aber kann es sein, dass die = Zuweisung einfach überladen sind, sodass beim pushen etc. von einem Array einfach eine Copy Routine aufgerufen wird?🙄

    Vektorenverschachtelung wollte ich halt aus Performancegründen vermeiden, und bei einem weiteren struct schreibt sich alles so umständlich. Aber vielleicht bin ich auch nur ein verbohrter Minimalist. 🤡

    0
  • ?

    GiantGeorge schrieb:

    ich wunder mich nur über die doch recht eindeutige und verheißungsvolle Compilermeldung.

    Das ist das Problem bei den Fehlermeldungen in Templates - sie sind teilweise etwas unklar.
    (der Compiler ersetzt alle Vorkommen des Template-Parameters durch die aktuellen Typen und versucht dann, ob er etwa damit anfangen kann - und eine Anweisung "T _tmp = X;" macht wenig Sinn, wenn T ein Array ist.

    Ich kenn mich da zu wenig aus, aber kann es sein, dass die = Zuweisung einfach überladen sind, sodass beim pushen etc. von einem Array einfach eine Copy Routine aufgerufen wird?🙄

    Der Vektor überlädt gar nichts - er sucht nur nach den richtigen Überladungen für die verwendeten Operationen (z.B. Copy-Konstruktor, Zuweisung, etc.) und ruft sie auf - in deinem Fall ist er darüber gestolpert, daß ein Array keinen Copy-Ctor hat (versuch' mal, "int x[5]={1,2,3,4,5};int y[5]=x;" zu compilieren).

    Vektorenverschachtelung wollte ich halt aus Performancegründen vermeiden, und bei einem weiteren struct schreibt sich alles so umständlich. Aber vielleicht bin ich auch nur ein verbohrter Minimalist. 🤡

    Plan C wäre es noch, eine eigene Klasse Array<T,int> zu schreiben, die ein Array fester Größe kapselt.

    0
  • R

    Den Minimalisten gehoert die Welt ! ^^

    Zu deiner fehlermeldung:
    Anforderungen der Standard-Container : CCtor !!!

    Alsowenn deine zu haltende Struct/klasse vom typ T ist:

    const T a = ???; // irgendwas halt ....

    T b(a); // das muss funktionieren !!!

    Du speicherst aber variablen vom typ array ....

    CrossPoint a[4] = {???, ???,???,???}; // nehmen wir mal an es wurde korrekt initialisiert ....
    CrossPoint b[4] (a); // !!!! wird er definitiv nicht kompilieren !!!

    Fazit : Arrays unterstuetzen keine CCTor Syntax -> sind nicht fuer STL-Container geeignet !!!

    Abhilfe:

    In ne klasse Kapseln !!!

    Ansatz:

    template<class T, size_t ASize>
class MyStaticArray
{
public: 
    // standard CTor
    MyStaticArray()
    {
          // In C++ lassen wir nix uninitialisiert ^^ 
          memset(mArray,0,sizeof(T)*ASize);
    }
    MyStaticArray(const MyStaticArray & rx) // CCTOR um das ding fuer STL COntainer zu nutzen
    {
         memcpy(mArray,rx.mArray,sizeof(T)*ASize);
    }
    // Damit wir das ding wie nen Array verwenden koennen brauchen wir nen Index Op 
    inline T & operator[](size_t index)
    {
         return mArray[index];
    }
    // Konstante Arrays sollen auch funzen 
    inline const T & operator[](size_t index) const
    {
         return mArray[index];
    }
    // ZuweisungsOp waer sicher auch noch moeglich .... 
    inline Crosspoint4ArrayT & operator = (const Crosspoint4ArrayT & rx)
    {
        // wie wird das wohl implementiert sein ? 
    } 
private: 
    mArray[ASize];
};

// nur die deklaration deines Arrays iss nu bisserl anders .... 

typedef MyStaticArray<CrossPoint,4> Crosspoint4ArrayT;

vector<Crosspoint4ArrayT> mVec; // sollt nu gehen .... 

// initialisation iss nu bisserl anders .. wenn was spezielles brauchst, solltest obiges template auf nen Konstruktor mit den werten gleich spezialisieren, das wuerde dir einmal kopieren oder stufenweises belegen der werte ersparen 

Crosspoint4ArrayT t; // geht nu nich mehr mit {...}
t[0] = X; // wenn man nem Crosspoint X zuweisen kann sollt das gehen .... 
t[1] = X;
t[2] = X;
t[3] = X;

mVec.insert(t); // sollt nu gehen .... 
mVec[0] = t; // sollt gehen wenn der zuweisungsop fuer Crosspoint4ArrayT definiert wurde

    Man kann mit C++ und co auch effizient programmieren und trotzdem klassen verwenden ^^ templates und inline sind da dein freund ....

    Ciao ...

    0
  • G

    wow danke !! 🙂
    ich geb zu, da hab ich ne zeitlang gebraucht um das zu verstehen, aber schaut sehr cool aus !! 🕶

    THX
    GiantGeorge

    0
Anmelden zum Antworten