2013-08-04 6 views
5

io normalmente fare questo nel mio codice C++:sizeof() per i tipi di operatore

int variable = 10; 
int sizeOfVariable = sizeof(variable); //Returns 4 for 32-bit process 

ma questo non sembra funzionare per C#. C'è un analogo?

+5

La dimensione di un 'int' è * sempre * 32 bit in C#. Questo perché 'int' è un alias per' System.Int32' e 'System.Int32' è a 32 bit per definizione e che * non * cambierà mai. Periodo, fine della storia. – jason

+4

@Jason e non è glorioso ?! –

+0

@ Jason: ovviamente non lo uso in quella forma specifica. – c00000fd

risposta

16

L'operatore sizeof in C# funziona solo su tipi noti in fase di compilazione, non su variabili (istanze).

L'esempio corretta sarebbe

int variable = 10; 
int sizeOfVariable = sizeof(int); 

Quindi, probabilmente siete alla ricerca di Marshal.SizeOf che può essere utilizzato su qualsiasi istanze di oggetti o tipi di runtime.

int variable = 10; 
int sizeOfVariable = Marshal.SizeOf(variable);  

Vedi here per ulteriori informazioni

+0

Grazie. Io nuovo è stato facile. Ma solo per curiosità, cosa fa 'sizeof'? – c00000fd

+1

Viene utilizzato per ottenere la dimensione in byte per un tipo. Il tipo dovrebbe essere noto al momento della compilazione. – hazzik

+7

'Marshal.SizeOf (oggetto)' indica la dimensione * non gestita * di un oggetto. È * possibile * che la dimensione * non gestita * di un oggetto differisca dalla sua dimensione * gestita *. 'sizeof (typename)' indica la dimensione * managed * delle istanze del tipo con nome 'typename'. 'sizeof' può * solo * essere applicato a' typename's che sono nomi di * tipi di valore *. 'sizeof' può * solo * essere usato nel codice * non sicuro *. – jason

8

NET 4.0 in poi:

if (Environment.Is64BitProcess) 
    Console.WriteLine("64-bit process"); 
else 
    Console.WriteLine("32-bit process"); 

Vecchie versioni di .NET framework:

public static bool Is64BitProcess 
{ 
    get { return IntPtr.Size == 8; } 
} 

(dal vostro esempio Sono supponendo che tu voglia fare questo per determinare il testimone del processo, whi ch potrebbe in effetti non essere quello che stai cercando di fare)

+0

Non lo sto usando per determinare il testimone del sistema operativo. Ho bisogno che conosca la dimensione di una variabile primitiva in memoria. – c00000fd

5

ci sono solo un paio di situazioni standard in cui si vorrà per farlo:

int x = sizeof(T) // where T is a generic type 

purtroppo non funziona :-)

int x = Marshal.SizeOf(T) // where T is a generic type 

che funziona ad eccezione di char e bool (Marshal.SizeOf(typeof(char)) == 1 invece di 2, Marshal.SizeOf(typeof(bool)) == 4 invece di 1)

int x = sizeof(IntPtr); 

non funziona, ma si può fare come

int x = Marshal.SizeOf(typeof(IntPtr)); 

o, meglio

int x = IntPtr.Size; 

Tutti gli altri tipi di base (byte, sbyte, short, ushort, int, uint, long , ulong, float, double, decimal, bool, char) hanno una lunghezza fissa, quindi è possibile fare sizeof(int) e sarà sempre 4.

+0

La segnalazione errata della dimensione del tipo di carattere char e di variabili mediante l'API 'Marshal.SizeOf' è in realtà errata o è attribuita ad alcune rappresentazioni interne effettive sul modo in cui sono memorizzate in memoria? – RBT

+0

@RBT La dimensione "errata" è perché quella restituita è la dimensione utilizzata durante il marshalling dell'API di Windows (si sta utilizzando 'Marshal.SizeOf' :-)). Per esempio vedere [UnmanagedType.Bool] (https://msdn.microsoft.com/en-us/library/system.runtime.interopservices.unmanagedtype (v = vs80) .aspx): 'Un valore booleano di 4 byte ' – xanatos

+0

Grazie per la tua risposta @xanatos. Nel frattempo avevo chiesto la stessa identica domanda per curiosità e Hans lo ha spiegato magnificamente. Puoi dare un'occhiata [qui] (http://stackoverflow.com/questions/38969438/oppostie-behavior-of-marshal-sizeof-and-sizeof-operator-for-boolean-and-char-dat). – RBT

Problemi correlati