Problemes avec les Parametres template

Version imprimable

Bonjour, en codant mon emulateur nes pour PS VITA je me heurte a un probleme, je doit convertir une structure c++ en c# mais je bloque sur les parametre template apres de nombreuse recherche je n'ai toujours pas trouver comment faire, voila la structure :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
template<unsigned bitno, unsigned nbits=1, typename T=u8>
struct RegBit
{
    T data;
    enum { mask = (1u << nbits) - 1u };
    template<typename T2>
    RegBit& operator=(T2 val)
    {
        data = (data & ~(mask << bitno)) | ((nbits > 1 ? val & mask : !!val) << bitno);
        return *this;
    }
    operator unsigned() const { return (data >> bitno) & mask; }
    RegBit& operator++ ()     { return *this = *this + 1; }
    unsigned operator++ (int) { unsigned r = *this; ++*this; return r; }
};

05/08/2012, 17h36
tomlev

Il n'y a pas d'équivalent C# à cette fonctionnalité ; les paramètres des types génériques ne peuvent être que des types, pas des nombres.

A vue de nez cette structure se contente de faire des manipulations de bits ; tu peux sans doute reproduire la même fonctionnalité en C# sans "traduire" littéralement cette structure.
05/08/2012, 22h54
hardcpp

Merci de ta reponse mais je vois pas trop comment faire
05/08/2012, 23h33
tomlev

Tu peux donner des exemples de l'utilisation de cette structure ? Là j'ai un peu de mal à comprendre à quoi ça sert exactement :?

Je m'en sert pour des union principalement pour le moteur de rendu audio de mon emulateur nes.

Jai reussie a faire sa en attendant

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
	class RegBitSupplies
	{
		public static System.Collections.Hashtable Data = new System.Collections.Hashtable();
	};
 
	struct RegBit<T>
	{
	    public T Data;
 
		public RegBit(uint bitno, uint nbits, T p_DefaultValue)
		{
			Data = p_DefaultValue;
			RegBitSupplies.Data.Add(this, new Tuple<uint, uint>(bitno, nbits ));
		}
 
		public uint GetMask()
		{
			return (uint)((1 << ((int)(RegBitSupplies.Data[this] as Tuple<uint, uint>).Item2)) - 1);
		}
 
	    public RegBit<T> Set<T2>(T2 p_Val)
	    {
			uint l_BitNo = (RegBitSupplies.Data[this] as Tuple<uint, uint>).Item1; 
			uint l_NBits = (RegBitSupplies.Data[this] as Tuple<uint, uint>).Item2;
 
			Int32 l_Part1 = ((Int32)Convert.ChangeType(Data, TypeCode.Int32)) & ~(((Int32)GetMask() << (Int32)(l_BitNo)));
			Int32 l_Part2 = (((Int32)(l_NBits) > 1 ? (Int32)Convert.ChangeType(p_Val, TypeCode.Int32) & (Int32)GetMask() : (Int32)Convert.ChangeType(p_Val, TypeCode.Int32)) << (Int32)(l_BitNo));
 
			Data = (T)Convert.ChangeType((Int32)(l_Part1 | l_Part2),  typeof(T));
 
	        return this;
	    }
 
	    public static explicit operator uint(RegBit<T> p_RegBit) 
		{ 
			return (uint)(((Int32)Convert.ChangeType(p_RegBit.Data, TypeCode.Int32) >> (Int32)(RegBitSupplies.Data[p_RegBit] as Tuple<uint, uint>).Item1) & (Int32)p_RegBit.GetMask()); 
		}
 
	  /*  RegBit& operator++ ()     { return *this = *this + 1; }
	    uint operator++ (int) { uint r = *this; ++*this; return r; }*/
	};

Mais jai un autre probleme qui est apparue :

Code:

1
2
	  /*  RegBit& operator++ ()     { return *this = *this + 1; }
	    uint operator++ (int) { uint r = *this; ++*this; return r; }*/

Comment adapter sa en c# sans les pointeurs x)