Newsgroup: it.comp.lang.c++
Titolo: me ne esco con una domanda stramba

da poco sto assorbendo l'uso dei namespace (non erano nello 
standard che studiai anni fa del C++), e mi chiedevo se si 
potesse fare una cosa come creare una specie di bind di una 
variabile, o oggetto classe, ad un determinato Namespace.
Mi spiego meglio, con le enum, quando uno dichiara una variabile 
del tipo enum, ogni assegnamento su quel valore dovrà essere 
pescato dalla corrispettiva lista di costanti. E fin qui, tutto 
regolare.
Mi piacerebbe sapere se c'è un qualche modo, anche tortuoso, per 
far si che una certa variabile possa essere assegnata attingendo 
soltanto dal namespace che la contiene, usando ovviamente 
apposite costanti tratte dal medesimo namespace (o da altri, ma 
in modo specifico).
In sostanza ne uscirebbe fuori una sorta di enum generalizzata 
in grado di ospitare anche tipi non integral, addirittura 
oggetti compositi.
Immagino già la risposta, in verità, ma ripongo una certa 
fiducia nell'umano ingegno. Mi andrebbe bene anche spaghetti-code.
P.S. offro in cambio anticipatamente, una classetta NON TESTATA 
(compila solo) per indirizzare e usare array statici di singoli 
bit alla stregua di quelli di byte, con la sintassi del subscript
Eccolo qui a chi interessa (sorry per i ritorni a capo 
automatici) :
//////////////////////////////////////////////////////////////////////////////////////////
// {127, 191, 223, 239, 247, 251, 253, 254};
//////////////////////////////////////////////////////////////////////////////////////////
namespace Constants_Bits {
	const unsigned long conBitsPerByte = 8;
	const unsigned long conBitOffsetMask = 7;
	const unsigned long conBitAddressShift = 3;
};
//////////////////////////////////////////////////////////////////////////////////////////
class ClsByteBits;
class ClsByteReference;
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
class ClsByteBits
{
private:
	static unsigned char zz_BitsSingoliUni [Constants_Bits :: 
conBitsPerByte];
	static unsigned char zz_BitsSingoliZeri [Constants_Bits :: 
conBitsPerByte];
	static inline unsigned char zz_Set_B_0 (unsigned char Byte) { 
return (Byte | 1); };
	static inline unsigned char zz_Set_B_1 (unsigned char Byte) { 
return (Byte | 2); };
	static inline unsigned char zz_Set_B_2 (unsigned char Byte) { 
return (Byte | 4); };
	static inline unsigned char zz_Set_B_3 (unsigned char Byte) { 
return (Byte | 8); };
	static inline unsigned char zz_Set_B_4 (unsigned char Byte) { 
return (Byte | 16); };
	static inline unsigned char zz_Set_B_5 (unsigned char Byte) { 
return (Byte | 32); };
	static inline unsigned char zz_Set_B_6 (unsigned char Byte) { 
return (Byte | 64); };
	static inline unsigned char zz_Set_B_7 (unsigned char Byte) { 
return (Byte | 128); };
	static inline unsigned char zz_Canc_B_0 (unsigned char Byte) { 
return (Byte & 254); };
	static inline unsigned char zz_Canc_B_1 (unsigned char Byte) { 
return (Byte & 253); };
	static inline unsigned char zz_Canc_B_2 (unsigned char Byte) { 
return (Byte & 251); };
	static inline unsigned char zz_Canc_B_3 (unsigned char Byte) { 
return (Byte & 247); };
	static inline unsigned char zz_Canc_B_4 (unsigned char Byte) { 
return (Byte & 239); };
	static inline unsigned char zz_Canc_B_5 (unsigned char Byte) { 
return (Byte & 223); };
	static inline unsigned char zz_Canc_B_6 (unsigned char Byte) { 
return (Byte & 191); };
	static inline unsigned char zz_Canc_B_7 (unsigned char Byte) { 
return (Byte & 127); };
	static inline unsigned char zz_Read_B_0 (unsigned char Byte) { 
return (Byte | 1); };
	static inline unsigned char zz_Read_B_1 (unsigned char Byte) { 
return (Byte | 2); };
	static inline unsigned char zz_Read_B_2 (unsigned char Byte) { 
return (Byte | 4); };
	static inline unsigned char zz_Read_B_3 (unsigned char Byte) { 
return (Byte | 8); };
	static inline unsigned char zz_Read_B_4 (unsigned char Byte) { 
return (Byte | 16); };
	static inline unsigned char zz_Read_B_5 (unsigned char Byte) { 
return (Byte | 32); };
	static inline unsigned char zz_Read_B_6 (unsigned char Byte) { 
return (Byte | 64); };
	static inline unsigned char zz_Read_B_7 (unsigned char Byte) { 
return (Byte | 128); };
 
