gibt es so eine art UNICODE-Cast in C++?

Ich möchte meine Programme in ANSI und in UNICODE-Varianten veröffentlichen, dafür habe ich nun sehr viel mit einem eigenen TEXT-Makro gearbeitet und es funktioniert auch alles einwandfrei!

Jedoch gibt es diverse Funktionen die einen char* erwarten und andere wiederum umbedingt einen wchar_t*

jetzt dachte ich mir, da müsste es doch evtl sowas geben?

dest_datentyp test = uni_cast<dest_datentyp>(source_datentyp);

Gibt es da soetwas das genau so aufgebaut ist wie die anderen C++ casts? ich habe von Templatedesign leider nicht sehr viel ahnung

Es gibt was zum konvertieren:

#include <iostream>
#include <locale>
int main()
{
  char str[100] = "Hello World";
  wchar_t wstr[100];
  std::use_facet< std::ctype<wchar_t> >( std::locale("C") ).widen(str,str+100,wstr);
  std::wcout << wstr << std::endl;
}

// Edit: Fixed Typo

#include <locale>
#include <string>

#include <boost/type_traits.hpp>
namespace utility{
	namespace privat{
    //the class Converter chooses the right function whhich does the conversion
		//there are 5 cases which have to be handled different:
		//
		//Type->AnotherType first uses narrow than widden, dataloss can occur
		//Type->char uses narrow
		//char->Type uses widden
		//char->char no conversion
		//Type->Type no conversion

		//conversion type->type
		template<class To,class From>
		struct Converter{

			static std::basic_string<To> convert(const std::basic_string<From>& input){
				return Converter<To,char>::convert(Converter<char,From>::convert(input));
			}

			static To convertChar(From input){
				return Converter<To,char>::convertChar(Converter<char,From>::convertChar(input));
			}
		};

		//conversion char->type
		template<class To>
		struct Converter<To,char>{
			static std::basic_string<To> convert(const std::string& input){
				To* widen = new To[input.size()];

				std::use_facet<std::ctype<To> > (std::locale()).widen(&*input.begin(), &*input.end(), widen);

				std::basic_string<To> output(widen);
				delete[] widen;

				return output;
			}
			static To convertChar(char input){
				return std::use_facet<std::ctype<To> > (std::locale()).widen(input);
			}
		};

		//conversion type->char
		template<class From>
		struct Converter<char,From>{
			static std::string convert(const std::basic_string<From>& input){
				char* narrow = new char[input.size()];

				std::use_facet<std::ctype<From> > (std::locale()).narrow(&*input.begin(), &*input.end(), narrow);

				std::string output(narrow);
				delete[] narrow;

				return output;
			}
			static char convertChar(From input){
				return std::use_facet<std::ctype<From> > (std::locale()).narrow(input);
			}
		};

		//when both types are the same, no conversion is needed
		template<class Char>
		struct Converter<Char,Char>{
			static const std::basic_string<Char>& convert(const std::basic_string<Char>& input){
				return input;
			}
			static Char convertChar(Char input){
				return input;
			}
		};
		//specialisation for <char,char> prevents ambigouity
		template<> struct Converter<char,char>{
			static const std::basic_string<char>& convert(const std::basic_string<char>& input){
				return input;
			}
			static char convertChar(char input){
				return input;
			}
		};

		//ConvertHelper has to differ between the 4 possible forms of the
		//template paramter "from": single sign,pointer,basic_string and char array.
		//Function templates doesnt work here because the compiler cannot
		//differ between them

		//when From is a pointer(cstring),it must be converted into a string
		template<class To,class From,bool>
		struct ConvertHelper{
			typedef std::basic_string<To> returnType;

			static returnType convert(From input){
				//get the unqualified nonpointer type 
				//example const char*->char
				//this is needed for basic_string
				typedef 
				typename boost::remove_const<
					typename boost::remove_pointer<
						typename boost::remove_const<From>::type
					>::type
				>::type InnerFrom;

				std::basic_string<InnerFrom> str(input);

				return Converter<To,InnerFrom>::convert(str);
			}				
		};

