template-metacode gesucht für i8, i16, u32 und so

volkard

ich suche code, mit dem ich, ohne standardheader zu benutzen, die typen u8, u16, u32, i8, i16, i32 basteln kann, wobei u32 zum beispiel unsigned integer mit 32 bit bedeutet.
ich gehe davon aus, daß sizeof(char)==1 und daß ein char 8 bit hat und daß die größeren typen genau 16, 32, 64, 128 bit haben, falls vorhanden.

ganz einfach kann ichs ja machen mit

typedef unsigned int u32;
static_assert(sizeof(u32)==4);

das reicht mit in sachen sicherheit. ich will sozusagen "normale" systeme.

nur wie mache ich das template-gefrickel, daß ich nach alleiniger inkludierung von "mytypes.hpp" und ohne stabdardheader dann auch typedefs für u16 und u32 habe?
also im prinzip würde es reichen, für i32 die typen long long, long, int, short, signed char zu testen, und den ersten zu nehmen, der paßt. so als mutmaßung.

Hab ich vor ein paar Jahren mal mit ein paar anderen hier in diesem Forum implementiert, wenn es den Thread noch gibt müsstest du darin mindestens 5 Möglichkeiten finden. Den Link habe ich leider nicht mehr, leider weiß ich auch nicht mehr was für einen Nick ich da benutzt habe

volkard

kannste dich noch an den verwendeten namen für u32 erinnern? das würde meine suche voll beschleunigen.

Du hast Glück ich habe gerade noch etwas auf meiner Festplatte gefunden, allerdings weiß ich nicht ob das alle Varianten sind.

/*template< bool condition, class TypeIfTrue, class TypeIfFalse >
struct IfThenElse
{
};

template< class TypeIfTrue, class TypeIfFalse >
struct IfThenElse< true, TypeIfTrue, TypeIfFalse >
{
	typedef TypeIfTrue Type;
};

template< class TypeIfTrue, class TypeIfFalse >
struct IfThenElse< false, TypeIfTrue, TypeIfFalse >
{
	typedef TypeIfFalse Type;
};

template< int size >
struct Size2Type
{
};

template<>
struct Size2Type< 1 >
{
	typedef char Type;
};

template<>
struct Size2Type< 2 >
{
	typedef IfThenElse< sizeof( short int ) == 2, short int,
				IfThenElse< sizeof( long int ) == 2, long int,
					void >::Type >::Type Type;
};

template<>
struct Size2Type< 4 >
{
	typedef IfThenElse< sizeof( short int ) == 4, short int,
				IfThenElse< sizeof( long int ) == 4, long int,
					IfThenElse< sizeof( long long int ) == 4, long long int,
						void >::Type >::Type >::Type Type;
};

template<>
struct Size2Type< 8 >
{
	typedef IfThenElse< sizeof( long int ) == 8, long int,
				IfThenElse< sizeof( long long int ) == 8, long long int,
					void >::Type >::Type Type;
};

template< bool isSigned, class IntType >
struct IsSigned
{
};

template< bool isSigned >
struct IsSigned< isSigned, char >
{
	typedef typename IfThenElse< isSigned, signed char, unsigned char >::Type Type;
};

template< bool isSigned >
struct IsSigned< isSigned, short int >
{
	typedef typename IfThenElse< isSigned, signed short int,
						unsigned short int >::Type Type;
};

template< bool isSigned >
struct IsSigned< isSigned, long int >
{
	typedef typename IfThenElse< isSigned, signed long int, 
						unsigned long int >::Type Type;
};

template< bool isSigned >
struct IsSigned< isSigned, long long int >
{
	typedef typename IfThenElse< isSigned, signed long long int,
						unsigned long long int >::Type Type;
};

#include <typeinfo>
#include <iostream>
using namespace std;

int main()
{
	typedef IsSigned< true, Size2Type< 1 >::Type >::Type int8;
	typedef IsSigned< false, Size2Type< 1 >::Type >::Type uint8;
	typedef IsSigned< true, Size2Type< 2 >::Type >::Type int16;
	typedef IsSigned< false, Size2Type< 2 >::Type >::Type uint16;
	typedef IsSigned< true, Size2Type< 4 >::Type >::Type int32;
	typedef IsSigned< false, Size2Type< 4 >::Type >::Type uint32;
	typedef IsSigned< true, Size2Type< 8 >::Type >::Type int64;
	typedef IsSigned< false, Size2Type< 8 >::Type >::Type uint64;

	cout << typeid( int8 ).name() << endl;
	cout << typeid( uint8 ).name() << endl;
	cout << typeid( int16 ).name() << endl;
	cout << typeid( uint16 ).name() << endl;
	cout << typeid( int32 ).name() << endl;
	cout << typeid( uint32 ).name() << endl;
	cout << typeid( int64 ).name() << endl;
	cout << typeid( uint64 ).name() << endl;
}*/

