In this chapter, you will learn about the basics of pointers. You will learn to declare and implement pointers. In addition, you will learn about using point-

ers with managed code. Finally, you will learn to compile unsafe code.

Pointers

Pointers are not a new concept for C and C++ programmers. A pointer is a variable similar to a reference and points to an address in memory. A pointer stores the actual memory address and makes it available to you.

Pointers are extensively used in C and C++ for dynamic allocation of memory and to directly access the memory. However, if pointers are not used properly, they may lead to memory corruption. To avoid such situations, C# hides most of the memory management operations from the end user. However, there may be cases where you need to have direct access to memory. C# allows you to use pointers in such cases.The following list contains some of the cases where you need to access memory addresses by using pointers.

You may be required to use pointers when you are working with existing code written in C or C++ that uses pointers.

You may require pointers to create applications with high performance requirements.

Pointers allow you to work with the underlying operating system by providing an interface between the program code and the operating system.

When you are debugging an application, you may be required to have direct access to a particular memory location. In addition to various debugging options provided by Visual Studio .NET, pointers help you in this case by allowing you to access the data stored at the specified memory location.

Pointers also provide you with an interface to work with advanced COM (Component Object Model ) applications containing structures that use pointers.

UNSAFE CODE Appendix A 833

As discussed earlier, if pointers are not used effectively, they can be a problem to programmers. The following list contains some of the problems faced by programmers while using pointers.

Working with pointers requires extensive and high-level programming. If you are not careful while programming with pointers, you may introduce errors in your code, which may even result in the program crashing.

When a pointer is no longer used by any program, you need to deallocate its memory. If you forget to deallocate the memory associated with the pointer, it may lead to unpredictable problems in your code. Debugging these problems can be time-consuming and tedious.

Pointers make the address of a memory location transparent to the users. Therefore, it becomes possible for users to manipulate the memory addresses. This may introduce errors in your code by making it unsafe to use.

While writing a program that uses pointers, you may make your pointer point to a wrong memory location. Therefore, when your program code accesses an incorrect memory location, it may produce errors or may even result in the program crashing.

The major problem with using pointers in the program code used to be because of the garbage collection system of CLR (common language runtime). The garbage collection system operates in the background to deallocate memory to objects that are no longer used by any program. The garbage collection system also causes the movement of objects within memory. Each time an object is moved, C# updates its reference. However, there is no mechanism by which the programmer is informed about the new memory location of the object. This may cause your pointer to point to a different memory location, thereby introducing errors in the program. As a solution to this problem, the .NET Framework introduced the concept of unsafe code. You will learn about unsafe code later in this appendix.

In spite of these problems, programmers have been extensively using pointers in C and C++. This is mainly because pointers offer several advantages to programmers, thereby helping them to write complex applications. Some of the advantages of using pointers in your code include backward compatibility with code

written in C and C++. Pointers also help you to access and manipulate data easily and efficiently, thereby increasing the performance of your application.

Because of the advantages of pointers, C# has retained pointers in some capacity. However, to prevent memory corruption in C#, pointers are used only within blocks of code for which the pointer is required.This restricts the programmer to using pointers only when they are required and marked. You can use the unsafe keyword to mark the block of code in which you need to declare a pointer. A class, method, struct, constructor, or block of code within a method can be marked as unsafe. However, you cannot mark a static constructor as unsafe.

When you mark code as unsafe, you inform the compiler that the program is not sure whether the code is safe to execute. Therefore, to execute code marked as unsafe, you need to give full trust to the program code. As discussed earlier, the major problem that you face while working with pointers is because of the garbage collection system of CLR. Therefore, to solve this problem, C# runs the code marked as unsafe outside the garbage collection system. This allows you to perform memory management processes directly. Therefore, you can only declare a pointer in the set of statements marked as unsafe.

Declaring Pointers

The following syntax shows how to declare a pointer. An asterisk (*) is used to declare a pointer.

unsafe class Class1

{

int *pointer1;

}

The preceding code marks the class Class1 as unsafe.The pointer named pointer1 is declared in this class. You can also mark a variable as unsafe. However, you can only do this in the block of code that is marked unsafe. After you mark code as unsafe, you need to inform the compiler that your program contains unsafe code. This will allow you to declare pointers in the unsafe code.To inform the compiler about the presence of unsafe code, you use the flag unsafe with the compile command. You will learn about the compilation of unsafe code later in this appendix.

C# allows you to declare more than one pointer of the same data type in a single command. In this case, you will use only one asterisk sign, although in C++, you