内存分配接口

Question

I know interface cannot be instantiated, but if we assign it to an object, could anyone please explain how the memory gets allocated to it. For ex:

ITest obj = (ITest) new TestClass1();  //TestClass1 is a class which implements ITest
obj.MethodsDefinedInInterface();

Does ITest converts to object to save properties and methods of TestClass1.

Answer 1

I'm not sure exactly what you mean by 'allocation'. The following statement makes two seperate 'allocations':

TestClass1 test = new TestClass1();

First is the new TestClass1() statement which allocates sizeof(TestClass1) on the heap. Second, the assignment of the address of the heap allocation is stored in the variable test , which is allocated on the stack as sizeof(object *) (ie IntPtr.Size, or 32/64 bits based on the hardware+OS+software running).

The following statement is EXACTLY the same in 'allocations':

ITest test = new TestClass1();

The only difference between the two is the methods available to be called on the variable test .

Note: This is NOT true with a structure that implements an interface. Interfaces must be a reference type, and as you know, structs are not. This is called boxing in .NET and allows a struct to be referenced as if it were a reference type by first placing a copy of the struct on the heap.

So we now re-evaluate the statement:

TestSTRUCT1 test2 = new TestSTRUCT1();

This 'allocates' sizeof(TestSTRUCT1) on the stack at the named variable test2 . (Not sure what the impact of the assignment to new TestSTRUCT1() is, it may create an additional stack copy but that should be removed immediately after the assignment.

If we then assign this value to an interface:

ITest test3 = test2;

We have now made two more allocations. First the structure is copied to the heap. Then the address of that heap-resident structure is placed in a newly 'allocated' variable test3 (on the stack).

Answer 2

It should be similar to:

TestClass1 test = new TestClass1();  
ITest obj = (ITest) test;
obj.MethodsDefinedInInterface();

Which, I think, answers your question.

Answer 3

Memory gets allocated for the object that impliments interface like any other object. whether or not it impliments an interface is just a property of the object

Answer 4

Memory is allocated only for TestClass1 instance. Interface ITest is only a type of reference, which points to that allocated memory.

Answer 5

Does ITest converts to object to save properties and methods of TestClass1

ITest is a type. TestClass1 properties and methods are still there just you cannot access it via obj variable.

Answer 6

Its quite simple acutally. You allocate for TestClass1 and then cast it back to the interface. Note that you're not instantiating a interface, you're instantiating a class that implements the interface and then calling the interface method which is implemented (obligatorily) in the concrete class!

another way to put it is:

TestClass1 test = new TestClass1();
ITest obj = (ITest) test;
obj.MethodsDefinedInInterface();

note that the allocated area is for TestClass1! it not grow or shrink because of the cast!

Answer 7

interfaces simply make sure that objects meet a cerain criteria both tecnically and logically at compile time.

When executing the code and using an interface memory will be allocated as if you would just instantiate the object using the class.

So there's no difference (in terms of memory allocaton) between

ITest obj = (ITest) new TestClass1();  //TestClass1 is a class which implements ITest
obj.MethodsDefinedInInterface();

and

TestClass1 obj = new TestClass1();  //TestClass1 is a class which implements ITest
obj.MethodsDefinedInInterface();

Answer 8

So, first, when you enter this method space will be allocated on the stack for all parameters, if applicable, the return value, if applicable, and all local variables for that method. For what we've shown here the only local variable that needs to be allocated is obj . obj is an interface, and so requires enough space for a single reference (32 bits on 32 bit systems, 64 bits on 64 bit systems). Since there are no other local variables, return values, or parameters, we will only take up that one word on the stack.

Because we're allocating a single object ( new TestClass1() ) and assuming that object is a class (and not a struct , because naming a struct TestClass1 would be very mean) enough space will be allocated on the heap to account for a single instance of TestClass . That space will be enough space for every single field (regardless of accessibility) plus a little extra for some object overhead. A reference to this newly allocated object will go in the spot on the stack that is allocated for our local variable.

This is all ignoring the registers utilized by the processor at runtime; due to the complex transformations and optimizations of compilers, jitters, operating systems, processor hardware, etc. I couldn't begin to try to predict what that would take. Fortunately, thanks to all of those abstractions, I don't really need to care.