c++ Funktionen wollen nicht arbeiten

[devDevil]

Nun gut. string. Welchen meinst du? z.B. MFC implementiert seinen eigenen (vgl. CString). Wahrscheinlich meinst du aber den es C++-Standards. std::string im Header <string>.

String steht für Zeichenkette. Unter C war es ein einfacher C-Array mit Nullterminierungszeichen ('\0'). Unter C++ kümmert sich darum die Klasse std::string.

 byte

Das ist meist nichts anderes als ein unsigned char. Ich bezweifel mal das du eine Zeichenkette in ein einzellnes unsigned char bekommst

LPCSTR

long pointer const string. Ein Zeiger auf eine konstante Zeichenkette. D.h. ein Zeiger auf einen char-Array. Auch eher C

 

[random-access]

Wer blickt da noch durch was für was am besten ist?

Also wenn ich eine Zeichenkette gebrauche wo ich vorher schon weis dass sie niemals größer als X ist, benutze ich array's vom typ char(char Arrayname[Groesse]), wenn ich aber zum Beispiel eine Eingabe abfragen will, von der ich nicht genau weis wie groß sie ist, nehme ich std::string, weil es bereits jede menge Operationen zur verfügung stellt, und man nach einer kurzen .. ich nenn es mal "einarbeitungszeit" leicht damit hantieren kann.

greetz

 

[Wessy]

Nungut, das hört sich ja logisch an. Aber was wenn du z.B. eine Zeichenkette per cin in eine Variable packst und diese dann an eine Funktion (z.B. um sie in die Registrierung zu schreiben) und diese Funktion will zwingend den Typen lpcstr oder lpcwstr oder sonst was? Zumindest VC 2008 EE kann die Typen nicht konvertieren! Da ist doch Käse! Da macht das Programmieren doch gleich am Anfang schon keinen Spass mehr.

 

[random-access]

in c++ hast du ja die möglichkeit dir eigene Funktionen zu bauen,
wenn du also eine bestimmte aktion vor hast, und den rückgabewert weist, pack ihn einfach als parameter in deine Funktion.
wenn du zum beispiel einen string in ein array konvertieren willst kannst du dir eine Funktion schreiben, die etwa so aussieht:

char goArray(std::string stringsource, char *fillingarray){
	for(unsigned int i = 0; i < stringsource.length(); i++){
		fillingarray[i] = stringsource[i];
		/* PseudoCode
		wenn die größe von i die Größe des Arrays übersteigt,
		break;
                /PseudoCode */
	}
	return 0;
}

 

[devDevil]

Komplexe Objekte als Kopie zu übergeben ist Performanceverschwendung pur!

void goArray(std::string const& source, char* destination, const std::size_t max_length)
{
    const std:.string::size_type length(std::min<std::size_t>(source.length(), max_length));
    for (std::string::size_type i(0); i < length; ++i) destination[i] = source[i];
}

So wäre dein Code wohl nutzbar.

Aber schonmal was von der Funktion c_str von std::basic_string (d.h. auch von std::string) gehört?

Und wenn du nicht mit nem const char* auskommst (was fast immer ein Zeichen für schlechtes Klassendesign ist), nimm einfach:

std::vector<char> string(sample.begin(), sample.end());
char* ptr_string = &string[0];

... Bei einem Vector ist laut Std. sichergestellt, das die Daten direkt aneinander liegen.

 

[Wessy]

Hallo hallo,

hatte einige Zeit Probleme mit meiner Hardware, daher hats gedauert...

Durch eure Beispiele steig ich leider noch nicht wirklich durch. Noch zu hoch für mich. Habe jetzt einfach mal einen C++-Kurs angefangen und mit const char's und const wchar_t's rumgetestet. Damit komme ich nun (bislang) auch einigermaßen klar.


Aber: Was sollte man bevorzugen? Wenn ich es richtig verstehe ist wchar_t nur für z.B. chinesische Zeichen etc relevant Gibt es auch einen Nachteil bei wchar_t wie zum Beispiel Kompatiblität oder Geschwindigkeit bei der Verarbeitung?


Und vor allem, wenn ich per

    const char *Test1 = "frischer char String";
    const wchar_t *Test2 = L"frischer wchar String";

meine Strings zugewiesen habe, bekomme ich z.B. Test1 nicht in Test2 rein. Auch nicht per z.B.

Test2 = static_cast<const wchar_t *>(Test1);

Was ist denn da jetzt schon wieder im argen? PS.: Habe mir VC++ 6 SE *hust* besorgt.

 

[devDevil]

Jaaa das geht auch nicht

Mach mal größenvergleich sizeof(char) und sizeof(wchar_t)

Kannst es über std::codevct machen ... usw

const char reicht bei deutschen Programmen, ja.

 

[Kahino]

Vielleicht habe ich das ja falsch verstanden was gefragt ist, aber ist es nicht unnötig sich eine Konvertierungsfunktion für std::string zu c-string zu schreiben ?

Ich meine, wenn man schon std::string verwendet, kann man doch auch andere STL-Funktionen verwenden.
Beispiel:

std::string test1;

test1 = "lalahuptroet";

// Funktion die ein chararray bzw cstring erfordert
bloede_funktion( test1.c_str() );

