C #: Non è possibile convertire da ulong al byte

Question

Strano come posso farlo in C ++, ma non in C #.

Per chiarire, io ti incollo le due funzioni in C ++ e poi in C # e segnare le linee problematiche nel codice C # con un commento "// errore". Che la funzione due non fa altro che codifica per il parametro e quindi aggiungerlo a una variabile globale byte1seeds nome.

Queste sono le funzioni in C ++

//Global var:

unsigned char byte1seeds[3];

unsigned long GenerateValue( unsigned long * Ptr )
{
unsigned long val = *Ptr;
for( int i = 0; i < 32; i++ )
    val = (((((((((((val >> 2)^val) >> 2)^val) >> 1)^val) >> 1)^val) >> 1)^val)&1)|((((val&1) << 31)|(val >> 1))&0xFFFFFFFE);
return ( *Ptr = val );
}

void SetupCountByte( unsigned long seed )
{
if( seed == 0 ) seed = 0x9ABFB3B6;
unsigned long mut = seed;
unsigned long mut1 = GenerateValue( &mut );
unsigned long mut2 = GenerateValue( &mut );
unsigned long mut3 = GenerateValue( &mut );
GenerateValue( &mut );
unsigned char byte1 = (mut&0xFF)^(mut3&0xFF);
unsigned char byte2 = (mut1&0xFF)^(mut2&0xFF);
if( !byte1 ) byte1 = 1;
if( !byte2 ) byte2 = 1;
byte1seeds[0] = byte1^byte2;
byte1seeds[1] = byte2;
byte1seeds[2] = byte1;
}

Ora il codice C #:

Ho cambiato la funzione GenerateValue.Instead di avere un puntatore come un parametro, esso ha un parametro ulong.

Per chiamare e modificare entrambi i valori che uso:

1. ulong mut1 = GenerateValue (mut);
2. mut = mut1;

Ecco le funzioni tradotte (le linee problematiche sono contrassegnati con "// errore");

//Global var:
public static byte[] byte1seeds = new byte[3];

public static ulong GenerateValue(ulong val)
{
    for( int i = 0; i < 32; i++ )
        val = (((((((((((val >> 2)^val) >> 2)^val) >> 1)^val) >> 1)^val) >> 1)^val)&1)|((((val&1) << 31)|(val >> 1))&0xFFFFFFFE);
    return val ;
}

public static void SetupCountByte( uint seed )
{
    if( seed == 0 ) seed = 0x9ABFB3B6;
    ulong mut = seed;
    ulong mut1 = GenerateValue(mut);
    mut = mut1;
    ulong mut2 = GenerateValue(mut);
    mut = mut2;
    ulong mut3 = GenerateValue(mut);
    mut = mut3;
    mut = GenerateValue(mut);
    byte byte1 = (mut & 0xFF) ^ (mut3 & 0xFF); //error
    byte byte2 = (mut1 & 0xFF) ^ (mut2 & 0xFF); //error
    if( byte1 != 0 )
        byte1 = 1;
    if( byte2 != 0 )
        byte2 = 1;
    byte1seeds[0] = byte1^byte2; //error
    byte1seeds[1] = byte2;
    byte1seeds[2] = byte1;
}

L'errore è:

Impossibile convertire implicitamente il tipo 'ulong' a 'byte'. Esiste una conversione esplicita (che le manca un cast?)

modifica: l'errore alla riga problematico 3 è:

Impossibile convertire implicitamente il tipo 'int' a 'byte'. Esiste una conversione esplicita (che le manca un cast?)

Qui viene la domanda: Come risolvere gli errori

?

Grazie in anticipo!

Answer 1

Aggiungi un (byte) per lanciarla. Come si potrebbe perdere la precisione, si deve dire al compilatore che il valore si inseriscono in un byte, cioè.

byte byte1 = (byte)((mut & 0xFF) ^ (mut3 & 0xFF));
byte byte2 = (byte)((mut1 & 0xFF) ^ (mut2 & 0xFF));

Answer 2

Si potrebbe perdere informazioni. Il compilatore non consente questo tipo di operazioni, a meno di dirgli esplicitamente di farlo. Quindi, provare qualcosa di simile:

byte result = ((byte)mut & 0xFF) ^ ((byte)mut3 & 0xFF);

In questo modo, tutte le variabili sono esplicitamente colato e il risultato sarà un byte. Oppure si può fare questo:

byte result = (byte)((mut & 0xFF) ^ (mut3 & 0xFF));

Answer 3

Sintomo

Il seguente codice viene compilato in C ++, ma è respinta da un compilatore C #, con la terza linea tipo di segnalazione di incompatibilità.

ulong mut = 5;
ulong mut3 = 6;
byte foo = (mut & 0xFF) ^ (mut3 & 0xFF);

Spiegazione

Il (mut & 0xFF) ^ (mut3 & 0xFF) espressione è di tipo ulong e non può essere assegnato ad una variabile di tipo byte.

Il mut variabile è un ulong. Tutti i sovraccarichi di & richiedono tipo operando simmetria, così nel (mut & 0xFF) espressione, il 0xFF valore viene promosso ulong, e il risultato dell'operazione ha il tipo ulong.

Mentre un processo simile fa anche dare il secondo sottoespressione tipo ulong, questo è incidentale perché nella grande espressione A ^ B, il fatto che l'espressione A ha il tipo ulong causerebbe espressione B da promuovere.

Così, l'espressione (mut & 0xFF) ^ (mut3 & 0xFF) è di tipo ulong e richiede un cast esplicito prima che possa essere assegnato ad una variabile di tipo byte.

Soluzione

esplicitamente typecast l'intera espressione prima dell'assegnazione.

Commento

La gente si spengono gli avvertimenti invece di pensare a loro, perché la maggior parte delle librerie C + sono pieni di difetti. Se si passa avvertimenti spalle su di voi ottenere così tante che è inutile cercare di guadare attraverso di loro, anche se da qualche parte nel caos ci sarà una nota per l'effetto di "è stato richiesto un typecast potenzialmente lossy implicito".

Se avete letto la specifica linguaggio C #, con particolare riguardo agli operatori, imparerete molte cose utili. Ad esempio, questo codice non sarà riuscito:

byte b = 0xF0 | 0x0E; //b should contain 0xFE

ma questi avranno successo:

byte b1 = (byte)(0xF0 | 0x0E); //typecast fixes it
byte b2 = 0xF0;
b2 |= 0x0E; //reflexive operator typed by target variable

Answer 4

"conversione esplicita esiste" indica che è necessario fare un cast esplicito. In questo caso, che sarebbe qualcosa di simile:

byte byte1 = (byte) ( (mut & 0xFF) ^ (mut3 & 0xFF) );
byte byte2 = (byte) ( (mut1 & 0xFF) ^ (mut2 & 0xFF) );

Answer 5

C'è un rel="nofollow MSDN Knowledge Base che spiega in modo approfondito la necessità di downcast esplicito. Le parole "conversione esplicita esiste" nel messaggio di errore sono destinati ad essere l'indizio che si deve convertire in modo esplicito il tipo di dati utilizzando un cast. Nel tuo caso specifico, che sarebbe simile a questa:

byte byte1 = (byte) ( (mut & 0xFF) ^ (mut3 & 0xFF) );