wchar_t Größe



  • Hallo ,

    bin etwa verwirrt was die Größe von wchar_t angeht.

    Sind es 16 Bit oder 32 Bit ?

    Danke.

    mfg, Elke



  • Das ist afaik vom Standard nicht vorgeschrieben (bzw. "implementation-defined") - d.h. beides ist im Zweifelsfall möglich.

    (wie es auf deinem System aussieht, kannst du ja per sizeof() nachmessen)



  • Mindes so groß wie ein char und maximal so groß wie ein long. Außerdem gibts kein explizites unsigned wchar_t. Der Typ is immer dann unsigned wenn der unterliegened Intergertyp (den wchar_t benötigt) unsigned ist.



  • Danke !

    Kann ich den wchar irgendwie auf 16 Bit festlegen ?

    Das Problem ist , ich möchte einen char in wchar_t ( mit Größe 16 Bit ) casten.
    Aber ich muss sicher gehen , dass wchar_t -16 Bit groß ist ?

    Gibt es da eine Möglichkeit so etwas zu machen ?

    danke.

    mfg , Elke



  • Nein, es sei denn du suchst dir einen Typen raus der definitiv 16 Bit breit ist und verwendest den.



  • Technisch: Nein (was sich hinter "wchar_t" verbirgt, entscheidet dein Compiler - eventuell bietet er die Möglichkeit, an den Größenvorgaben zu schrauben).

    Praktisch: Muß es denn unbedingt wchar_t sein? Du könntest zur Not einen eigenen Typ my_wchar definieren (z.B. als 'unsigned short') - da kannst du genau einstellen, wie groß er werden soll.
    (irgendwo habe ich mal eine Template-Konstruktion gesehen, mit der man gezielt einen n-Byte-Integertyp auswählen konnte)



  • Was meint ihr , wenn ich das so mache :

    int nWChar_Laenge = sizeof( wchar_t );
         #if ( nWChar_Laenge == 2 )
    	typedef wchar_t UChar;
         #else
    	typedef unsigned short UChar;
         #endif
    

    Dann ist ja der UChar immer 16 Bit groß.

    mfg , Elke



  • Jep, hab ich auchmal was gebastelt. Dafür verwendete ich Typenlisten (die Implementation aus 'Modern C++ Design'):

    Gekürzt:

    struct NullType {};
    
    template< bool b, typename T, typename U >
    struct Select
    {
    	typedef T Result;
    };
    
    template< typename T, typename U >
    struct Select< false, T, U >
    {
    	typedef U Result;
    };
    
    template< typename T, typename U >
    struct TypeList
    {
    	typedef T Head;
    	typedef U Tail;
    };
    
    namespace TL
    {
    	template< typename TList, unsigned int bits > 
    	struct TypeBySize; 
    
    	template< unsigned int bits > 
    	struct TypeBySize< NullType, bits > 
    	{ 
    		typedef void Type; 
    	}; 
    
    	template< typename T, typename U, unsigned int bits > 
    	struct TypeBySize< TypeList< T, U >, bits > 
    	{ 
    		typedef typename Select< ( ( sizeof( T ) * CHAR_BIT ) == bits ), T, typename TypeBySize< U, bits >::Type >::Result Type; 
    	}; 
    };
    
    #define TYPELIST_1( T1 ) TypeList< T1, NullType >
    #define TYPELIST_2( T1, T2 ) TypeList< T1, TYPELIST_1( T2 ) >
    #define TYPELIST_3( T1, T2, T3 ) TypeList< T1, TYPELIST_2( T2, T3 ) >
    #define TYPELIST_4( T1, T2, T3, T4 ) TypeList< T1, TYPELIST_3( T2, T3, T4 ) >
    #define TYPELIST_5( T1, T2, T3, T4, T5 ) TypeList< T1, TYPELIST_4( T2, T3, T4, T5 ) >
    

    Hab nur meine eigene Funktionalität im Namespace TL mit aufgelistet. Der Rest wäre hier irrelevant.

    Und verwendet wird das so:

    typedef TYPELIST_4( signed char, signed short, signed int, signed long ) SIntegralTypes;
    
    int main( int argc, char* argv[] )
    {
    	typedef TL::TypeBySize< SIntegralTypes, 16 >::Type My16BitWChar;
    
    	My16BitWChar foobar = 0x7fff;
    	std::cout << sizeof( foobar ) << std::endl;
    }
    

    grüße



  • Hallo David ,

    interessante Lösung !

    danke.

    mfg, Olga



  • Eventuell ist dazu auch noch folgender FAQ-Beitrag interessant:
    Absolute Typgrößen mit templates

    Greetz



  • #include <boost/cstdint.hpp>
    typedef boost::uint16_t my_wchar_t;
    

Log in to reply