C/C++ Forum :: map mit arrays ?

se1111 Mitglied 17:19:02 10.03.2010 Titel:

Hallo Leute,

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:

C/C++ Code:
1 2 3 4 5 6 7 8	1 2 3 4 5 6 7 8	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)); }

C/C++ Code:
1 2 3 4 5 6 7 8	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)); }

C/C++ Code:
1 2 3 4 5 6 7 8	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.

DocShoe Mitglied 17:24:40 10.03.2010 Titel:

Ich kann dir nicht ganz folgen, fürchte ich. Abgesehen davon speicherst du Adressen eines Arrays, das nach Verlassen der for-Schleife überhaupt nicht mehr existiert. Was genau hast du denn vor?

se1111 Mitglied 17:34:20 10.03.2010 Titel:

stimmt, die Arrays müssten natürlich global sein um dauerhaft zu existieren.
Allerdings müssen sie sich ja irgendwie bei jedem Id Durchlauf unterscheiden lassen, um sie in der Map eindeutig zuzuweisen.

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 !? :confused:

DocShoe Mitglied 17:44:39 10.03.2010 Titel:

Beschreib´ doch bitte mal ganz genau das Gesamtvorhaben. Man kann bestenfalls vermuten, was du vorhast, zumindest ich habe keine Ahnung, welche Adressen du wann wie wiederfinden willst.

asc Mitglied 17:57:11 10.03.2010 Titel:

se1111 schrieb:

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.

se1111 Mitglied 18:09:49 10.03.2010 Titel:

OK hier noch etwas genauer:

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

C/C++ Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14	1 2 3 4 5 6 7 8 9 10 11 12 13 14	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; }

C/C++ Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14	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; }

C/C++ Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14	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; }

C/C++ Code:
// 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]*

C/C++ Code:
// 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]*

C/C++ Code:
// 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.

asc Mitglied 18:50:15 10.03.2010 Titel:

se1111 schrieb:

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:

C/C++ Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16	1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16	#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]; }

C/C++ Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16	#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]; }

C/C++ Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16	#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]; }

Code:
1 2 3 4 5 6 7 8	1 2 3 4 5 6 7 8	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).

Code:
1 2 3 4 5 6 7 8	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).

Code:
1 2 3 4 5 6 7 8	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.

se1111 Mitglied 10:35:53 11.03.2010 Titel:

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.

Michael E. Mitglied 11:50:04 11.03.2010 Titel:

se1111 schrieb:

Allerdings habe ich hier VC++ 6.0

Warum?

Unregistrierter

se1111 schrieb:

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 :rolleyes:

.