Why are pointers reference types?

Question

This week I've been working on some reflection-based code, and during unit testing found an unexpected condition: pointers are reference types. The C# code typeof(int).MakePointerType().IsClass returns true.

I checked in my just-arrived Annotated CLI Standard, and sure enough, pointers are clearly defined as reference types.

This was surprising to me, coming from a C++ background. I had just assumed that pointers would be value types.

Is there a particular reason why pointer types are reference types and not value types?

Update (clarification)

When talking about pointers and references, things often get confusing regarding the "pointer" and "pointee". So here's some clarification.

Types can be reference types or value types, but variables are a bit different. (Sorry, I haven't had a chance to read through my CLI Standard, so the terminology and concepts may be wrong - correct me, please!)

Given this code (local variable concepts for reference types):

var x = new MyClass();
var y = x;

The variables x and y are not actually reference types, but they're references to an object that is a reference type (MyClass is a reference type). In other words, x and y are not instances of the reference type; they only refer to an instance of reference type.

Given this code (local variable concepts for value types):

var x = 13;
var y = x;

The variables x and y are instances value types (or at least act like they're instances).

So then we come to this code:

var i = 13;
var x = &i;
var y = x;

If the pointer type is a reference type, then this is how I interpret the statement x = &i:

1. An instance of type int* is created, pointing to i.
2. Since pointers are reference types, this instance is created on the heap (assuming that all reference types are placed on the heap, an implementation detail).
3. x is a reference to this pointer instance.
4. The pointer instance will eventually be garbage collected, just like other reference types.
5. When y = x is executed, the reference is copied. Both y and x refer to the same instance of the pointer object.

Perhaps I'm completely wrong in this interpretation.

Coming from a C++ background, it would make more sense to me for pointers to be value types, so the statement x = &i is just assigning the address of i to the instance of the value type x, and y = x copies that address value into y. No "pointer object" would be created on the heap.

Answer 1

They're reference types because they don't contain the actual value of the target object: just like references, they merely "point to" the target object.

Answer 2

Consider:

MyClass x = new MyClass();

Here, MyClass is a reference type, and if you looked through reflection, x would be called a reference type. But, under the hood, x is actually a pointer.

Answer 3

typeof(int).MakePointerType().IsPointer

seems there is a distinction.

Answer 4

This is just a theory, but would it have something to do with the fact that because of the garbage collection system and heap compaction, pointers have to be adjusted when objects are moved around in memory. By making managed pointers reference types, they can be re-pointed in the same way that any other reference is, rather than having to make them a special case.

Update

An excellent article by Wesner Moise: "Pointers UNDOCUMENTED".

In the article he describes how managed pointers are adjusted during heap compaction.