Dynamische Strings

Kaladial

hi

hab da ma nen problem:
ich hab nen bild : 1024*768 graustufen
ich will nun jedes pixel auslesen und deren grauwert als hexwert-farbwert(#xxxxxx) in einem string abspeichern also "#xxxxxx #xxxxxx"

diesen string will ich dann an einen char* übergeben

irgendwie macht er die convertierung net...
also ich bekomm den string schon zusammen (teilweise auch sehr langsam aber naja dazu kommen wir viellicht später) nur wenn ich den dann meinem char* übergeben will bekomm ich imemr die fehlermeldung das das net geht weil mein string vom typ const char* sei und ich das char* net übergeben kann ...

wie kann ich das lösen?

mfg Kaladial

MrGentleman

hmm....das heißt, du hast nen std::string mit dem farbwert, weiterverarbeiten willst du den string dann als char* und du willst das const wegbekommen - seh ich das richtig?

std::string test("hallo");
char* pString = (char*)test.c_str(); // einfacher C-Cast
std::cout<< pString;

lg, MrGentleman

MrGentleman schrieb:

hmm....das heißt, du hast nen std::string mit dem farbwert, weiterverarbeiten willst du den string dann als char* und du willst das const wegbekommen - seh ich das richtig?
std::string test("hallo");
char* pString = (char*)test.c_str(); // einfacher C-Cast
std::cout<< pString;
lg, MrGentleman

Ouch, was wird das denn? Wenn überhaupt, dann const_cast<char*>.
Zuallererst sollte man aber gucken, ob man den Parameter nicht einfach als const char* deklariert. Wenn man das nicht kann, dann umkopieren, außer, man kann sich sicher sein, dass die (fremde) Funktion den char* nicht verändert, dann eventuell const_cast, weil die Menschheit zu schlecht ist, um const-Korrektheit einzuhalten.

JimmydaMage

Wenn du C++ benutzt, und davon geh ich aus, da du im C++ Forum postest, benutz doch bitte std::string, macht das Leben echt leichter:

//rgb zu Hex-Konvertierung
#include <sstream>
#include <string>

...
std::ostringstrean hex_stream;
hex_stream << "#" << std::hex << r << g << b;
std::string hex_string = hex_stream.str();

//Falls du wirklich eine Übergabe als char* brauchst:
myfunction(hex_string.c_str());
...

Natürlich kannst du einen const char* keinem char* zuweisen, da const char* bedeutet, dass der String nicht verändert werden darf, während das bei char* eben nicht ausgeschlossen ist... Falls du dir sicher bist, dass (ich geh mal davon aus, du möchtest an eine Funktion übergeben) die Funktion den String nicht verändert, kannst du eine Übergabe mit const_cast<> erzwingen

void myfunction(char* str);
...
const char my_string[] = "Hallo Welt!";
myfunction(const_cast<char*>(my_string));

Grüße,

Martin

Kaladial

thx jo geht

Simon2

MrGentleman schrieb:

...

std::string test("hallo");
char* pString = (char*)test.c_str(); // einfacher C-Cast
std::cout<< pString;

...

Besser:

// Vorgegebene Funktionen
void f_const_char(char const* p);
void f_char(char * p);

// "Kopien-Halter"-Hilfsklasse
class stringCpyHolder {
   vector<char> vec;
   string& str;
public:
   stringCpyHolder(string& s) :  str(s)
   { 
      copy(str.begin(), str.end(), back_inserter(vec));
      vec.push_back('\0');
   }
   operator char*() { return &vec[0]; }
   ~stringCpyHolder() {
      str.clear();
      copy(vec.begin(), vec.end()-1, back_inserter(str));
   }
};

int main() {
   string test("hallo");
   // ..
   // Eine Menge komfortables und sicheres Arbeiten mit test
   // ..

   // easy
   f_const_char(test.c_str());

   {
      stringCpyHolder holder(test);
      f_char(holder);
   }
   cout << "-> test:" << test << "\n";

   return 0;
}

Man spart sich die Speicherverwaltung mit dem vector ganz.
Man kann da noch verschiedene Varianten bauen (z.B. "zurückkopieren" nur, wenn "operator char*()" überhaupt aufgerufen wurde.)
Wenn einem der Sinn danach steht, kann man auch eine "Proxy-Funktion" drumherumschreiben ... muss das dann aber für jede Funktion tun (ist dafür aber sicher, dass man den string erst nach dem Zurückkopieren wieder anfasst)

EDIT: Aus historischen Gründen:
Ich meine, dass die "Zusicherungen von vector" das hergeben.

Gruß,

Simon2.

LordJaxom

Simon2 schrieb:

Ich meine, dass die "Zusicherungen von vector" das hergeben.

Da das Thema in letzter Zeit häufiger vorkommt: Ja, diese Zusicherungen wurden im 2003er Standard ergänzt.

camper schrieb:

Für vector steht es explicit da 23.2.4/1
Zitat:

The elements of a vector are stored contiguously, meaning that if v is a vector<T, Allocator> where T is some type other than bool, then it obeys the identity &v[n] == &v[0] + n for all 0 <= n < v.size().

Für basic_string existiert keine solche Passage an entsprechender Stelle.

http://www.c-plusplus.net/forum/viewtopic-var-p-is-1327791.html#1327791

Simon2

LordJaxom schrieb:

Simon2 schrieb:

Ich meine, dass die "Zusicherungen von vector" das hergeben.

Da das Thema in letzter Zeit häufiger vorkommt: Ja, diese Zusicherungen wurden im 2003er Standard ergänzt. ...

Danke !!
Dann werde ich in Zukunft den 2. Weg wählen.

Gruß,

Simon2.