Skip to main content
  1. About
  3. For Teams
Asked
Modified 4 years, 6 months ago
Viewed 500 times
0

The form class shown here has a method that handles a button click event. A local value type x is declared and initialised. I understand that this is located in the stack frame for the button code for the duration of the method. The button code also creates an instance of the class foo, with the name f, and calls its method doSomething. I understand that the stack frame for the button now contains a reference to the object f which is on the heap. The doSomething method of object f declares and initialises a local value type y. Where is y stored? Is it on the same stack? Is it on the heap, in-line with the object f? or, when doSomething calls doSomethingElse, is there a different stack involved? Presumably, the same mechanism is used when one form instantiates another?

Public Class Form1
    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Dim x As Integer
        x = 5
        Dim f As New foo
        f.doSomething()
    End Sub
End Class

Public Class foo
    Public Sub doSomething()
        Dim y As Integer
        y = 6
        Call doSomethingElse()
    End Sub

    Public Sub doSomethingElse()
        Dim z As Integer
        z = 7
    End Sub
End Class
Share
Improve this question
8
  • I think all methods use the same stack.
    Precious Uwhubetine
    –  Precious Uwhubetine
    2019-09-21 19:47:35 +00:00
    Commented Sep 21, 2019 at 19:47
  • As an implementation detail, value types like integers are stored on the stack. Reference types (like foo) are stored in the heap.
    R.J. Dunnill
    –  R.J. Dunnill
    2019-09-21 20:13:12 +00:00
    Commented Sep 21, 2019 at 20:13
  • Here is a good article that may help with your question. c-sharpcorner.com/article/…
    Mary
    –  Mary
    2019-09-22 18:31:18 +00:00
    Commented Sep 22, 2019 at 18:31
  • I appreciate the responses so far and the various articles out there make sense but only to a point. I am still uncertain how things work in a Windows Forms application. Some of the code in my example is written within a form class. There could be several sub-routines/methods within a form class. A form object is created when the application runs. This object is presumably a reference type on a heap somewhere - so which program maintains the stack containing the form's methods when they start to call each other? If one form launches another, is the same stack used?
    Drummy
    –  Drummy
    2019-09-23 05:40:32 +00:00
    Commented Sep 23, 2019 at 5:40
  • What are you trying to find out with this questioning? whats the endgame?
    Ess Kay
    –  Ess Kay
    2019-09-25 12:42:00 +00:00
    Commented Sep 25, 2019 at 12:42

1 Answer 1

Reset to default
1

All variables would be in the same stack unless you multithread. The form would go into the heap.

Stack is used for static memory allocation and Heap for dynamic memory allocation, both stored in the computer's RAM .

Variables allocated on the stack are stored directly to the memory and access to this memory is very fast, and it's allocation is dealt with when the program is compiled. When a function or a method calls another function which in turns calls another function etc., the execution of all those functions remains suspended until the very last function returns its value. The stack is always reserved in a LIFO order, the most recently reserved block is always the next block to be freed. This makes it really simple to keep track of the stack, freeing a block from the stack is nothing more than adjusting one pointer.

Variables allocated on the heap have their memory allocated at run time and accessing this memory is a bit slower, but the heap size is only limited by the size of virtual memory . Element of the heap have no dependencies with each other and can always be accessed randomly at any time. You can allocate a block at any time and free it at any time. This makes it much more complex to keep track of which parts of the heap are allocated or free at any given time. enter image description here

You can use the stack if you know exactly how much data you need to allocate before compile time and it is not too big. You can use heap if you don't know exactly how much data you will need at runtime or if you need to allocate a lot of data.

In a multi-threaded situation each thread will have its own completely independent stack but they will share the heap. Stack is thread specific and Heap is application specific. The stack is important to consider in exception handling and thread executions.

ref: http://net-informations.com/faq/net/stack-heap.htm

More Detail

Which objects are allocated on the stack and which objects are allocated on the heap?

Note: you should never say "reference types are allocated on the heap while value types are allocated on the stack", this is a commonly repeated mistake and sets off a red flag for an experienced interviewer.

Reference types (classes, interfaces, delegates) are always allocated on the heap.

When you pass a reference object as a parameter or assign it to a variable, you're in fact passing its reference. The reference (not the referenced object) can be allocated both on the stack or on the heap.

By passing a reference to an object, you're telling where that object is located on the heap so that your code can access it.

Every time an object is passed as a reference, the reference itself is copied. This means that you can change the reference to point to a different object without affecting the previous object itself or other references pointing to it. A reference is lightweight and is always constant size (32 bit or 64 bit depending on OS bitness) so copying it (and thus passing around reference types) is considered cheap.

Value types (derived from System.ValueType, e.g. int, bool, char, enum and any struct) can be allocated on the heap or on the stack, depending on where they were declared.

If the value type was declared as a variable inside a method then it's stored on the stack. If the value type was declared as a method parameter then it's stored on the stack. If the value type was declared as a member of a class then it's stored on the heap, along with its parent. If the value type was declared as a member of a struct then it's stored wherever that struct is stored. Starting with C#7.2, a struct can be declared as ref struct, in which case it will always be allocated on the stack, preventing it from being declared inside reference types.

Instances of value types are passed by copy (unless used with reference semantics, see below). This means that every time a value type is assigned to a variable or passed as parameter, the value is copied.

Because copying value types can get expensive depending on the size of the object, it's not recommended to declare memory-heavy objects as value types.

Since every type in C# derives from System.Object, value types can be assigned to variables or passed to methods that expect an object. In such cases, the value is copied and stored on the heap wrapped as a reference type, in an operation known as boxing.

ref: https://dev.to/tyrrrz/interview-question-heap-vs-stack-c-5aae#targetText=In%20C%23%20there%20are%20two,can%20be%20accessed%20from%20anywhere.

Share
Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

Drummy
Drummy
I understand object members are stored in-line with the object, in the heap. E.G. if the form included variables declared within the class (not within a method), or a reference type E.G. an array, they would be stored in-line with the object data and pointers would be maintained on the stack. This makes sense if there is a 'main' program. But what if a method of a Windows form (E.G. a button click event handler) declares a local variable? Is this variable maintained on the stack or is it in-line with the form object? Does the form method behave like a main program in, say, C?
Ess Kay
Ess Kay
@Drummy I've updated the answer. in short, if its on the heap already, everything it creates will stay on heap since its not Local variable to application itself
Drummy
Drummy
You have hit the nail on the head when it comes to my confusion... Since the form is an object, it is on the heap. if everything the form creates is on the heap, it follows that all variables declared locally within a form method are also on the heap. With a Windows Forms Application in VB.NET (or C#), when I step through the code I can see a call stack, so which program maintains this? Is there a 'main program' somewhere behind the scenes? And does it not follow that the stack only every contains references?
Ess Kay
Ess Kay
It would be a combination of both. The reference to your class object would be on the stack, while the object & data itself would be on the heap. it would look similar to this i.sstatic.net/yZK6t.png
Drummy
Drummy
It's starting to make sense. Please correct me if I'm wrong, with a VB.NET Windows Form application, if a sub-procedure (i.e. a form method) declares and assigns, say, an integer type, the data is on the heap with the rest of the form object and the stack contains a reference to this - is this right? Having researched some more, I see that a VB.NET Windows Forms application has a hidden 'sub main'. This can be replaced with a custom sub main in a module (which you can designate as the startup program). If a custom sub main declares an integer, the data will be on the stack - is this right?

Your Answer

Post as a guest

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.

Morty Proxy This is a proxified and sanitized view of the page, visit original site.