		//From is a normal char
		template<class To,class From>
		struct ConvertHelper<To,From,false>{

			typedef To returnType;

			static returnType convert(From str){
				return Converter<To,From>::convertChar(str);
			}				
		};

		//From is a std::basic_string
		template<class To,class From>
		struct ConvertHelper<To,std::basic_string<From>,false>{

			typedef std::basic_string<To> returnType; 

			static returnType convert(const std::basic_string<From>& str){
				return Converter<To,From>::convert(str);
			}
		};

		//from is a char array
		template<class To,class From,int i>
		struct ConvertHelper<To,From[i],false>{

			typedef std::basic_string<To> returnType;

			typedef typename boost::remove_const<From>::type InnerFrom;

			static returnType convert(const std::basic_string<InnerFrom>& str){
				return Converter<To,InnerFrom>::convert(str);
			}
		};
	}

	//the function itself
	template<class To,class From>
	typename privat::ConvertHelper<To,From,boost::is_pointer<From>::value>::returnType 
	char_convert(const From& input){
		return privat::ConvertHelper<To,From,boost::is_pointer<From>::value>::convert(input);
	}
}

MfG

template<class T>
struct is_pointer
{
    enum{value=false};    //static const bool, können aber meines wissens nach nicht alle compiler
};

template<class T>
struct is_pointer<T*>
{
    enum{value=true};
};

template<class T>
struct remove_const
{
    typedef T type;
};

template<class T>
struct remove_const<const T>
{
    typedef T type;
};

template<class T>
struct remove_pointer
{
    typedef T type;
};

template<class T>
struct remove_pointer<T*>
{
    typedef T type;
};

Das sollte dein Programm kein byte größer machen, da nix instanziert wird.

template < typename Type >
struct always_int
{
  typedef typename remove_const< typename remove_pointer< typename remove_const< Type >::type >::type >::type type;
};

std::string bool_to_str( bool val )
{
  return ( val ? "true" : "false" );
}

int main()
{
  std::cout << bool_to_str( typeid(always_int< const int * const >::type) == typeid(int) ) << std::endl;
  std::cout << bool_to_str( typeid(always_int< const int *       >::type) == typeid(int) ) << std::endl;
  std::cout << bool_to_str( typeid(always_int< const int         >::type) == typeid(int) ) << std::endl;
  std::cout << bool_to_str( typeid(always_int<       int * const >::type) == typeid(int) ) << std::endl;
  std::cout << bool_to_str( typeid(always_int<       int *       >::type) == typeid(int) ) << std::endl;
  std::cout << bool_to_str( typeid(always_int<       int         >::type) == typeid(int) ) << std::endl;
}

Output:
true
true
true
true
true
true

hab durch zufall diesen Thread gefunden und bin auch sehr an diesem "cast" interessiert. Jedoch habe ich den Code von Otze ausprobiert, doch er geht nicht Er bringt das Programm zum absturz

Weiß einer warum?

hab durch zufall diesen Thread gefunden und bin auch sehr an diesem "cast" interessiert.

Verarsch doch die Leute nicht. Du bist doch der Threadstarter.

Was ist mit

mbtowc()
wctomb()
mbstowcs()
wcstombs()

oder unter Windows auch

WideCharToMultiByte()
MultiByteToWideChar()

Ist natürlich alles C und umständlich zu nutzen, aber hat für mich immer funktioniert.

std::string bool_to_str( bool val )
{
  return ( val ? "true" : "false" );
}

Das brauchst du nicht wirklich. Dafuer kannst du auch das Flag boolalpha setzen ;).

mfg
v R

Ist natürlich alles C und umständlich zu nutzen, aber hat für mich immer funktioniert.

weil es nicht plattformunabhaengig ist?