kann das jemand testen?

[otze]

also, in nem andren thread wurde ja en bissl über das konvertieren von char nach wchar_t geredet, und ich hab dazuw as geschrieben.

das problem ist nur, dass meine stl implementation fehlerhaft zu sein scheint was locales angeht(nicht einmal humes bsiepiele in der faq gehen), das einzige was ich da bekomme ist eine bad cast exception(mit andren worten: std::ctype<wchar_t> gibet scheinbar nicht...)

also, kann das jemand durch seinen compiler jagen? wär ganz toll.
wenn der compiler nen fehler ausspucken sollte, dann bitte posten, der gcc hat mir bis auf die beiden wcout nichts angeprangert

#include <iostream>
#include<boost\type_traits\remove_const.hpp>

namespace privat{

	//von beliebigem zeichentyp zu anderem beliebigen zeichentyp
    template<class T,class U>
	struct converter{
		static std::basic_string<T> convert(const std::basic_string<U>& str,const std::locale& loc=std::locale()){
			return converter<T,char>::convert(converter<char,U>::convert(str,loc),loc);
		}

	};

    //von char zu einem beliebigen andren zeichentyp
	template<class T> 
	struct converter<T,char>{

		static std::basic_string<T> convert(const std::string& str,const std::locale& loc=std::locale()){
			std::basic_string<T> output;
			output.reserve(str.size());

			std::use_facet<std::ctype<T> > (loc).widen(&*str.begin(),&*str.end(),&*output.begin());
			return output;
		}

	};

    //von beliebigen zeichentyp zu char
    template<class T> 
	struct converter<char,T>{

		static std::string convert(const std::basic_string<T>& str,const std::locale& loc=std::locale()){
			std::string output;
			output.reserve(str.size());

			std::use_facet<std::ctype<T> > (loc).narrow(&*str.begin(),&*str.end(),0,&*output.begin());
			return output;
		}

	};

	//wenn start und ziel typ identisch sind, muss nichts gemacht werden
	template<class T> struct converter<T,T>{

		static const std::basic_string<T>& convert(const std::basic_string<T>& str,const std::locale& loc=std::locale()){
			return str;
		}

	};

	//spezialisierung fpr char, damit keine uneindeutigkeit entsteht
	template<> struct converter<char,char>{

		static const std::string& convert(const std::string& str,const std::locale& loc=std::locale()){
			return str;
		}

	};

} 

// hier werden die funktionen zusammengefasst
template<class T,class U>
std::basic_string<T> convert(const std::basic_string<U>& str,const std::locale& loc=std::locale()){

	return privat::converter<T,U>::convert(str,loc);
}

//der compiler kann sich den template parameter bei character konstanten nicht herleiten
template<class T,class U>
std::basic_string<T> convert(U* str,const std::locale& loc=std::locale()){
	return convert<T>(std::basic_string< typename boost::remove_const<U>::type >(str),loc);
}

int main(){
	try{
		std::cout<<convert<char>("Hallo\n");
		std::cout<<convert<char>(L"Hallo\n");
		std::wcout<<convert<wchar_t>(L"Hallo\n");
		std::wcout<<convert<wchar_t>("Hallo");
	}
	catch(const std::exception &e){
		std::cout<<e.what();
	}
	std::cin.get();
}

[audacia]

Weder BCC noch MSVC schmeißen eine Exception, aber bei beiden hat nur das erste cout Effekt (zudem kennt auch MSVC wcout nicht; ich habe die wcouts auskommentiert).

Moritz

[borg]

g++.exe "Unbenannt1.cpp" -o "Unbenannt1.exe" -fexpensive-optimizations -O3 -pg -g3
In function `int main()':
error: `wcout' is not a member of `std'
error: `wcout' is not a member of `std'
Ausführung beendet

[otze]

@borg selber compiler, selbe fehler...

@audacia kannst du in den try block auch noch diese zeile einfügen?

std::cout<<privat::converter<char,wchar_t>::convert(std::wstring(L"Hallo\n"));

wenn das nicht funktioniert,liegts an der funktion, sonst hab ich da irgendwo nen fehler bei der auswahl gemacht...

[cplusplus.]

hi!

hab visual c net 2003...und da funzt es....
wird 2 mal Hallo ausgegeben....

cu

[otze]

geht auchd er wcout teil?(müssten dann 4 "Hallo"s sein...)

[audacia]

otze schrieb:

@audacia kannst du in den try block auch noch diese zeile einfügen?

std::cout<<privat::converter<char,wchar_t>::convert(std::wstring(L"Hallo\n"));

wenn das nicht funktioniert,liegts an der funktion, sonst hab ich da irgendwo nen fehler bei der auswahl gemacht...

Es scheint an der Funktion zu liegen; ich bin gerade mit dem Debugger durchgestiegen. Ich glaube, die narrow-Methode wird falsch verwendet (wobei ich allerdings keine Ahnung habe, wie sie richtig verwendet wird :)).

Moritz

[otze]

wenn, dann ist der 3. parameter nicht korrekt. das ist der default character, also falls das umzuwandelnde zeichen nicht im ascii bereich liegt, wird der dafür eingesetzt. ich hab dafür dann '/0' genommen, und als der gcc dann dafür ne warning gegegeben hat, hab ich draus dann den zahlenwert 0 gemacht. setz also einfach mal ein anderes zeichen ein...