	typedef unsigned char (* PtrSetBit_B_nn) (unsigned char Byte);
	typedef unsigned char (* PtrCancBit_B_nn) (unsigned char Byte);
	typedef unsigned char (* PtrReadBit_B_nn) (unsigned char Byte);
 
	static PtrSetBit_B_nn PtrSetBitFn [Constants_Bits :: 
conBitsPerByte];
	static PtrCancBit_B_nn PtrCancBitFn [Constants_Bits :: 
conBitsPerByte];
	static PtrReadBit_B_nn PtrReadBitFn [Constants_Bits :: 
conBitsPerByte];
public:
	inline static unsigned char BitSet (unsigned char Byte, 
unsigned char Index) { return ((PtrSetBitFn [Index & 
Constants_Bits :: conBitOffsetMask])(Byte)); };
	inline static unsigned char BitSetFast (unsigned char Byte, 
unsigned char Index) { return ((PtrSetBitFn [Index])(Byte)); };
	inline static unsigned char BitCancel (unsigned char Byte, 
unsigned char Index) { return ((PtrCancBitFn [Index & 
Constants_Bits :: conBitOffsetMask])(Byte)); };
	inline static unsigned char BitCancelFast (unsigned char Byte, 
unsigned char Index) { return ((PtrCancBitFn [Index])(Byte)); };
	inline static unsigned char BitAssign (unsigned char Byte, 
unsigned char Index, unsigned Value) { return ((Value == 0) ? 
((PtrCancBitFn [Index & Constants_Bits :: 
conBitOffsetMask])(Byte)) : ((PtrSetBitFn [Index & 
Constants_Bits :: conBitOffsetMask])(Byte))); };
	inline static unsigned char BitAssignFast (unsigned char Byte, 
unsigned char Index, unsigned Value) { return ((Value == 0) ? 
((PtrCancBitFn [Index])(Byte)) : ((PtrSetBitFn [Index])(Byte))); };
	inline static unsigned char BitRead (unsigned char Byte, 
unsigned char Index) { return ((PtrReadBitFn [Index & 
Constants_Bits :: conBitOffsetMask])(Byte)); };
	inline static unsigned char BitReadFast (unsigned char Byte, 
unsigned char Index) { return ((PtrReadBitFn [Index])(Byte)); };
};
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
ClsByteBits :: PtrSetBit_B_nn  ClsByteBits :: PtrSetBitFn 
[Constants_Bits :: conBitsPerByte] = { & zz_Set_B_0, & 
zz_Set_B_1, & zz_Set_B_2, & zz_Set_B_3, & zz_Set_B_4, & 
zz_Set_B_5, & zz_Set_B_6, & zz_Set_B_7 };
ClsByteBits :: PtrCancBit_B_nn ClsByteBits :: PtrCancBitFn 
[Constants_Bits :: conBitsPerByte] = { & zz_Canc_B_0, & 
zz_Canc_B_1, & zz_Canc_B_2, & zz_Canc_B_3, & zz_Canc_B_4, & 
zz_Canc_B_5, & zz_Canc_B_6, & zz_Canc_B_7 };
ClsByteBits :: PtrReadBit_B_nn ClsByteBits :: PtrReadBitFn 
[Constants_Bits :: conBitsPerByte] = { & zz_Read_B_0, & 
zz_Read_B_1, & zz_Read_B_2, & zz_Read_B_3, & zz_Read_B_4, & 
zz_Read_B_5, & zz_Read_B_6, & zz_Read_B_7 };
//////////////////////////////////////////////////////////////////////////////////////////
unsigned char ClsByteBits :: zz_BitsSingoliUni [Constants_Bits 
:: conBitsPerByte] =  {1,   2,   4,   8,   16,  32,  64,  128};
unsigned char ClsByteBits :: zz_BitsSingoliZeri [Constants_Bits 
:: conBitsPerByte] = {254, 253, 251, 247, 239, 223, 191, 127};
//////////////////////////////////////////////////////////////////////////////////////////
class ClsByteReference
{
private:
	unsigned char * PtrBytes;
	unsigned long Indice;
public:
	ClsByteReference (unsigned char * ByteArray, unsigned long Index)
		: PtrBytes (ByteArray), Indice (Index)
			{ return; };
 