Und sollen die strings Unicodefähig sein benutzt man halt nicht

std::string  sondern  std::wstring

Dann kann man auch chinesische Zeichen speichern.

Also falls das nicht ersichtlich ist, die Memberfunktion von String "c_str()" gibt die eigene Repräsentation als c-string zurück.

Als kleiner Tipp für die Zukunft, wenn du irgendwann auch mal <vector> / <map> und was es sonst noch so gibt verwenden möchtest, solltest du dir einfach mal ein wenig anschauen was die STL für Containerarten und "freie" algorithmen bietet

http://www.cplusplus.com/reference/
diese Seite ist z.B. ganz gut.
Einfach auf "stl container" oder "stl algorithmen" klicken um zu schauen was es so für funktionen gibt.


P.S.
Wenn man noch Anfänger ist machen einen diese Multibytezeichensätze bzw Unicodesachen nur Probleme.

 

[Wessy]

Erst einmal danke für eure Antworten. Wenn ich wieder am Rechner (also meinem) sitze dann schaue ich mir mal std::codevct genauer an. Das hört sich schon mal gut an.

Wenn ich es richtig verstehe, ist STL eine Möglichkeit auf 'vordefinierte' Funktionen und Methoden zuzugreifen welche einem natürlich viel arbeit abnehmen Davon wäre ich auf jeden Fall überzeugt. NUR: Ich kann nicht .NET Voraussetzen. Ich benötige nativen Win32-Code welcher auch auf einem nackten Win2000 mit ohne SP läuft. Nix Runtimes, nix .Net, nix ausser die reine Installation. Damit möchte ich mir nachträgliche 'oh ne, für das Programm brauchst noch die Datei und das Update und den Patch' ersparen

Und wenn ich mich jetzt nicht verlesen habe steht die STL, oder zumindest eine STL, nur über .NET zur Verfügung

Warum ich mich mit den String-Typen rumschlage? Mein Programm soll im Endeffekt verschiedene Funktionen bieten:
-mit einer noch zu schreibenden DLL für Verschlüsselung arbeiten
-UDP+TCP Pakete senden und empfangen
-die Windowsregistrierung lesen und schreiben (SZ,DWORD,MULTI_SZ,etc)
-einige Einstellungen von Windows bearbeiten, Sachen installieren/deinstallieren

Im Endeffekt baut ein Server (auch noch zu schreiben) eine Verbindung zu einer DB auf, ließt für den Client ein paar Informationen aus, sendet sie weiter und der Client setzt diese dann um. Mit VB ist dies fast alles schon umgesetzt.

Nun, glaub ich, benötigt der Funktionsaufruf für die Windowsregistrierung z.B. einen Parameter als char und einen als wchar_t oder aber z.B. der Funktionsaufruf für TCP/IP-Verbindungen benötigt char /wchar_t etc. Also muss ich hier doch flexibel zwischen den Typen konvertieren können.

PS.: Sag mal Kahino warum sitzt du denn morgens um 02:40h am PC?

 

[Kahino]

Also die STL hat nichts mit .NET zu tun, das ist zwar "nur" eine Funktionsbibliothek und gehört nicht zum Sprachumfang von C++, doch gehört sie durchaus in den c++ Standard (weswegen man die STL durchaus als zum Sprachumfang gehörend betrachten kann), was bedeutet, dass STL überall dort laufen muss wo auch C++ läuft ... genug Speicherplatz vorrausgesetzt (auf Mikrokontrollern ist also nicht so gut mit STL, nicht unbedingt).

Zudem verwendest du die STL ja schon längst in deinem Programm.

<string> / <iostream>

und mit "using namespace std;" machst du ja auch den kompletten Namensbereich der STL verfügbar.

Also kurz gesagt, das Zeug verwendest du schon längst und nackter gehts eigentlich gar nicht, ist alles (quasi) "nur" C++.

Und was das verpacken in die DLL angeht.
Ich hatte auch mal einen kurzen Exkurs in die DLL-Programmierung gemacht (kenne mich jedoch nicht sonderlich aus), doch wenn du jetzt schon Probleme hast mit den verschiedenen Stringtypen umzugehen und keine größere Tiefenkenntnis aufweisen kannst, wirst du da große Probleme bekommen sofern du das selbst machstt.
der std::string bzw std::wstring regelt das alles für dich, da brauch man nicht sonderlich aufzupassen.

Benutzt du die verschiedenen zeichentypen "roh", hast du dich eventuell mit Fehlern rumzuschlagen die keinen Sinn zu ergeben scheinen, die erst behebbar sind, wenn man sich wirklich gut mit Strings auskennt und besonders wie sie im Speicher abgelegt sind, verwendest du diese "normalen" stringtypen nämlich in einer DLL hast du dich mit verschiedenen Speichersegmenten zu beschäftigen.

Und warum ich so spät noch am PC bin?
Joar, Hatte vor kurzem erst meine letzte Abiturprüfung hinter mir und demnach nun etwas mehr Freizeit als zuvor.
Eigentlich wollte ich ein paar Informationen bezüglich den WINAPI "datei öffnen"-Dialog finden, da hatte ich gemerkt dass ich hier ja angemeldet bin oO seit sonem Jahr oder so.