dynamische variablen

hi,

in php gibts ne fette möglichkeit wo ich variablen aus strings erstellen kann.
gibts irgendwas in der art auch für c++?

verständlich dargstellt mein ich sowas:
string="eine_variable";
/* irgendwie nun umwandlen und datentyp definieren .. in diesem fall int */
eine_variable = 1;

ich bezweifel das es sowas in c++ gibt, aber ich frag lieber bevor ich hoffnung aufgebe

nman

Hm, sieht strange aus, aber wenn Du ein assoziatives Array erstellen willst schau Dir doch mal std::map an.
Oder hättest Du einfach gerne dynamisches Typing? *nichtauskenn*

Mis2com

Ich verstehe jetzt auch nicht, was du meinst.
Du solltest dich davon distanzieren, die Merkmale von anderen Sprachen nach C++ 1 zu 1 zu kopieren, so wie du in Englisch ja auch nicht sagst:
You're going on my nerves.
sondern dich an den Sprachstil anpasst.
Gib uns mal ein Beispiel, was du erreichen willst, vielleicht auch Kontext von dem Projekt, wo du es evtl. einbauen möchtest, dann können wir dir sagen, ob es nicht eine effizientere Möglichkeit in C++ gibt.

Wie nman schon sagte, kannst du eine Map erstellen, die zu einem String eine Variable hat, dies ginge allerdings, ohne Umwege, nicht mit jedem Typ.

Aber sag mal, wo du das anwenden möchtest...

MfG MAV

assoziatives arrays würden auch sehr gut passen .. in php ist das standard und kinderleicht zu managen .. in c++ noch nie gemacht, darum mal gesucht und hier einen einzigen beitrag dazu gefunden:

#include <map> 
#include <string> 
using namespace std; 

map<string,string> assoArray; 
assoArray["Irgendwas"]="Aha"; 
cout<<assoArray["Irgendwas"].c_str()<<endl; //->Aha

jedoch wenn ich das komplieren möchte kommt
"LINK : fatal error LNK1104: Datei "stlport_vc6_static.lib" kann nicht geoeffnet werden"
was muss ich tun?

also was will ich überhaupt:

ich will einen ordner durchgehen und alle dateien darin laden .. und um später auf die datei zugreifen zu können am besten den dateinamen der mir bekannt ist als ein assoziatives array nutzen und so kinderleicht ansprechen.

files["menu"] = datei_einlesen.. //menu.txt
files["config"] = datei_einlesen.. // config.dat

einlesen tu ich momentan so (code-snippet):

handle=_open(filename,_O_RDONLY);
filesize=_filelength(handle);
unsigned char *daten= (unsigned char*) malloc(filesize+1);
_read(handle,&daten[0],filesize);
_close(handle);

der inhalt der datei ist binär und keine textdatei.
ich spreche per memcpy dann den inhalt an:
memcpy(&var,&daten[46],7);
so tat ichs bisher .. über neue bessere und schnellere wege wäre ich begeistert.

kann mir bitte einer nen beispiel zeigen wie man jetzt das koppeln kann?
assoziatives array erstellen + binär inhalt einer datei übergeben und dann aus dem array daten auslesen?

wäre echt supi

*winke*

Artchi

Yo, std::map ist in diesem Fall dein Freund! Das was du ja eigentlich willst, ist eine zweispaltige Tabelle, gell? Ein Schlüssel und einen passenden Wert dazu. Das tägliche Geschäft in der EDV.

Zu dem Link-Error: du scheinst den STL-Port benutzen zu wollen, ohne ihn zu haben? Zumindest findet dein Linker die Lib nicht. Normalerweise hat VC schon eine STL dabei, nicht aber den STL-Port.

Schau mal in deine Projekteinstellungen, ob du die Librarie eingetragen hast. Entweder den richtigen Pfad angeben, oder rausschmeissen.

Artchi

malloc und Konsorten solltest du in C++ unterlassen, das ist doch C. Benutze am besten das Schlüsselwort new um Speicher anzufordern.

Hier mal ein Anhaltspunkt, wie du das Prob lösen könntest:

class Daten
{
private:
    unsigned char *binData;
    unsigned long binSize;
public:
    void createBinData(std::string filename);
    // etc. noch die nötigen Methoden für die Members
};

std::map<*std::string, *Daten>

Jetzt kannst du als Schlüssel einen String ablegen, und passend dazu ein Daten-Objekt. Du kannst dann binData nach belieben mit Daten füllen. Alles schön gekapselt über Methoden-Aufrufe der Klasse Daten.

bin wohl eher noch nen c progger

habs vergessen zu schreiben .. das mit stlport ist erledigt.

@Artchi

wieso "void createBinData(std::string filename);" ?
ich mein .. ich muss es dann extra wieder per .c_str() umwandeln ..
warum will niemand normal "char" machen?

