我真的不明白C＃的参考

Question

English is not my mother tongue, exactly I am a Chinese. I'll be sorry if I cannot express my idea clearly.

I used to programme with c++. I really dont's understand the reference of C#.Many people tell me the reference is similar to the pointer in c++.Such as below

Person Foo = new Person(); // C#
Person *Foo = new Person(); // C++.

Many times it works well.While many C# coders also tell me that the instance of class is just the Foo.Foo has name.whiched is called Foo.name.Foo has age,which is called Foo.age. It seems the thought is more easy to be used to code.But this thought does not conform to Memory model .

Please tell me What the reference is in c#.a object,or more likely a pointer?Thx.

Answer 1

C# has garbage collection and by default, it does not support pointers. You can however, use pointers as outlined here http://msdn.microsoft.com/en-us/library/t2yzs44b(v=VS.80).aspx

Answer 2

You will want to get familiar with the different between Reference Type and Value Type.

Example is below:

void Main()
{
    Foo A = new Foo{Age = 16}; //A creates a space in memory for the data of Foo and points to that memory location
    Foo B = A; //B just creates a variable and points to the memory location created by A

    A.Bar();
    B.Bar();

    //Result
    //Your Age is 16
    //Your Age is 16

    A.Age = 24;

    A.Bar();
    B.Bar();

    //Result
    //Your Age is 24
    //Your Age is 24  <----- B is pointing to the same location as A and reflects the changes on call.

    FooValueType E = new FooValueType{Age = 23};
    FooValueType F = E;

    E.Bar();
    F.Bar();

    //Result
    //Your Age is 23
    //Your Age is 23

    E.Age = 56;

    E.Bar();
    F.Bar();

    //Result
    //Your Age is 56
    //Your Age is 23
}

public class Foo  //These object are by reference
{
    public int Age { get; set; }
    public void Bar()
    {
       Console.WriteLine("Your Age is {0}", Age);
    }
}

public struct FooValueType //These object are by value
{
    public int Age { get; set; }
    public void Bar()
    {
       Console.WriteLine("Your Age is {0}", Age);
    }
}

Answer 3

In C# when you say Person Foo = new Person();

1. new Person() creates an object of the class Person by allocating memory in heap section
2. returns a reference to this object (ie nothing but reference to memory allocated ) of type Person.

While Foo catches this reference and with this reference you can access the objects properties ie its methods and variables .

In C++,

It follows the same steps but in c++ you catch a reference to object in a pointer of type Person .

---

More specifically new internally calls operator new function to allocate a memory dynamically to create objects.

In the image shown below Person p ( on stack ) creates an reference to an object returned by new Person() .

age and name are the member variables of the Object.So we can easily access them using p.name and p.age .

---

More to add about stack and heap memory allocation in both c# and c++

• The reference Foo always gets a memory on stack
• Where object ie here new Person() gets memory on heap and in case of C# more specifically it gets memory on managed heap

Updates

When you say new Person() it internally allocates memory for the Object Of the type - person .This object is composed of Persons members like shown in image.

You then can do two thing

1. Either you catch this reference in variable of type Person eg Person p = new Person(); Here p is a reference to memory location of object.So I can easily access Objects member using p .

2. Just don't store the reference directly use it eg new Person().age will give me Persons age.This is called an anonymous Object.

Answer 4

With respect to the variable behaviors, there are two kinds of types in C#:

• Value types .
• Reference types .

Value type variables carry the actual object as their value. Assigning a value type variable assigned from another value type variable copies the whole object . In C++ terms, this is like using a variable of the class type (not a pointer to the class) like for example when you're making a stack allocated instance. C# however doesn't give you that choice, but restricts this behavior only to such types as structs.

Reference type variables carry a reference to the actual object as their value. A reference to the actual object will most probably at least in involve the memory address of the object (but the details are hidden from you). Assigning a reference type variable from another reference type variable copies the reference, not the object , so now the two variables point to the same object. In C++ terms, this is like having a pointer variable of the class. C# however defaults to this behavior for variables of such types as classes and interfaces (and there's no way to jump back to the other behavior, as far as I know). The major difference between C# references and C++ pointers is that C++ pointers support arithmetic, while C# references don't. This is one of the ways C# ensures what we call memory safety . (C# does offer pointers, but they are used rarely and a lot of the time they are useful in interoperability scenarios. It'll likely be a long time before you ever need to use a pointer in C#.)

In the end, you can think that the C# reference is close to the C++ pointer (but, as outlined above, there are differences because the languages behave differently and give you different degrees of control and protection).

Answer 5

Have you googled that before asking? There are many top resources on the internet and also some nice e-books.

However, here´s the memory model used in C# (in Java and PHP nearly as well):

1. Every object is inherited from the class object. That means, that nearly everything is an object in C#.
2. You don´t need to use pointer anymore. There´s nearly no need in C# for it. When you create an object, you will get back an reference to the instance in the stack. You could also have many references to one single object in stack. The references are located in the heap. This is the default behaviour and you aren´t able to change it, unless you do native code.
3. There´s no need of deleting something. It will be automatically happened by the Garbage Collector. It will be delete every local variable which is created inside a method at the end of it. The Garbage Collector will also delete objects, which got no reference anymore.
4. Internal datatypes are always located at the stack, strings also. For strings, they made an exception here, strings are also treated as simple datatypes, not as an object.
5. Every internal datatype will be copied per default, if you eg have give an int value to a method. This pattern is called "Call-By-Value". Every object will be passed by a new reference. That means, if you give an object as a method paremter, you will just get inside the method a new reference to the object. This pattern is called "Call-By-Reference". It´s very important, that you might divide in them.
6. You can change Call-By-Value to Call-By-Reference using the "ref" keyword. You could also define only an out parameter. That means, that doesn´t matter what value you give to a method. It will only return something at the end of the method. This can be done by using the "out" keyword in C#.
7. In logical conclusion to this, you are not able to overflow the heap in C#. Because the stack would get an overflow before...
8. There´s no difference anymore between static and object-calls. It´s always the dot. So, you could call public members of a class in the same way you would also call public static members of the class. For static members, you just need to use the class name, or inside the class without any keyword before the variable name. You call object/class member by using a reference to it.
9. You could only inherit from one class. Multiple inheritance is not supported it C# (Java and PHP as well).
10. Stdout commands (>> and >) changes to "Console" or to any other stream reference, eg file output streams.

Edit:

A child class inherits everything from the base class, also private and protected members/methods. But you can only access public and protected members/methods, unless you dont´ make use of reflections.

Hope, this helps you in order to unterstand C# a bit more...

Answer 6

The reference is a pointer to an object.

You can use "real" pointers in C# in unsafe code: here is an example