Folgendes Problem, bei dem ich nicht weiterkomme.

Für n Identitäten (id) möchte ich 2 Arrays gleicher Art und Größe haben.
Die Relation Identität zu Objekt (hier das Array) erfolgt einfacherweise in einer Map.

Um die map am Anfang zu definieren, wollte ich es so etwa machen:

for (id=0 ; id<MAX ; id++)
{
   int array_a[3];
   int array_b[3];

   array_a_map.insert(make_pair(id, &array_a));
   array_b_map.insert(make_pair(id, &array_b));
}

Später könnte ich mir die Pointer zurückgeben lassen, die immer auf das erste Element der Arrays zeigen und damit dann arbeiten.

Jedoch wird die Inititlisierung so wohl nicht funktionieren, da ich die Array Adressen in der Map speichere. Bei nur einer id würde es funktionieren, beim weiteren for-Durchlauf wird doch wieder dieselbe Adresse geschrieben oder? Wäre also Mist.

Wie könnte man es sonst machen? Map von Map vielleicht? Die zweite Map wäre dann das Array.

Den Typ der Map wollte ich so setzen:
typedef std::map<int, int*> ArrayMapType

Ich sehe aber nicht wie ich sie unterscheiden sollte.

Besser das Ganze über eine
std::map<int, map<int, int>>
machen !?

Wie könnte man es sonst machen? Map von Map vielleicht? Die zweite Map wäre dann das Array.

Ich würde es (wenn ich den dein Problem richtig verstehe) wohl auf eine der folgenden Weisen umsetzen:

std::map<int, std::vector<int> >
std::map<int, std::tr1::array<int, 3> >

Ein Array durch eine map zu ersetzen sehe ich als falsch an, da würde ich auf entweder einen vector oder dem array aus dem TR1 zurückgreifen, da diese einem Array noch am meisten ähneln.

Ich habe diese zwei Arrays:
int array_a[3];
int array_b[3];

Normalerweise schreibe und lese ich direkt mit z.B.
array_a[0] = 0x10;

Da ich nun n verschiedene Kontexte habe (Identitäten genannt), kann in jeder Identität der Inhalt der Arrays anders sein. Und sie gibt es dann auch n-mal (für jede Id).
Ich muss also über eine Id<->Array Relation drauf zugreifen. Ich denke eine map ist dafür geeignet. Der Index ist die Id, der Content ist ein "Pointer auf Array".
Insgesamt habe ich also auch 2 maps, "array_a_map" und "array_b_map".

typedef std::map<int, int*> ArrayMapType;

// Funktion die mir den Pointer zurückgibt:
int * GetPtr2ArrayfromIdMap(int id, ArrayMapType map_name)
{
  ArrayMapType::iterator iter = map_name.begin();

  iter = map_name.find(id);
  if( iter != map_name.end() ) 
    return iter->second;
}

// Array Zugriff (Lesen):

  int * tmpArrayPtr = GetPtr2ArrayfromIdMap(id, array_a_map); // get Ptr to Array
  int tmp__0 = *(tmpArrayPtr);   // points to tmpArrayPtr[0]  
  int tmp__1 = *(tmpArrayPtr+1); // points to tmpArrayPtr[1]

Die Frage ist nun, wie ich initial die map aufsetze. Ich müsste für jede map und für jede Id ein 3 dimensionales Array reservieren. Dafür brauche ich die jeweiligen Adressen der Arrays, und
diese müssen bei jedem for-Durchlauf (siehe oben) eindeutig sein. Ich muss also die Arrays unterscheiden können. Da sie aber immer gleich heißen, sind sie auch immer dieselben Objekte.

OK hier noch etwas genauer:

Ehrlich gesagt bin ich von deiner Erläuterung eher verwirrt als was anderes.

Wenn die Arrays pro Id einen eigenen Inhalt haben müssen, ist meine Variante die richtige (Ansonsten müsstest du die Arrays dynamisch allozieren oder n-mal global definieren, wobei sich n nicht zur Laufzeit unterscheiden kann).

Meine Variante:

#include <array> // tr1-Header
#include <map>

int main()
{
    std::map<int, std::tr1::array<int, 3> > identityArray;

    // Beispiel für den schreibenden Zugriff auf ein Arrayelement zur Id 4711
    identityAArray[4711][0] = 41;
    //             \Id/  |
    //                   |
    //             Arrayposition

    // Beispiel für den lesenden Zugriff auf ein Arrayelement zur Id 4711
    std::cout << identityAArray[4711][0];
}