dummerweise find ich meine msdn cds nicht wieder .. gestern abend überall gesucht .. vom erdboden verschluckt und mit 56K modem im inet was suchen ist nen kreuz :(:(

deshalb würd ich gerne weiter mit fragen nerven
könntest nicht eventuell die 5 zeilen code aufschreiben, wie ich jetzt das ganze übergebe? ich peil map noch nicht ganz .. schon mit google versucht mir erleuchtung zu bringen .. aber es wollte nicht
map<int, string> bzw map<string, long> etc verstehe nicht wozu was steht etc ..

ich habe jetzt:
den dateinamen ohne typ => "config" // config.dat
die daten binär geladen => daten

und will dann zum schluss so arbeiten
memcpy(&var, &global["config"][46],7); // ab position 46, 7 bytes in var ablegen.

wie bekomme ich jetzt das global["config"] erzeugt und die "daten" dort rein.

sorry wenn ich mich zu dumm anstelle .. habt mitleid

ich glaub google hat mir eben doch geholfen

map<string, int>
"string" steht für den inhalt im array => global["text"]
und "int" steht für den datenwert den es aufnehmen soll => global["text"] = 1
stimmt das so?

aber irgendwie bekomme ich das trotzdem nicht ganz hin

unsigned char* binData= (unsigned char*) malloc(filesize+1); //inwiefern wäre denn hier new angebrachter?
map<string, unsigned char> assoArray;
assoArray["text"]=binData; // hier sagt er error => 'unsigned char *' kann nicht in 'unsigned char' konvertiert werden

Artchi

Bin zur Zeit auf Arbeit und kann deshalb aus zeitlichen Gründen keine kompletten Lösungsansätze liefern... wenn ich zu Hause bin, kann ich umfangreicher aushelfen.

void createBinData(std::string filename);

Aber erstmal soviel: eigentlich sind einfache Arrays unter C++ böse bzw. schmutzig, da sie Fehleranfällig sind (du kanns über das Array hinaus schreiben usw., obwohl das nicht sein darf). Dafür hat man ja Objekte, die alles kapseln und die Zugriffe überprüfen.

std::string hat intern auch ein char-Array, aber das siehst du nicht. Wenn der Filename 20 Zeichen lang ist, und du erweiterst diesen um 5 Zeichen, macht std::string für dich die vergößerung des Arrays, ohne das du dich drum kümmern mußt. Genau das gleiche wenn du Zeichen abschneidest oder einfach lesen willst. Du wirst nicht so einfach Zeichen-Position 100 lesen können, wenn der Filename nur 20 Zeichen lang ist.

Deshalb sollte man immer std::string anstatt char* benutzen. Sonst kann man auch gleich C programmieren und brauch kein C++.

Bei string sind auch die Operatoren überladen, so das du es wie char* behandeln kannst:

string str10 = "abcdefghi";
char ch = str10[3];
cout << ch << endl; // 'd'
str10[5] = 'X';
cout << str10 << endl; // "abcdeXghi"

Und das MIT Zugriffsüberprüfung die du bei einem char* nicht hast. Wenn du bei obigen Beispiel str10[88] machst (wenn es ein char* wäre!), bekommst du einen Wert zurück der Müll ist. Bei string bekommst du eine Exception geworfen und weißt, das was nicht i.O. ist.

Auch unsigned char* ist eigentlich nicht gut, was ich da oben gemacht habe. Man kannst mit std::vector noch einfacher haben.

fänd ich sehr nett wenn mir helfen könntest ..

ich glaube es hinbekommen zu haben
danke für deine hilfe .. falls was is meld ich mich wieder *grins*

jetzt habe ich doch ne frage *muh*

struct sFile 
{ 
    unsigned long filesize; 
    unsigned char *daten;
};

statt unsigned char, soll da das sFile rein.

map<string, [b]unsigned char[/b]> data;

und ich möchte es nun definieren und mit daten füllen

//unsigned char *daten = (unsigned char*) malloc(filesize+1);
unsigned char *daten =  new unsigned char[filesize];

_read(handle,&daten[0],filesize);

ohne die struct geht alles .. aber ich möchte ja mehrere dateien so mit den binärdaten und dateigrösse ablegen und aufrufen können .. help me

kaum gepostet, schon antwort selber gefunden .. irgendwie peinlich solche selbstgespräche

Artchi

Ja, manchmal hilft etwas rumprobieren.

Aber noch ein Tip, für schöneres C++. Das new kannst du sogar ganz weglassen, wenn du std::vector benutzt. Das ist ein dynamisches Array, da mußt du dich wie bei std::string um nichts kümmern.

std::vector<unsigned char> daten(filesize); //Reserviert gleich ein Array in der Größe filesize

Kannst du wie ein normales Array behandeln, mit dem Vorteil, das du es nachträglich in der Größe ändern kannst. Bei Zugriff über []-Operator gibts nicht mal Performance-Verlust, gegenüber einem normalen Array!

daten.push_back(12); //erhöht die Arraygröße autom. um 1 und hängt 12 an
daten.size(); //gibt die größe des Array zurück
daten[1] = 13; // setzt an Pos 1 ein 13 ein
unsigned char b = daten[1];
daten.clear(); // löscht den Array-Inhalt, size = 0

// gibt noch mehr Methoden zu vector!

Kauf dir ein Buch über die STL, da steht alles drin was man zum vernünftigen C++ coden braucht.

vielen dank für deine hilfe .. werds mal mit vector probieren