Bedanke mich im Vorraus

mit Gruß

hewi

Die Lösung für das was du machen willst ist sehr wahrscheinlich einer der folgenden Begriffe (zum Selbstnachlesen):

1. STL-Container, insbesondere std::map und std::vector
2. Arrays
3. Templatespezialisierung

Wie kann ich nun eine Variable erstellen, die den Namen Muster_3_4_5 trägt?

Garnicht.

Wie kann man prüfen, ob diese Variable bereits existiert?

Garnicht.

Bedanke mich im v******

Gern

#define VAR(NAME, N1, N2)  NAME ## _ ## N1 ## _ ## N2

int VAR(Muster, 3, 4) = 2;

Allerdings natürlich völlig sinnfrei.

Wie kann ich nun eine Variable erstellen, die den Namen Muster_3_4_5 trägt?
Wie kann man prüfen, ob diese Variable bereits existiert?

int Muster_3_4_5;

strg+f -> "Muster_3_4_5"

...

Vielleicht beschreibst du lieber einmal, was das Ziel davon sein soll. Dann könnte man dir mit Sicherheit sinnvolle Alternativen nennen.

Zum Problem:
Ich würde im Prinzip gern ein Array generieren mit 10 hoch 10
(oder mehr) Elementen - das ist ein bisschen viel.
Von den vielen Elementen werden nur etwa 8 Tausend mit Werten gefüllt.
Es wäre daher evt. sinnvoll nur die gefüllten Variablen zu generieren.

mfg

hewi

Aber nur ein Array mit 8000 Werten zu erstellen ist wohl zu einfach?

Es wäre daher evt. sinnvoll nur die gefüllten Variablen zu generieren.

Ehm, ja, aber ... wieso brauchst du mehr Variablen, wenn du sie gar nicht benötigst? Und wieso erstellst du dir dann nicht ein Array mit 8'000 Elementen? Also bei mir herrscht nun völlige Verwirrung, was du tun willst ...

Grüssli

Edit: Ok, dann bleibt das 10¹⁰ unter uns.

Dieser Off-Topic Beitrag muss nun noch sein:
LoL, danke. Als ich auf "Absenden" gedrückt habe, ist es mir aufgefallen, Beitrag editieren geht aber zum Teil so lange, 44 Sekunden, aber der Nexus hat es natürlich gesehen, mist ...

Grüssli

std::map<int, int> m;
m[1] = 123;
m[100000] = 5;
// ... 8000 werte an beliebigen positionen (mit beliebigen keys)

int i = m[100000]; // holt die 5 wieder raus

Als Key musst du dabei nicht einen Integer verwenden:

std::map<boost::tuble<int, int, int>, int> m;
m[boost::make_tuple(1, 2, 3)] = 123;
m[boost::make_tuple(1000, 12, 10101013)] = 666;
// ...

(Als Wert kannst du natürlich auch nehmen was du willst (fast))

Ich würde im Prinzip gern ein Array generieren mit 10 hoch 10
(oder mehr) Elementen - das ist ein bisschen viel.
Von den vielen Elementen werden nur etwa 8 Tausend mit Werten gefüllt.

Wenn ich es aber richtig sehe hast du eine Koordinatenangabe, und du hast du nur eine grobe Angabe dafür wie viele Plätze du tatsächlich brauchst.

Es gibt mehrere mögliche Lösungsansätze, eine davon wäre die Verwendung einer Struktur mit den Koordinatenangaben und dem Wert (und dies dann beispielsweise in einen std::vector abzulegen). Ein anderer Wäre die Angaben voneinander zu trennen (Schlüssel [Koordinate] / Wert und std::map verwenden)...

Einfaches Beispiel:

#include <vector>

struct Foo{
   int x;
   int y;
   int z;
   int value;

   Foo(int x=0, int y=0, int z=0, int value=0)
   : x(x), y(y), z(z), value(value)
   {}
};

int main()
{
  std::vector<Foo> foos;
  foos.reserve(10000); // Wenn du weißt, wieviele Elemente ca. zu erwarten sind.

  foos.push_back(Foo(0,0,1,4));
  foos.push_back(Foo(0,1,3,8));
  foos.push_back(Foo(1,1,2,12));
  foos.push_back(Foo(2,1,1,16));
  foos.push_back(Foo(3,3,3,20));
  //...
}

Die Struktur braucht zwar mehr Speicher als nur ein Wert, aber mit Sicherheit ist bei dir 8000 x Strukturgröße geringer als 10^10 x Wertgröße.

@hewi: nimm eine map oder hash_map.

Aber aufpassen:

int i = m[100000]; // holt die 5 wieder raus

Falls hier der Eintrag an der Position 100000 nicht existiert, wird dieser angelegt! (über find usw. lässt sich dies aber vermeiden).