/*template< int count, int offset >
struct Sum
{
	enum{ result = offset + Sum< count-1, offset >::result };
};

template< int offset >
struct Sum< 1, offset >
{
	typedef enum{ result = offset };
};
#include <iostream>
using namespace std;
int main()
{
	cout << Sum< 10, 2 >::result;
}*/

/*
template< int base, int exp >
struct static_pow
{
	enum{ result = base * static_pow< base, exp - 1 >::result };
};

template< int base >
struct static_pow< base, 0 >
{
	enum{ result = 1 };
};

int main()
{
	cout << static_pow< 3, 2 >::result;
}*/

/*#include <climits>

template< bool condition, class TypeIfTrue, class TypeIfFalse >
struct IfThenElse
{
	typedef TypeIfFalse Type;
};

template< class TypeIfTrue, class TypeIfFalse >
struct IfThenElse< true, TypeIfTrue, TypeIfFalse >
{
	typedef TypeIfTrue Type;
};

struct TypeSize
{
	enum
	{
		uchar	= sizeof( unsigned char ) * CHAR_BIT,
		ushort	= sizeof( unsigned short ) * CHAR_BIT,
		ulong	= sizeof( unsigned long ) * CHAR_BIT,
		ull		= sizeof( unsigned long long ) * CHAR_BIT
	};
};

struct TypeTraits
{
	enum
	{
		NoSign,
		WithSign
	};
};

template< int size, int isSigned >
struct BitsToType
{
};

template< int isSigned >
struct BitsToType< TypeSize::uchar, isSigned  >
{
	typedef typename IfThenElse< isSigned, signed char, unsigned char >::Type Type;
};

template< int isSigned >
struct BitsToType< TypeSize::ushort, isSigned >
{
	typedef typename IfThenElse< isSigned, signed short, unsigned short >::Type Type;
};

template< int isSigned >
struct BitsToType< TypeSize::ulong, isSigned >
{
	typedef typename IfThenElse< isSigned, signed long, unsigned long >::Type Type;
};

template< int isSigned >
struct BitsToType< TypeSize::ull, isSigned >
{
	typedef typename IfThenElse< isSigned, signed long long, unsigned long long >::Type Type;
};

typedef BitsToType< 32, TypeTraits::NoSign >::Type uint32;
*/

/*template< bool condition, class TypeIfTrue, class TypeIfFalse >
struct IfThenElse
{
	typedef TypeIfFalse Type;
};

template< class TypeIfTrue, class TypeIfFalse >
struct IfThenElse< true, TypeIfTrue, TypeIfFalse >
{
	typedef TypeIfTrue Type;
};

struct Empty{};

template< typename T1 = Empty, typename T2 = Empty,
		  typename T3 = Empty, typename T4 = Empty > struct TypeList;

template< typename T1, typename T2, typename T3, typename T4 >
struct TypeList
{
	typedef T1 Head;
	typedef TypeList< T2, T3, T4 > Tail;
	enum
	{
		length = Tail::length + 1
	};
};

template<>
struct TypeList< Empty, Empty, Empty, Empty >
{
	enum
	{
		length = 0
	};
};

template< typename TypeList >
struct Length
{
	enum
	{
		val = TypeList::length
	};
};

template< typename TypeList, int Index, int Depth = 0, 
		  bool End = ( Index == Depth ),
		  bool OutOfRange = Length< TypeList >::val == 0 >
struct Get
{
	typedef typename Get< typename TypeList::Tail, Index, Depth + 1 >::Type Type;
};

template< typename TypeList, int Index, int Depth, bool End >
struct Get< TypeList, Index, Depth, End, true >
{
};

template< typename TypeList, int Index, int Depth, bool OutOfRange >
struct Get< TypeList, Index, Depth, true, OutOfRange >
{
	typedef typename TypeList::Head Type;
};

#include <climits>

template< typename T >
struct TypeWrapper
{
	typedef T Type;
	enum
	{
		size = sizeof( T ) * CHAR_BIT
	};
};

template< typename TypeList, int size, int depth = 0,
		  bool found = ( size == TypeList::Head::size ) >
struct Find
{
	typedef typename Find< typename TypeList::Tail, size, depth + 1 >::Type Type;
};

template< typename TypeList, int size, int depth >
struct Find< TypeList, size, depth, true >
{
	typedef typename TypeList::Head::Type Type;
};

typedef TypeList< TypeWrapper< unsigned char >, 
				  TypeWrapper< unsigned short >,
				  TypeWrapper< unsigned long >, 
				  TypeWrapper< unsigned long long > > UnsignedIntTypes;

typedef TypeList< TypeWrapper< signed char >, 
				  TypeWrapper< signed short >,
				  TypeWrapper< signed long >, 
				  TypeWrapper< signed long long > > SignedIntTypes;

struct TypeTraits
{
	enum
	{
		NoSign = 0,
		WithSign = 1
	};
};

template< int size, int isSigned >
struct BitsToType
{
	typedef 
		typename 
			IfThenElse< isSigned,
						typename Find< SignedIntTypes, size >::Type,
						typename Find< UnsignedIntTypes, size >::Type >::Type Type;
};

typedef BitsToType< 32, TypeTraits::NoSign >::Type uint32;*/