	// lettura
	operator unsigned char ()
		{ return (PtrBytes [Indice]); };
	// scrittura
	ClsByteReference & operator = (const unsigned char Byte)
		{ PtrBytes [Indice] = Byte; return (* this); };
};
//////////////////////////////////////////////////////////////////////////////////////////
template <unsigned long TotBitsNumber> class ClsArrayBits
{
friend class ClsByteBits;
private:
	unsigned char zz_Array [(TotBitsNumber + Constants_Bits :: 
conBitsPerByte - 1) / Constants_Bits :: conBitsPerByte];
	unsigned char zz_Innocuo;
public:
	// accesso con notazione funzionale esplicita
	inline unsigned char BitSet (unsigned long Index) { return 
(ClsByteBits :: BitSetFast (zz_Array [Index >> Constants_Bits :: 
conBitAddressShift], (unsigned char)(Index & Constants_Bits :: 
conBitOffsetMask))); };
	inline unsigned char BitCancel (unsigned long Index) { return 
(ClsByteBits :: BitCancelFast (zz_Array [Index >> Constants_Bits 
:: conBitAddressShift], (unsigned char)(Index & Constants_Bits 
:: conBitOffsetMask))); };
	inline unsigned char BitAssign (unsigned long Index, unsigned 
Value) { return (ClsByteBits :: BitAssignFast (zz_Array [Index 
 >> Constants_Bits :: conBitAddressShift], (unsigned char)(Index 
& Constants_Bits :: conBitOffsetMask), Value)); };
	inline unsigned char BitRead (unsigned long Index) { return 
(ClsByteBits :: BitReadFast (zz_Array [Index >> Constants_Bits 
:: conBitAddressShift], (unsigned char)(Index & Constants_Bits 
:: conBitOffsetMask))); };
 
	inline unsigned long SizeOfInBits (void) { return (sizeof 
(zz_Array)); };
	// accesso comodo con notazione di array di bit (operatore 
unario subscript)
	ClsByteReference operator [] (unsigned long Index)
		{ return (ClsByteReference (zz_Array, Index % sizeof 
(zz_Array))); };
};
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
int silly (void)
{
ClsArrayBits <10> BArr;
BArr.BitSet(1);
unsigned A = BArr.BitRead(2);
BArr [3] = 1;
A = BArr [5];
BArr [2] = BArr [0];
return 0;
};
//////////////////////////////////////////////////////////////////////////////////////////

 > di ospitare anche tipi non integral, addirittura oggetti compositi.
Sinceramente io non ho capito:
1) a cosa servirebbe tutto questo...
2) non ti vanno bene le classi?
In una classe puoi infilare dentro variabili e altra roba statica..
prova a vedere se ti ci salta fuori qualcosa di funzionante...
-- 
Adesso quando i medici di turno rifiuteranno di esserti d'aiuto / perchè
venne un polacco ad insegnargli che è più cristiano imporsi col rifiuto
pretenderanno che tu torni indietro/e ti costringeranno a partorire per
poi chiamarlo figlio della colpa / e tu una Maddalena da pentire

 In una classe puoi infilare dentro variabili e altra roba statica..
vero .... mi sa che prima o poi dovrò spiegare meglio i difetti 
delle soluzioni pure basate su classi finora prodotte.
ciao x ora
CCCP++Mario
