uni_cast?

[otze]

ich hab mal vor kurzem so einen cast geschrieben, aber das grenzt eher an einen großen hack. ich kopier dir den code mal raus

#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);
	}
}

[''']

iiiiih boost! nee lass mal. Bevor mein Programm total aus den Näten platzt lasse ich das lieber.

[evilissimo]

das was da aus boost benutzt wird ist nur minimal und das kannst du auch einfach nachprogrammieren.

MfG

[ness]

Dir zu liebe, ohne Garantie, iplementierungen für is_pointer,remove_const und remove_pointer:

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.

[+++++++++++++++++++]

@ness:
wie benutzt man das?!?!?!

[evilissimo]

Wenn du z.b. immer sicherstellen willst das du den grund typen bekommst: ( Ohne const, pointer usw )

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

['#']

Hi,

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?

[LOL!]

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

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

[pZy]

Ich versteh ehrlich gesagt nicht, warum ihr diese Unmengen von Code postet.

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.

[virtuell Realisticer]

evilissimo schrieb:

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

[Shade Of Mine]

pZy schrieb:

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

weil es nicht plattformunabhaengig ist?