[evilissimo]

Hi otze

Der Code funktioniert so.
Das problem bei dir war

std::use_facet<std::ctype<T> > (loc).widen(&*str.begin(),&*str.end(),&*output.begin());
//und
std::use_facet<std::ctype<T> > (loc).narrow(&*str.begin(),&*str.end(),0,&*output.begin());

das mit dem übergeben der adresse des ersten zeichens, hat nicht wirklich funktioniert.
Nun wird bei mir 4 mal Hallo ausgegeben.

otze schrieb:

ich hab dafür dann '/0' genommen, und als der gcc dann dafür ne warning gegegeben hat, hab ich draus dann den zahlenwert 0 gemacht.

Das war ja auch richtig(Vom Compiler das er dich warnt), denn '\0' ist 0 und '/0' sind 2 zeichen!!

#include <iostream>
#include <wchar.h>
#include<boost/type_traits/remove_const.hpp>

namespace privat{

    //von beliebigem zeichentyp zu anderem beliebigen zeichentyp
    template<class T,class U>
    struct converter{
        static std::basic_string<T> convert(const std::basic_string<U>& str,const std::locale& loc=std::locale()){
            return converter<T,char>::convert(converter<char,U>::convert(str,loc),loc);
        }

    };

    //von char zu einem beliebigen andren zeichentyp
    template<class T>
    struct converter<T,char>{

        static std::basic_string<T> convert(const std::string& str,const std::locale& loc=std::locale()){
            T *output = new T[str.size()];            
            std::use_facet<std::ctype<T> > (loc).widen(&*str.begin(),&*str.end(),output);
	    std::basic_string<T> ret(output, output+str.size());
            delete[] output;
            return ret;
        }

    };

    //von beliebigen zeichentyp zu char
    template<class T>
    struct converter<char,T>{

        static std::string convert(const std::basic_string<T>& str,const std::locale& loc=std::locale()){

            char *output = new char[str.size()];             
            std::use_facet<std::ctype<T> > (loc).narrow(&*str.begin(),&*str.end(),0,output);
            std::string ret(output);
	    delete[] output;
	    return ret;
        }

    };

    //wenn start und ziel typ identisch sind, muss nichts gemacht werden
    template<class T> struct converter<T,T>{

        static const std::basic_string<T>& convert(const std::basic_string<T>& str,const std::locale& loc=std::locale()){
            return str;
        }

    };

    //spezialisierung fpr char, damit keine uneindeutigkeit entsteht
    template<> struct converter<char,char>{

        static const std::string& convert(const std::string& str,const std::locale& loc=std::locale()){
            return str;
        }

    };

}

// hier werden die funktionen zusammengefasst
template<class T,class U>
std::basic_string<T> convert(const std::basic_string<U>& str,const std::locale& loc=std::locale()){

    return privat::converter<T,U>::convert(str,loc);
}

//der compiler kann sich den template parameter bei character konstanten nicht herleiten
template<class T,class U>
std::basic_string<T> convert(U* str,const std::locale& loc=std::locale()){
    return convert<T>(std::basic_string< typename boost::remove_const<U>::type >(str),loc);
}

int main(){
    try{
        std::cout<<convert<char>("Hallo\n");
        std::cout<<convert<char>(L"Hallo\n");
        std::wcout<<convert<wchar_t>(L"Hallo\n");
        std::wcout<<convert<wchar_t>("Hallo\n");
    }
    catch(const std::exception &e){
        std::cout<<e.what();
    }
    std::cin.get();
}

[otze]

eViLiSSiMo schrieb:

Hi otze

Der Code funktioniert so.
Das problem bei dir war

std::use_facet<std::ctype<T> > (loc).widen(&*str.begin(),&*str.end(),&*output.begin());
//und
std::use_facet<std::ctype<T> > (loc).narrow(&*str.begin(),&*str.end(),0,&*output.begin());

das mit dem übergeben der adresse des ersten zeichens, hat nicht wirklich funktioniert.
Nun wird bei mir 4 mal Hallo ausgegeben.

dann ist es ja gut danke dir, dass du dich mal dran gesetzt hast

//edit krieg immer noch ne exception

otze schrieb:

ich hab dafür dann '/0' genommen, und als der gcc dann dafür ne warning gegegeben hat, hab ich draus dann den zahlenwert 0 gemacht.

Das war ja auch richtig(Vom Compiler das er dich warnt), denn '\0' ist 0 und '/0' sind 2 zeichen!!

himmel, vor wenigen monaten wär mir das nicht passiert, die programmierabstinenz hat mich doch weiter zurückgeworfen als ich dachte

naja, wird schon wieder

[evilissimo]

ehrlich gesagt hatte ich mich auch gewundert
das gerade dir das nicht auffällt

aber so eine Programmierabstinenz macht sich schon bemerkbar.

MfG

[otze]

hab mich nochmal wegen g++ und wchar_t erkundigt: zwar ist wcout etc bereits in den headern deklariert(man muss nur ein define auf 1 setzen), aber es gibt für wcout oder den locales zb noch keine implementation unter windows :(. einzige möglichkeit is ne andere stl implementation, wobei ich aber nicht weis, wie ich die unter mingw einbinden soll^^