Was passiert beim Indexzugriff auf diese Map:
a) Existiert zu dem Key schon ein Element?
   => ja siehe c
   => nein siehe b
b) Ein neues array<int, 3> (Int-Array mit 3 defaultinitialisierten [bei int: 0]
   Einträgen) wird angelegt und in die Map zum Key abgelegt.
   => weiter mit c
c) Rückgabe einer Referenz auf den Inhalt (Hier dem Array).

Falls das nicht gewünscht ist: Abfrage mit find ob das Element existiert, und Zugriff per Iteratoren.

Allerdings habe ich hier VC++ 6.0

Warum?

Danke, werde ich mal versuchen. Allerdings habe ich hier VC++ 6.0 und ob es da die TR1 gibt, bin ich mir grad nicht sicher.

VC++6? Ne, der hat kein TR1. Das hat ja noch nichmal richtiges C++.

Mit anderen Worten: 1997 hat angerufen und will seinen Compiler zurück .

Allerdings habe ich hier VC++ 6.0 und ob es da die TR1 gibt, bin ich mir grad nicht sicher.

Nein, gibt es nicht. Dann ist der Weg etwas umständlicher, aber mit std::vector dennoch machbar.

Dennoch die schon hier gestellte Frage: Warum VC++ 6.0? Sofern dir dies nicht durch eine Firma vorgegeben wurde rate ich dir ganz dringend zu einem Wechsel auf eine aktuelle Plattform (z.B. Visual C++ 2008 Express).

Der VC++ 6.0 hat etliche Probleme mit dem C++ Standard (logisch, der C++ Standard kam etwas danach raus).

Aber um auf die Alternativen zurück zu kommen:

#include <map>
#include <vector>

int main()
{
    std::map<int, std::vector<int> > identityArray;

    // Beim ersten Zugriff auf Id den vector für drei Elemente initialisieren:
    identityArray[4711] = std::vector<int>(3);

    // Rest läuft identisch, nur muss sichergestellt sein, das vor dem Zugriff
    // auf den jeweiligen vector über den Indexoperator dieser schon drei
    // Elemente enthält (Ein Standardkonstruierter vector enthält anfangs 0
    // Elemente).
    ...
}

asc schrieb:

// Beim ersten Zugriff auf Id den vector für drei Elemente initialisieren:
identityArray[4711] = std::vector<int>(3);

Ich hoff ich verstehe es richtig, dann müsste ich das ja so schreiben:

for (..Identity.. )
{
  array_a_map.insert(make_pair(Identity, std::vector<int>(3)));

}

Genau ich muss ihm die Sachen reservieren.

Nein, DU musst die Sachen nicht zwangsweise reservieren. Zumindest wenn du mit Objekten arbeitest, die eben diese Aufgabe für dich übernehmen. Und ein Standardkonstruiertes std::tr1::array<int, 3> wäre für dich als Mapelement eigentlich genau richtig (Ist aber nicht extrem veralteten VC++ 6.0 enthalten).

Die Map stellt bereits eine Initialisierung mit dem Standardkonstruktor sicher. Sofern du den Indexoperator verwendest, ist Sichergestellt das ein entsprechendes Objekt bereits existiert. Nur muss man 3 Fälle unterscheiden:
a) Ein Standardkonstruierter Zeiger bringt dir hier keinen Nutzen.
b) Ein Standardkonstruiertes std::tr1::array<int, 3> ist eine Arrayklasse mit 3 int-Werten (Im wesentlichen ein Wrapper um ein C-Array).
c) Ein Standardkonstruiertes std::vector ist ein vector mit 0 Elementen. Da du 3 benötigst musst du selbst sicherstellen das die beim lesenden Zugriff auch enthalten sind. Dies geht entweder durch eine Zuweisung mit einem entsprechenden Vector, oder ein resize...

se1111 schrieb:

Ich hoff ich verstehe es richtig, dann müsste ich das ja so schreiben:

for (..Identity.. )
{
  array_a_map.insert(make_pair(Identity, std::vector<int>(3)));

}

Kürzer Wäre:

for (..Identity.. )
{
  array_a_map[Identity] = std::vector<int>(3);
  // ODER
  array_a_map[Identity].resize(3);
}

Bei verwendung eines neuen Compilers mit der TR1 Unterstützung kannst du dir diesen Schritt gänzlich schenken (wie gesagt std::tr1::array).