Answer to Question #8960 in C# for naveed hussain

Question

please explain pointer

Answer 1

C# also supports pointers in a limited extent. A pointer is nothing but a variable that holds the memory address of another type. But in C# pointer can
only be declared to hold the memory address of value types and arrays. Unlike
reference types, pointer types are not tracked by the default garbage collection
mechanism. For the same reason pointers are not allowed to point to a reference
type or even to a structure type which contains a reference type. We can say
that pointers can point to only unmanaged types which includes all basic data
types, enum types, other pointer types and structs which contain only unmanaged
types.

Declaring a Pointer type

The general form of declaring a pointer type is as shown below

type *variable_name;

Where * is known as the de-reference operator. For example the following statement


int *x ;

Declares a pointer variable x, which can hold the address of an int type. The reference operator (&) can be used to get the
memory address of a variable.

int x = 100;

The &x gives the memory address of the variable x, which we can assign to a pointer variable


int *ptr = & x;.
Console.WriteLine((int)ptr) // Displays the memory address
Console.WriteLine(*ptr) // Displays the value at the memory address.

Unsafe Codes

The C# statements can be executed either as in a safe or in an unsafe context. The statements marked as unsafe by using
the keyword unsafe runs out side the control of Garbage Collector. Remember that
in C# any code involving pointers requires an unsafe context.

We can use the unsafe keyword in two different ways. It can be used as a modifier to a
method, property, and constructor etc. For example

// Author: [e-mail]
using System;
class MyClass
{
public unsafe void Method()
{
int x = 10;
int y = 20;
int *ptr1 = &x;
int *ptr2 =
&y;
Console.WriteLine((int)ptr1);
Console.WriteLine((int)ptr2);
Console.WriteLine(*ptr1);
Console.WriteLine(*ptr2);
}
}
class MyClient
{
public static void Main()
{
MyClass mc = new MyClass();
mc.Method();
}
}

The keyword unsafe can also be used to mark a group of statements as unsafe as shown below.

// Author: [e-mail]
//unsafe blocks
using System;
class MyClass
{
public void Method()
{
unsafe
{
int x = 10;
int y = 20;
int *ptr1 = &x;
int *ptr2 = &y;
Console.WriteLine((int)ptr1);
Console.WriteLine((int)ptr2);
Console.WriteLine(*ptr1);
Console.WriteLine(*ptr2);
}
}
}
class MyClient
{
public static void Main()
{
MyClass mc = new MyClass();
mc.Method();
}
}

Pinning an Object

The C# garbage collector can move the objects in memory as it wishes during the garbage
collection process. The C# provides a special keyword fixed to tell Garbage
Collector not to move an object. That means this fixes in memory the location of
the value types pointed to. This is what is known as pinning in C#.

The fixed statement is typically implemented by generating tables that describe to
the Garbage Collector, which objects are to remain fixed in which regions of
executable code. Thus as long as a Garbage Collector process doesn't actually
occur during execution of fixed statements, there is very little cost associated
with this. However when a Garbage Collector process does occur, fixed objects
may cause fragmentation of the heap. Hence objects should be fixed only when
absolutely necessary and only for the shortest amount of time.

Pointers & Methods

The points can be passed as argument to a method as showing below. The methods can also return a pointer.

// Author: [e-mail]
using System;
class MyClass
{
public unsafe void Method()
{
int x = 10;
int y = 20;
int *sum = swap(&x,&y);
Console.WriteLine(*sum);
}
public unsafe int* swap(int *x, int *y)
{
int sum;
sum = *x + *y;
return ∑
}
}
class MyClient
{
public static void Main()
{
MyClass mc = new MyClass();
mc.Method();
}
}