Bei std::string gibt es den Konstruktor:

template<class InputIterator> string (InputIterator begin, InputIterator end)

Den wollt ich mal ausprobieren. Ich hab zum beispiel versucht:

#include<string>
#include<iostream>

int main(int argc,char **argv)
{
	wchar_t *wcp=L"hallo!\n";

	std::string s<wchar_t*>(wcp,wcp+7);

	std::cout<<s;
}

Funktioniert natürlich nicht.

Kann mir jemand sagen wo ich

<wchar_t>

hinschreiben muss?
Vielen Dank!

template<class InputIterator> string (InputIterator begin, InputIterator end)

Geht nicht, mit dem da:

wchar_t *wcp=L"hallo!\n";
std::string s(wcp, wcp + 7);

Grund, std::string ist für char da.

Richtig wäre:

std::wstring str(L"Hallo!\n");

Und wenn du diesen speziellen Konstruktor verwenden willst, dann so:

wchar_t const* w = L"Hallo!\n";
std::wstring str(w, w + 8); // Kopie von [0, 8[

Oder mit normalen chars

char const* c = "Hallo!\n";
std::string str(c, c + 8);

Oder mit einem Vektor:

std::vector<char> vec(10, h);
std::string str(vec.begin(), vec.end());

Die Templateparameter werden automatisch deduziert beim Aufruf einer Templatefunktion (wozu auch der Konstruktor gehört). Nur wenn die Deduktion nicht eindeutig ist oder man eine Klasse vorliegen hat, muss man die Templateparameter angeben.

Grüssli

PS: Templategrundlagen durchlesen!

Ich hatte gedacht man müsste das <wchar_t> hinschreiben.
Aber

#include<string>
#include<iostream>

int main(int argc,char **argv)
{
    wchar_t *wcp=L"hallo!\n";

    std::string s(wcp,wcp+7);

    std::cout<<s;
}

funktioniert (zumindest bei mir)
Ausgabe ist wie gewolt

blabla> ./testprogramm
hallo!

Das ist ja gerade was ich wollte:
Jeden einzelnen wchar_t in einen char casten.

Danke!

Ich hatte gedacht man müsste das <wchar_t> hinschreiben.
Aber

#include<string>
#include<iostream>

int main(int argc,char **argv)
{
    wchar_t *wcp=L"hallo!\n";

    std::string s(wcp,wcp+7);

    std::cout<<s;
}

funktioniert (zumindest bei mir)
Ausgabe ist wie gewolt

blabla> ./testprogramm
hallo!

Das ist ja gerade was ich wollte:
Jeden einzelnen wchar_t in einen char casten.

Das wird aber ÄUSSERST GEFÄHRLICH!
Führ mal den folgenden Code aus, dann verstehst du, was ich meine.

#include <string>
#include <iostream>

int main()
{
  wchar_t const* w = L"äöü";
  std::string str(w, w + 3);

  std::cout << str << std::endl;

  return 0;
}

Grüssli

Stimmt. Da kommt nur Mist bei raus.
War auch ein doofes Beispiel von mir. Eine Konvertierung von char nach wchar_t währe warscheinlich sinnvoller und ungefährlicher gewesen,

Ungefährlicher, aber nicht gefahrlos. Solche Konvertierungen von Zeichen sollten, wenn möglich, immer über Locales geschehen:

std::string -> std::wstring

std::wstring to_wstring(std::string const& str, std::locale const& loc = std::locale())
{
	std::ctype<wchar_t> const& ct = std::use_facet<std::ctype<wchar_t> >(loc);
	std::vector<wchar_t> buffer(str.length());

	ct.widen(str.data(), str.data() + str.length(), &buffer[0]);
	return std::wstring(&buffer[0], buffer.size());
}

std::wstring -> std::string

std::string to_string(std::wstring const& wstr, char defaultChar, std::locale const& loc = std::locale())
{
	std::ctype<wchar_t> const& ct = std::use_facet<std::ctype<wchar_t> >(loc);
	std::vector<char> buffer(wstr.length());

	ct.narrow(wstr.data(), wstr.data() + wstr.length(), defaultChar, &buffer[0]);
	return std::string(&buffer[0], buffer.size());
}

Grüssli