Fun-Soft - Programmierforum

Autor

Thread - Seiten: > 1 <

000
17.12.2007, 12:07 Uhr
~Dirk3214
Gast

Hi!

Ich arbeite mit MSVC++ und habe zwei Konvertierungsprobleme. Intern behandle ich alle meine Zeichenfolgen als std::string um es einheitlich zu halten.

Jetzt liefert mir aber eine Methode die ich verwenden muss ein Byte-Array zurück, eine andere liefert wchar zurück. Wie kann ich diese beiden Typen in std::string konvertieren?

Ich arbeite nur mit ANSI.

Grüße, Dirk

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

001
17.12.2007, 16:23 Uhr
Kest
saint

Hi!

Kommt drauf an. Wenn es sich um einen C-String handelt

C++:

char* s1 =  "Hallo";
    char s2[] = "Bye";

    std::string str = s1;
    std::cout << str << '\t' << str.length() << std::endl;

    str = s2;
    std::cout << str << '\t' << str.length() << std::endl;

Wenn es aber ein >Byte-Array< ist

C++:

char s1[] = { 'H', 'a', 'l', 'l', 'o'};
    char s2[] = { 'B', 'y', 'e' };
    std::string str(s1, 5);
    std::cout << str << '\t' << str.length() << std::endl;

    str.assign(s2, 3);
    std::cout << str << '\t' << str.length() << std::endl;

Bei >wchar_t< (ich nehme an, dass du dich verschrieben hast) geht man genauso vor, außer dass man statt >std::string< >std::wstring< verwendet. Ein WideChar verwendet mehr als ein Byte, also nicht >std::cout< benutzen, sondern >std::wcout<< usw..
--
Wenn man einen Hufschlag hört, sollte man >Pferd< denken und nicht >Zebra<.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

002
17.12.2007, 23:21 Uhr
xXx
Devil

Ich denke mal das er von std::wstring nach std::string umwandeln will

Hab es bei mir noch nicht ganz fertig ... aber hier:

C++:

#include <locale>
#include <vector>
#include <string>

template<class dest_type, class source_type>
inline const std::basic_string<dest_type> char_cast(std::basic_string<source_type> const & source, std::locale const & loc = std::locale::classic())
{
    std::vector<dest_type> result (source.length(), 0);
    mbstate_t state;
    const source_type* ptr_source_next;
    dest_type* ptr_dest_next;
    std::use_facet<std::codecvt<dest_type, source_type, mbstate_t> >(loc).in(state, &source[0], &source[0] + source.length(),
        ptr_source_next, &result[0], &result[0] + result.size(), ptr_dest_next);
    return std::basic_string<dest_type>(&result[0], ptr_dest_next - &result[0]);
}

template<>
inline const std::basic_string<char> char_cast(std::basic_string<char> const & source, std::locale const &)
{ return source; }

template<>
inline const std::basic_string<wchar_t> char_cast(std::basic_string<wchar_t> const & source, std::locale const &)
{ return source; }

Vllt kann es 0xdeadbeefy oder so mal korrigieren, denn ich bin mir noch nicht 100%ig sicher bei dem Template ...

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

003
17.12.2007, 23:51 Uhr
0xdeadbeef
Gott
(Operator)

Die Konvertierung ist abhängig von der locale, also zum Beispiel

C++:

std::string narrow_wstring(std::wstring const &ws, std::locale const &loc) {
  std::string s(ws.size());

  for(std::size_t i = 0; i < ws.size(); ++i) {
   s[i] = std::use_facet<std::ctype<wchar_t> >(loc).narrow(ws[i]);
}

  return s;
}

xXxs Idee scheint da genereller einsetzbar zu sein, aber ich hab da nicht lange rumgewühlt. Was mir direkt auffällt, die Spezialisierung für gleiche Typen ließe sich einfacher als

C++:

template<typename t> t char_cast(t const &source, std::locale const &loc) { return source; }

umsetzen, damit haste gleich alles auf einmal erschlagen.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Dieser Post wurde am 17.12.2007 um 23:52 Uhr von 0xdeadbeef editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

Seiten: > 1 < [ C / C++ (ANSI-Standard) ]

ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: