#if-Abfrage innerhalb Makro



  • Hallo,

    kurze Frage:
    Ist es möglich folgendes Konstrukt zu realisieren:

    mein_makro( type ) \
    #if type == char \
    [...] \
    #else \
    [...] \
    #endif \



  • Schreit das nicht nach einer Template-Funktion?

    EDIT: Ach so, C-Forum... sorry...



  • _matze schrieb:

    Schreit das nicht nach einer Template-Funktion?

    Das worum es mir geht, habe ich auch per Template realisiert. Soll aber auch eine C-Variante existieren.

    Sieht momentan so aus:

    #ifndef __cplusplus
    
    	#define _decl_byteunion( type, name )					\
    	union name												\
    	{														\
    	private:												\
    		/******* private member *******/					\
    		type _byte;											\
    		/******* private member *******/					\
    															\
    	public:													\
    		/******* typedef *******/							\
    		typedef const name C_##name;						\
    		typedef const type C_##type;						\
    		/******* typedef *******/							\
    															\
    															\
    		/******* public member *******/						\
    		struct _nibble {									\
    			type n0:4;										\
    			type n1:4;										\
    		} nibble;											\
    															\
    		struct _bit {										\
    			type b0:1;										\
    			type b1:1;										\
    			type b2:1;										\
    			type b3:1;										\
    			type b4:1;										\
    			type b5:1;										\
    			type b6:1;										\
    			type b7:1;										\
    		} bit;												\
    		/******* public member *******/						\
    															\
    															\
    		/******* constructor / destructor *******/			\
    		name##(void) {};										\
    															\
    		name##(C_##type value) {								\
    			this->_byte = value;							\
    		}													\
    															\
    		~##name##(void) {};										\
    		/******* constructor / destructor *******/			\
    															\
    		/******* function declaration *******/				\
    		name##& invert(void) {								\
    			this->_byte = this->_byte ^ 1 ^ 2 ^ 4 ^ 8 ^ 16 ^ 32 ^ 64 ^ 128; \
    			return *this;									\
    		}													\
    		/******* function declaration *******/				\
    															\
    		/******* operator *******/							\
    		operator DWORD (void) {								\
    			return CAST(this->_byte, DWORD);				\
    		}													\
    															\
    		type##& operator= (C_##type& value) {				\
    			this->_byte = value;							\
    		}													\
    															\
    		bool operator== (C_##name##& rhs) {					\
    			return (this->_byte == rhs._byte);				\
    		}													\
    															\
    		bool operator!= (C_##name##& rhs) {					\
    			return (this->_byte != rhs._byte);				\
    		}													\
    															\
    		name##& operator| (C_##type##& value) {				\
    			this->_byte = this->_byte | value;				\
    			return *this;									\
    		}													\
    															\
    		name##& operator& (C_##type##& value) {				\
    			this->_byte = this->_byte & value;				\
    			return *this;									\
    		}													\
    															\
    		name##& operator^ (C_##type##& value) {				\
    			this->_byte = this->_byte ^ value;				\
    			return *this;									\
    		}													\
    		/******* operator *******/							\
    	}
    
    	_decl_byteunion( UCHAR, unByte );
    	_decl_byteunion( CHAR, siByte );
    
    #endif
    

    Bevor die Frage kommt, was dass eigentlich soll. Es geht darum eine Klasse (oder ben Union) zu implementieren, die mir möglichst einfach den Wert jedes Bits und Halbbytes (nibbles) anzeigt.

    Dass es besser wäre mit keinem direkten Wert zu rechnen, sondern dass ganze eher per Pointer auf eine andere Variable zeigen zu lassen, ist mir klar 😉

    Es geht darum, dass ich bei einem signed char nicht unbedingt einen DWORD (unsigned long) Operator brauche.



  • FrEEzE2046 schrieb:

    Bevor die Frage kommt, was dass eigentlich soll. Es geht darum eine Klasse (oder ben Union) zu implementieren, die mir möglichst einfach den Wert jedes Bits und Halbbytes (nibbles) anzeigt.

    dein code ist viel zu umständlich (C++ verleitet zu übermässig kompliziertem denken!!). mach's etwa so:

    #define GETBIT(x,y)(((x)&(1<<(y)))!=0)  // bit y aus wert x lesen
    #define UPPER4(x) (((x)>>4)&15)         // obere 4 bits von byte-wert x
    #define LOWER4(x) ((x)&15)              // untere 4 bits eines wertes
    

    ^^ ungetestet, aber vom prinzip her geht das so.
    🙂



  • FrEEzE2046 schrieb:

    name##& invert(void) { this->_byte = this->_byte ^ 1 ^ 2 ^ 4 ^ 8 ^ 16 ^ 32 ^ 64 ^ 128; \ return *this;

    kannste abkürzen zu: byte ^= 255;
    🙂



  • Soll aber auch eine C-Variante existieren.

    Und dann mit "private", "public" und Operatoren-Überladung???



  • mmmh,

    im Prinzip kann ich jede Funktionalität einer Klasse wieder in Funktionen packen. Es ging mir eigentlich aber darum, diesen Vorgang zu vereinfachen.

    Ich wollte folgende Klasse (nur der wichtigste Teil) in C übernehmen:

    template<typename T> class BitAnalyzer 
    		{
    		private:
    			/******* typedef *******/
    			typedef union _ByteUnion {
    				struct _nibble {
    					BYTE n0:4,
    						 n1:4;
    				} nibble;
    
    				struct _bit {
    					BYTE b0:1,
    						 b1:1,
    						 b2:1,
    						 b3:1,
    						 b4:1,
    						 b5:1,
    						 b6:1,
    						 b7:1;
    				} bit;
    			} ByteUnion, *PByteUnion;
    			/******* typedef *******/
    
    			/******* private member *******/
    			PByteUnion _Var;			
    			/******* private member *******/
    
    		public:
    			/******* constructor / destructor *******/
    			explicit BitAnalyzer( T* Var ) {
    				this->_Var = reinterpret_cast<PByteUnion>(Var);
    			}
    			~BitAnalyzer(void) {}
    			/******* constructor / destructor *******/
    
    			/******* public member *******/
    			ByteUnion& operator[] (C_DWORD idx) {
    				if( idx < sizeof(T) )
    					return *(this->_Var + idx);
    			}
    			/******* public member *******/
    		};
    


  • FrEEzE2046 schrieb:

    mmmh,
    im Prinzip kann ich jede Funktionalität einer Klasse wieder in Funktionen packen. Es ging mir eigentlich aber darum, diesen Vorgang zu vereinfachen.

    ^^dein code ist sowieso mist. du solltest besser keine unions und bitfields verwenden, um auf teile eines bytes zuzugreifen, das kann schnell schief gehen.
    mach am besten alles neu, jetzt haste ja die gelegenheit dazu.
    🙂



  • Hallo Fricky,

    da ich auch noch fleissig am C lernen bin und für meine Ausgabe eines Bytes als Dualzahl eine Funktion aus Union und Bitfelder verwenden, würde ich gerne wissen wieso man diese besser nicht einsetzen sollte?



  • justchris schrieb:

    Hallo Fricky,
    da ich auch noch fleissig am C lernen bin und für meine Ausgabe eines Bytes als Dualzahl eine Funktion aus Union und Bitfelder verwenden, würde ich gerne wissen wieso man diese besser nicht einsetzen sollte?

    unions sind zum speicherplatz sparen da. nur der zuletzt geschriebene wert ist gültig. nimm zum fummeln mit bits bessr shifts und logikoperatoren. das ist portabel und auch nicht zu langsam.
    🙂


Log in to reply