How to declare a void pointer in C#

How can we declare a void pointer i开发者_JS百科n C#?

void* identifier;

But it needs to be in unsafe as:

unsafe
{
    void* identifier;
}

And unsafe code has to have been allowed for the project.

I'm assuming you mean in managed code, as your question is rather short to do anything but assume.

I think you're either looking for IntPtr or simply any object reference (which is the base type, and the basic equivalent of a null pointer - a reference to "something"). Unless you mean null pointer, in which case you're looking for IntPtr.Zero.

From http://msdn.microsoft.com/en-us/library/y31yhkeb%28VS.80%29.aspx

Visual Studio 2005Other Versions22 out of 43 rated this helpful - Rate this topic In an unsafe context, a type may be a pointer type as well as a value type or a reference type. A pointer type declaration takes one of the following forms:

type* identifier; void* identifier; //allowed but not recommended Any of the following types may be a pointer type:

sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, or bool.

Any enum type.

Any pointer type.

Any user-defined struct type that contains fields of unmanaged types only.

Pointer types do not inherit from object and no conversions exist between pointer types and object. Also, boxing and unboxing do not support pointers. However, you can convert between different pointer types and between pointer types and integral types.

When you declare multiple pointers in the same declaration, the * is written along with the underlying type only, not as a prefix to each pointer name. For example:

int* p1, p2, p3; // Ok

int *p1, *p2, *p3; // Invalid in C#

A pointer cannot point to a reference or to a struct that contains references because it is possible for an object reference to be garbage collected even if a pointer is pointing to it. The GC does not keep track of whether an object is being pointed to by any pointer types.

The value of the pointer variable of type myType* is the address of a variable of type myType. The following are examples of pointer type declarations:

Example Description

int* p

p is a pointer to an integer

int** p

p is a pointer to pointer to an integer

int*[] p

p is a single-dimensional array of pointers to integers

char* p

p is a pointer to a char

void* p

p is a pointer to an unknown type

The pointer indirection operator * can be used to access the contents at the location pointed to by the pointer variable. For example, for the following declaration,

int* myVariable; the expression *myVariable denotes the int variable found at the address contained in myVariable.

You cannot apply the indirection operator to a pointer of type void*. However, you can use a cast to convert a void pointer to any other pointer type, and vice versa.

A pointer can be null. Applying the indirection operator to a null pointer results in an implementation-defined behavior.

Be aware that passing pointers between methods can cause undefined behavior. Examples are returning a pointer to a local variable via an Out or Ref parameter or as the function result. If the pointer was set in a fixed block, the variable to which it points may no longer be fixed.

The following table lists the operators and statements that can operate on pointers in an unsafe context:

Operator/Statement Use *

to perform pointer indirection.

->

to access a member of a struct through a pointer.

[]

to index a pointer.

&

to obtain the address of a variable.

++ and --

to increment and decrement pointers.

• and -

to perform pointer arithmetic.

==, !=, <, >, <=, and >=

to compare pointers.

stackalloc

to allocate memory on the stack.

fixed statement

to temporarily fix a variable in order that its address may be found.

C# Language Specification For more information, see the following section in the C# Language Specification:

18 Unsafe Code