Usando IntelliSense e guardando il codice di altre persone, mi sono imbattuto in questo IntPtrtipo; ogni volta che è necessario usarlo ho semplicemente messo nullo IntPtr.Zerotrovato la maggior parte delle funzioni. Che cos'è esattamente e quando / perché viene utilizzato?
Risposte:
È un "numero intero nativo (specifico della piattaforma)". È rappresentato internamente come void*ma esposto come un numero intero. È possibile utilizzarlo ogni volta che è necessario archiviare un puntatore non gestito e non si desidera utilizzare il unsafecodice. IntPtr.Zeroè effettivamente NULL(un puntatore nullo).
IntPtrha perfettamente senso, perché è un numero intero (come nell'intero matematico) e un puntatore (come nel puntatore). La Intparte ha poco a che fare con il tipo int: è un concetto, non un tipo specifico. Sebbene sia giusto, l'unica cosa che le specifiche CLI dicono a riguardo è che si tratta effettivamente di un "numero intero, dimensione nativa". Oh bene :)
È un tipo di valore abbastanza grande da memorizzare un indirizzo di memoria utilizzato nel codice nativo o non sicuro, ma non direttamente utilizzabile come indirizzo di memoria nel codice gestito sicuro.
È possibile utilizzare IntPtr.Sizeper scoprire se si sta eseguendo un processo a 32 o 64 bit, poiché saranno rispettivamente 4 o 8 byte.
IntPtrè anche usato per rappresentare handle che sono a 32 bit indipendentemente dall'architettura (anche se Sizein questo caso dice ancora 8). La specifica CLI nota solo che è un numero intero di "dimensione nativa", ma in realtà non dice molto.
Ecco un esempio:
Sto scrivendo un programma C # che si interfaccia con una telecamera ad alta velocità. La fotocamera ha il suo driver che acquisisce le immagini e le carica automaticamente nella memoria del computer.
Quindi quando sono pronto a portare l'ultima immagine nel mio programma con cui lavorare, il driver della fotocamera mi fornisce un IntPtr su dove l'immagine è GIÀ memorizzata nella memoria fisica, quindi non devo perdere tempo / risorse per crearne un'altra blocco di memoria per memorizzare un'immagine che è già in memoria. IntPtr mi mostra solo dove si trova già l'immagine.
Un IntPtr è un numero intero che ha le stesse dimensioni di un puntatore .
È possibile utilizzare IntPtr per memorizzare un valore di puntatore in un tipo non puntatore. Questa funzionalità è importante in .NET poiché l'uso dei puntatori è altamente soggetto a errori e quindi illegale nella maggior parte dei contesti. Consentendo al valore del puntatore di essere archiviato in un tipo di dati "sicuro", l'impianto idraulico tra segmenti di codice non sicuri può essere implementato in un codice di alto livello più sicuro - o anche in un linguaggio .NET che non supporta direttamente i puntatori.
Le dimensioni di IntPtr sono specifiche della piattaforma, ma raramente questi dettagli devono essere considerati, poiché il sistema utilizzerà automaticamente le dimensioni corrette.
Il nome "IntPtr" è confuso - qualcosa di simile Handleavrebbe potuto essere più appropriato. La mia ipotesi iniziale era che "IntPtr" fosse un puntatore a un numero intero. La documentazione MSDN di IntPtr entra nei dettagli in qualche modo enigmatico senza mai fornire molte informazioni sul significato del nome.
An IntPtrè un puntatore con due limitazioni:
In altre parole, un IntPtrè proprio come un void*- ma con la funzione extra che può (ma non dovrebbe) essere usato per l'aritmetica del puntatore di base.
Per dereferenziare un IntPtr, puoi lanciarlo su un puntatore vero (un'operazione che può essere eseguita solo in contesti "non sicuri") oppure puoi passarlo a una routine di supporto come quella fornita dalla InteropServices.Marshalclasse. L'uso della Marshalclasse dà l'illusione della sicurezza poiché non richiede di essere in un contesto esplicito "non sicuro". Tuttavia, non rimuove il rischio di crash che è inerente all'uso dei puntatori.
Che cos'è un puntatore?
In tutte le lingue, un puntatore è un tipo di variabile che memorizza un indirizzo di memoria e puoi chiedere loro di dirti l' indirizzo a cui stanno puntando o il valore all'indirizzo a cui stanno puntando.
Un puntatore può essere pensato come una sorta di segno di libro. Tranne, invece di essere utilizzato per saltare rapidamente a una pagina di un libro, viene utilizzato un puntatore per tenere traccia o mappare i blocchi di memoria.
Immagina la memoria del tuo programma esattamente come un grande array di 65535 byte.
I puntatori indicano obbedientemente
I puntatori ricordano ciascuno un indirizzo di memoria e quindi puntano ciascuno a un singolo indirizzo in memoria.
Come gruppo, i puntatori ricordano e richiamano gli indirizzi di memoria, obbedendo a ogni comando fino alla nausea.
Sei il loro re.
Puntatori in C #
Nello specifico in C #, un puntatore è una variabile intera che memorizza un indirizzo di memoria compreso tra 0 e 65534.
Anche specifici per C #, i puntatori sono di tipo int e quindi firmati.
Tuttavia, non è possibile utilizzare indirizzi con numero negativo, né è possibile accedere a un indirizzo superiore a 65534. Qualsiasi tentativo in tal senso genererà un'eccezione System.AccessViolationException.
Un puntatore chiamato MyPointer è dichiarato così:
int * MyPointer;
Un puntatore in C # è un int, ma gli indirizzi di memoria in C # iniziano da 0 e si estendono fino a 65534.
Le cose appuntite dovrebbero essere gestite con particolare attenzione
La parola non sicuro è destinato a spaventare voi, e per una buona ragione: I puntatori sono cose appuntite, e le cose appuntite ad esempio spade, asce, puntatori, ecc dovrebbero essere trattati con particolare attenzione.
I puntatori danno al programmatore il controllo stretto di un sistema. Pertanto è probabile che gli errori commessi abbiano conseguenze più serie.
Per utilizzare i puntatori, è necessario abilitare il codice non sicuro nelle proprietà del programma e i puntatori devono essere utilizzati esclusivamente in metodi o blocchi contrassegnati come non sicuri.
Esempio di un blocco non sicuro
unsafe
{
// Place code carefully and responsibly here.
}Come usare i puntatori
Quando le variabili o gli oggetti vengono dichiarati o istanziati, vengono memorizzati.
int *MyPointer;
MyPointer = &MyVariable;
Una volta assegnato un indirizzo a un puntatore, si applica quanto segue:
MyPointer = &MyVariable; // Set MyPointer to point at MyVariable
"MyPointer is pointing at " + *MyPointer;
Poiché un puntatore è una variabile che contiene un indirizzo di memoria, questo indirizzo di memoria può essere memorizzato in una variabile puntatore.
Esempio di puntatori usati con cura e responsabilità
public unsafe void PointerTest()
{
int x = 100; // Create a variable named x
int *MyPointer = &x; // Store the address of variable named x into the pointer named MyPointer
textBox1.Text = ((int)MyPointer).ToString(); // Displays the memory address stored in pointer named MyPointer
textBox2.Text = (*MyPointer).ToString(); // Displays the value of the variable named x via the pointer named MyPointer.
}Si noti che il tipo di puntatore è un int. Questo perché C # interpreta gli indirizzi di memoria come numeri interi (int).
Perché è int invece di uint?
Non c'è una buona ragione.
Perché usare i puntatori?
I puntatori sono molto divertenti. Con gran parte del computer controllato dalla memoria, i puntatori consentono a un programmatore un maggiore controllo della memoria del proprio programma.
Monitoraggio della memoria.
Utilizzare i puntatori per leggere i blocchi di memoria e monitorare come i valori puntati cambiano nel tempo.
Modifica questi valori in modo responsabile e tieni traccia di come le modifiche influiscono sul tuo computer.
65534sembra molto sbagliato come intervallo del puntatore. Dovresti fornire un riferimento.
System.IntPtr: Vorrei vedere la risposta aggiornata alla fine spiegando anche cosa System.IntPtre come si riferisce ai puntatori non sicuri in C # per favore.
MSDN ci dice:
Il tipo IntPtr è progettato per essere un numero intero le cui dimensioni sono specifiche della piattaforma. Vale a dire, un'istanza di questo tipo dovrebbe essere a 32 bit su hardware e sistemi operativi a 32 bit e 64 bit su hardware e sistemi operativi a 64 bit.
Il tipo IntPtr può essere utilizzato da lingue che supportano i puntatori e come mezzo comune per fare riferimento ai dati tra lingue che supportano e non supportano i puntatori.
Gli oggetti IntPtr possono anche essere utilizzati per contenere handle. Ad esempio, le istanze di IntPtr sono ampiamente utilizzate nella classe System.IO.FileStream per contenere handle di file.
Il tipo IntPtr è conforme a CLS, mentre il tipo UIntPtr non lo è. Nel runtime di linguaggio comune viene utilizzato solo il tipo IntPtr. Il tipo UIntPtr viene fornito principalmente per mantenere la simmetria architettonica con il tipo IntPtr.
http://msdn.microsoft.com/en-us/library/system.intptr(VS.71).aspx
Bene, questa è la pagina MSDN che tratta IntPtr.
La prima riga recita:
Un tipo specifico della piattaforma utilizzato per rappresentare un puntatore o un handle.
Per quanto riguarda quale puntatore o handle è la pagina continua a dichiarare:
Il tipo IntPtr può essere utilizzato da lingue che supportano i puntatori e come mezzo comune per fare riferimento ai dati tra lingue che supportano e non supportano i puntatori.
Gli oggetti IntPtr possono anche essere utilizzati per contenere handle. Ad esempio, le istanze di IntPtr sono ampiamente utilizzate nella classe System.IO.FileStream per contenere handle di file.
Un puntatore è un riferimento a un'area di memoria che contiene alcuni dati a cui sei interessato.
Un handle può essere un identificatore per un oggetto e viene passato tra metodi / classi quando entrambe le parti devono accedere a quell'oggetto.
An IntPtrè un tipo di valore utilizzato principalmente per contenere indirizzi di memoria o handle. Un puntatore è un indirizzo di memoria. Un puntatore può essere digitato (ad es. int*) O non tipizzato (ad es void*.). Un handle di Windows è un valore di solito delle stesse dimensioni (o inferiore) di un indirizzo di memoria e rappresenta una risorsa di sistema (come un file o una finestra).