Example | Description |
---|---|
byte* | Pointer to byte |
char* | Pointer to char |
int** | Pointer to pointer to int |
int*[] | Single-dimension array of pointers to int |
void* | Pointer to unknown type |
int* pi, pj; // NOT as int *pi, *pj;end note] Paragraph 71 The value of a pointer having type T* represents the address of a variable of type T. 2 The pointer indirection operator * (§25.5.1) may be used to access this variable. 3 For example, given a variable P of type int*, the expression *P denotes the int variable found at the address contained in P. Paragraph 81 Like an object reference, a pointer may be null. 2 Applying the indirection operator to a null pointer results in implementation-defined behavior. 3 A pointer with value null is represented by all-bits-zero. Paragraph 91 The void* type represents a pointer to an unknown type. 2 Because the referent type is unknown, the indirection operator cannot be applied to a pointer of type void*, nor can any arithmetic be performed on such a pointer. 3 However, a pointer of type void* can be cast to any other pointer type (and vice versa). Paragraph 101 Pointer types are a separate category of types. 2 Unlike reference types and value types, pointer types do not inherit from object and no conversions exist between pointer types and object. 3 In particular, boxing and unboxing (§11.3) are not supported for pointers. 4 However, conversions are permitted between different pointer types and between pointer types and the integral types. 5 This is described in §25.4. Paragraph 111 A pointer-type may be used as the type of a volatile field (§17.4.3). [Note: Although pointers can be passed as ref or out parameters, doing so can cause undefined behavior, since the pointer may well be set to point to a local variable which no longer exists when the called method returns, or the fixed object to which it used to point, is no longer fixed. For example:
using System; class Test { static int value = 20; unsafe static void F(out int* pi1, ref int* pi2) { int i = 10; pi1 = &i; fixed (int* pj = &value) { // ... pi2 = pj; } } static void Main() { int i = 10; unsafe { int* px1; int* px2 = &i; F(out px1, ref px2); Console.WriteLine("*px1 = {0}, *px2 = {1}", *px1, *px2); // undefined behavior } } }end note] Paragraph 121 A method can return a value of some type, and that type can be a pointer. [Example: For example, when given a pointer to a contiguous sequence of ints, that sequence's element count, and some other int value, the following method returns the address of that value in that sequence, if a match occurs; otherwise it returns null:
unsafe static int* Find(int* pi, int size, int value) { for (int i = 0; i < size; ++i) { if (*pi == value) { return pi; } ++pi; } return null; }end example] Paragraph 131 In an unsafe context, several constructs are available for operating on pointers:
| |
Jagger Software Ltd | |
Company # 4070126 | |
VAT # 762 5213 42 |