Ich bin im addressraum des Programs und habe ein gefüllten Struct!

diesem Struct hat ein char[28] als member und er füllt sich auch meistens mit dem erforderlichen String! Jedoch wenn der String länger als 15 Zeichen ist ist anstelle des Strings ein pointer auf den string gegeben! Ich habe schon alles mögliche probiert um es zu filtern! evtl hat ja einer von euch eine Idee!

struct bla
{
   ...    
   char[28] Name;
   ...
};

bla sBla;
PCHAR pName;

// also ich wil hier zuerst mal überprüfen das wenn es ein pointer ist den inhalt des pointers überprüfen ob er null ist

if ((PCHAR)*(sBla.Name[0]))
  pName = *(sBla.Name[0])
else
  pName = sBla.Name;

bei den meisten versuchen mittels & und * erhalte ich entweder den verkrüppelten string oder einen fehler! ich weis wirklich nicht weiter! kann mir einer helfen bitte?

Vielen Dank im voraus!

Machst du "Name = "neuer String"?

Vielleicht würde es dann schon helfen wenn du einfach die Funktion strcpy nutzt!

Viele Grüße
Andreas

The-Kenny schrieb:

Eine andere Möglicheit wäre auch std::string...

meinst du ich sollte dem struct anstatt char[28] lieber string zuweisen? oder auf was beziehst du deine antwort

Ich hatte nur früher folgenden Fehler gemacht

char testString[256];
testString = "hallo";

oder

char* testString = "hallo1";
char* testString2 = testString;

wenn ich jetzt testString manipuliere, verändere ich auch gleichzeitig testString2

Ich programmier noch nicht so lange c++, aber vielleicht wäre das ja die Ursache einer deiner Probleme gewesen.

Viele Grüße
Andreas

The-Kenny schrieb:

Eine andere Möglicheit wäre auch std::string...

meinst du ich sollte dem struct anstatt char[28] lieber string zuweisen?

Na, verwende halt statt des Char-Arrays die std::string-Klasse.

diesem Struct hat ein char[28] als member und er füllt sich auch meistens mit dem erforderlichen String! Jedoch wenn der String länger als 15 Zeichen ist ist anstelle des Strings ein pointer auf den string gegeben!

Wo kriegst du denn dann den Pointer her, bzw wie ist der denn gegeben? Generell würde ich sagen (und das scheint ja auch dein Ansatz zu sein), dass du prüfst ob der Zeiger NULL ist; wenn ja, dann ist deine Zeichenkette wohl in dem char[28], wenn nicht, dann zeigt der Zeiger auf die Zeichenkette.
Wenn ich dich richtig verstanden habe, bekommst du ja durch irgendeine Schnittstelle den char[28] gefüllt oder eben einen Pointer. Steht vielleicht in der Beschreibung der Schnittstelle etwas dazu?
Und wenn du dann ermittelt hast, was von beiden den String enthält, würde ich ihn einer std::string-Variable zuweisen, also in etwa so:

string fertiger_string;

char str1[28];
char* str2;
// Austauschen mit der Schnittstelle, entweder str2 oder der Inhalt von str1 ist gültig

if ( str2 )
    fertiger_string = str2;
else
    fertiger_string = str1;

also ich hab mal versucht den char in dem struct umzuwandeln in ein string da mir das hier jemand geraten hat und habe dann da ich komplett nur mit char und nicht mit string arbeite den inhalt probiert umzuwandeln!

Allerding kamen immer noch verkrüppelte zeichen raus!

struct bla
{
   ...    
   string Name;
   ...
};

bla sBla;
char pName[50]; //50 Zeichen sind völlig ausreichend für mich

strcpy(pName,sBla.Name.c_str());

Als ausgabe bekam ich aber jetzt die zeichenkette ab dem 5 Zeichen und wenn ein pointer gegeben ist kamen wieder irgendwelche ascii zeichen raus
Jetzt meine frage stimmt es denn überhaupt das ein string wenn der Inhalt größer als 15 Zeichen ist ihn als pointer speichert? Der Typ string hat ja auch 28 Bytes zur verfügung also war es für den struct schon mal nicht verkehrt!
aber die funktionsweise kenn ich nicht und weis auch nicht ob ich ihn korrekt umgewandelt habe

Ich nehme an, die Struktur 'bla' mit dem Namen ist nicht von dir.
Aber anhand dieses Eintrags kann man es nicht herausfinden, sondern es muß in der Struktur noch ein anderes Member vom Typ 'char *' vorhanden sein. Dieser kann dann auf 0 (NULL) geprüft werden (oder aber ein zusätzliches Member mit der Länge des Strings).

class CString
{
//28 Bytes werden im speicher für den string typ belegt
//wenn der inhalt > 15 Zeichen ist wird der inhalt woanders gespeichert und der
//char* zeigt auf den Inhalt andernfalls ist der inhalt direkt ab anfang gespeichert
public: 
	//String typecast
	char* value;		//0000
	char unknown0[12];
	int size;		// 0010
	char unknown1[8];
};

jetzt habe ich meinen struct entsprechend geändert

struct bla
{
   ...    
   CString Name;
   ...
};

bla sBla;
char pName[50]; //50 Zeichen sind völlig ausreichend für mich

Auslesen tue ich den jeweiligen Inhalt folgendermaßen!

if (sBla.Name.size > 15)
    strcpy_s(pName,50,sBla.Name.value);
else
    strcpy_s(pName,50,(PCHAR)&sBla.name);

Diese Lösung ist für mich völlig ausreichend und funktioniert einwandfrei

struct bla
{
   // …    
   std::tring Name;
   // …
};

bla sBla;
std::string name = "Ich bin der Max";
sBla.Name = name;