/*
#include <climits>
#include <cstddef>

// tja, das gute alte if/then/else
template <bool Condition, class Then, class Else>
struct if_then_else;

template <class Then, class Else>
struct if_then_else<false, Then, Else>
{
typedef Else result;
};

template <class Then, class Else>
struct if_then_else<true, Then, Else>
{
typedef Then result;
};

namespace native_integer
{

// unsere Typliste, mal etwas anders :)
// leicht erweiterbar
template <size_t I, bool Signed>
struct type_list;

template <>
struct type_list<0, true>
{
typedef signed char type;
};

template <>
struct type_list<0, false>
{
typedef unsigned char type;
};

template <>
struct type_list<1, true>
{
typedef signed short type;
};

template <>
struct type_list<1, false>
{
typedef unsigned short type;
};

template <>
struct type_list<2, true>
{
typedef signed int type;
};

template <>
struct type_list<2, false>
{
typedef unsigned int type;
};

template <>
struct type_list<3, true>
{
typedef signed long type;
};

template <>
struct type_list<3, false>
{
typedef unsigned long type;
};

// hier durchsuchen wir die Typliste nach einem passenden Eintrag
template <size_t Size, bool Signed, size_t I = 0>
struct type_selection
{
private:
typedef typename if_then_else<
sizeof(typename type_list<I, Signed>::type) * CHAR_BIT == Size,
type_list<I, Signed>,
type_selection<Size, Signed, I + 1>
>::result result;
public:
typedef typename result::type type;
};

// Ende der Rekursion
// private deshalb, damit wir einen Compilefehler bekommen
template <size_t Size, bool Signed>
struct type_selection<Size, Signed, 4>
{
private:
struct type
{
};
};

// lediglich dieses Template ist fuer den Anwender von Interesse
template <size_t Size, bool Signed>
struct type_definition
{
typedef typename type_selection<Size, Signed>::type result;
};

} // namespace native_integer

// Verwendung
typedef native_integer::type_definition<16, false>::result uint16;
//typedef native_integer::type_definition<15, false>::result uint15; // win32: ouch
*/

volkard

vielen dank.
die frage kam aus
http://www.c-plusplus.net/forum/viewtopic-var-t-is-239408-and-start-is-15.html
und ich werde deinen code sogleich auf meine platte sichern und fürderhin verwenden.
thx.

edit: warum hast du das eigentlich gemacht? auch nur aus spaß?

volkard schrieb:

vielen dank.
die frage kam aus
http://www.c-plusplus.net/forum/viewtopic-var-t-is-239408-and-start-is-15.html
und ich werde deinen code sogleich auf meine platte sichern und fürderhin verwenden.
thx.

edit: warum hast du das eigentlich gemacht? auch nur aus spaß?

Ja, hatte damals mit der Metaprogrammierung angefangen und als ich einmal solche typedefs gebraucht habe, habe ich mir überlegt, dass man das ja mit Template-Metaprogrammierung machen könnte und so ist das entstanden.

Übrigens fällt mir gerade ein, dass du damals kurz nach dem mein damaliger Thread erstorben ist in einem anderen Thread geschrieben hattest, dass du (falls du mal so etwas benötigst) das mit Template-Metaprogrammierung machen würdest (du wurdest damals von einem anderen aus meinem Thread auch auf mein Thread hingewiesen) und heute ist es so weit

volkard

C++-Programmierer schrieb:

Übrigens fällt mir gerade ein, dass du damals kurz nach dem mein damaliger Thread erstorben ist in einem anderen Thread geschrieben hattest, dass du (falls du mal so etwas benötigst) das mit Template-Metaprogrammierung machen würdest (du wurdest damals von einem anderen aus meinem Thread auch auf mein Thread hingewiesen) und heute ist es so weit

GEIL!