Aber wenn ich es richtig verstanden habe, kann man die Namen einer
Variablen (Muster_x_y_z...) nicht durch den Progrmmablauf bestimen?

mfg

hewi

hustbaer schrieb:

@hewi: nimm eine map oder hash_map.

Aber aufpassen:

int i = m[100000]; // holt die 5 wieder raus

Falls hier der Eintrag an der Position 100000 nicht existiert, wird dieser angelegt! (über find usw. lässt sich dies aber vermeiden).

Jo ich weiss

blub

Ja. Verwende bitte eine map. Hab ich schon geschrieben. Aber erklärs ruhig noch 2x, ich schreib dir dann noch 2x dasselbe, ne?

Aber wenn ich es richtig verstanden habe, kann man die Namen einer
Variablen (Muster_x_y_z...) nicht durch den Progrmmablauf bestimen?

Wow, da hast du jetzt garnicht lange gebraucht um das zu überzuckern.

Vielen Dank für Eure Mühe

mfg

hewi

Leider bin ich kein Programmierer und weiß daher im Moment noch nicht was ein
map oder hush_map ist.

http://www.cplusplus.com/reference/stl/map/

Allerdings solltest du in jedem vernünftigen C++ Buch davon erfahren, weil es Teil der Standardbibliothek von C++ ist.

hewi schrieb:

Kann man vorher abprüfen, ob das Element schon angelegt ist.

Mit:
http://www.cplusplus.com/reference/stl/map/count/

Oder:
http://www.cplusplus.com/reference/stl/map/find/

Mit der hash_map aus dem TR1 von C++ habe ich noch nicht gearbeitet und da kenn ich auch keine Referenz dazu.

Für allgemeine Erklärungen was eine Map oder Hashmap ist, kann man Wikipedia konsultieren. Eine Map ist meistens als Baum implementiert:
http://de.wikipedia.org/wiki/Baum_(Graphentheorie)

Eine Hashmap heisst auf Deutsch meistens Hashtabelle:
http://de.wikipedia.org/wiki/Hashtabelle

Grüssli

Läuft der Vorschlag von asc mit dem Vector auf was anderes hinaus?

Jopp. Bei einem Vektor gibt's immer eine bestimmte Anzahl an Elementen, und die sind der Reihe nach durchnummeriert. D.h. das erste Element spricht man über [0] an, das zweite über [1] und das letzte über [N-1] (bei N Elementen). Bei einer map (auch als Dictionary bekannt), kannst du beliebige "Indizes" verwenden. D.h. du kannst sagen nur bei "Index" 0, 7 und 1000 gibt's ein Element, sonst nirgends. Dann existieren auch nur diese drei Elemente, "dazwischen" ist dann nichts. Den "Index" nennt man dabei üblicherweise "key" (Schlüssel), und das Element wird als "value" (Wert) bezeichnet.

Kann man vorher abprüfen, ob das Element schon angelegt ist.

Ja, kann man.

wenn also durch den Programm-Ablauf die Variablen folgende Werte erhalten:
cc=3, hh=4, ll=5 (die Werte können zwischen 0 und 9 schwanken) kann man
mit dem map folgende Variable m[345] anlegen und füllen.
In der richtigen Anwendung wäre es dann m[123456789...].
Wenn man dann nur 8000 Werte hat belastet das dann den Speicher nur mit den 8000 Werten? Das wäre dann schon gut.

Über die Vereinbarung
---------------------------------------------------------
C/C++ Code:
std::map<int, int> m;
m[1] = 123;
m[100000] = 5;
// ... 8000 werte an beliebigen positionen (mit beliebigen keys)

int i = m[100000]; // holt die 5 wieder raus

Als Key musst du dabei nicht einen Integer verwenden:
C/C++ Code:
std::map<boost::tuble<int, int, int>, int> m;
m[boost::make_tuple(1, 2, 3)] = 123;
m[boost::make_tuple(1000, 12, 10101013)] = 666;
// ...
C/C++ Code:
std::map<boost::tuble<int, int, int>, int> m;
m[boost::make_tuple(1, 2, 3)] = 123;
m[boost::make_tuple(1000, 12, 10101013)] = 666;
// ...
C/C++ Code:
std::map<boost::tuble<int, int, int>, int> m;
m[boost::make_tuple(1, 2, 3)] = 123;
m[boost::make_tuple(1000, 12, 10101013)] = 666;
// ...
-------------------------------------------------------------
muß ich mir jetzt noch Gedanken machen - hab ich noch nie gesehen

Mit bestem Gruß

hewi

Wenn man dann nur 8000 Werte hat belastet das dann den Speicher nur mit den 8000 Werten? Das wäre dann schon gut.

Das ist etwas vom Container abhängig, aber im wesentlichen kannst du annehmen das der Overhead im Verhältnis eher gering ist.

cu André