Yahoo Web Search

Search results

1. Top results related to define heap memory in c

   • Heap Memory in C Programming

     Top Answer

     Answered Apr 18, 2012 · 15 votes

     The heap is part of your process's address space. The heap can be grown or shrunk; you manipulate it by calling brk(2) or sbrk(2). This is in fact what malloc(3) does.

     Allocating from the heap is more convenient than allocating memory on the stack because it persists after the calling routine returns; thus, you can call a routine, say funcA(), to allocate a bunch of memory and fill it with something; that memory will still be valid after funcA() returns. If funcA() allocates a local array (on the stack) then when funcA() returns, the on-stack array is gone.

     A drawback of using the heap is that if you forget to release heap-allocated memory, you may exhaust it. The failure to release heap-allocated memory (e.g., failing to free() memory gotten from malloc()) is sometimes called a memory leak.

     Another nice feature of the heap, vs. just allocating a local array/struct/whatever on the stack, is that you get a return value saying whether your allocation succeeded; if you try to allocate a local array on the stack and you run out, you don't get an error code; typically your thread will simply be aborted.

     Check all answers on Stack Overflow

     1/5

   • How to define a variable in heap memory in a struct with C++?

     Top Answer

     Answered Dec 14, 2016 · 4 votes

     I'd do something like this:

     //Switched to a class because we need some encapsulation or this will be bug-prone.class matrixImage{ //Do you need this? What kind of object is "Image"? //Image Img; std::vector<Color> pixel_data; int Width; int Height;public: matrixImage(int width = 1, int height = 1) : Width(width), Height(height), pixel_data(width * height) { } //You can add bounds-checking if you need it, i.e. make sure y is less than Height, //make sure x is less than Width. Not every application needs it, and you need a //clear semantic of "what should happen" if you specify an invalid index. Color & get_color(int x, int y) { return pixel_data[y * Width + x]; } //We have two versions to handle the case where your object is made "const" Color const& get_color(int x, int y) const{ return pixel_data[y * Width + x]; } //Hey, we can use the function we just defined above this one! void set_color(int x, int y, Color c) { get_color(x, y) = c; } //This only resizes the canvas. Doing proper "Resizing" is beyond the scope of what //we're discussing here. void set_size(int new_width, int new_height) { std::vector<Color> new_data(new_width * new_height); //This case is pretty easy if(new_width == Width) { std::copy( pixel_data.begin(), pixel_data.begin() + std::min(pixel_data.size(), new_data.size()), new_data.begin() ); //This gets complicated } else if(new_width < Width) { for(size_t y = 0; y < std::min(Height, new_height); y++) { std::copy( pixel_data.begin() + y * Width, pixel_data.begin() + y * Width + new_width, new_data.begin() + y * new_width ); } //Similar logic, but slightly different. } else { for(size_t y = 0; y < std::min(Height, new_height); y++) { std::copy( pixel_data.begin() + y * Width, pixel_data.begin() + (y + 1) * Width, new_data.begin() + y * new_width ); } } pixel_data = new_data; Width = new_width; Height = new_height; } //I leave this last one as an exercise to the reader, as it's beyond my expertise. void resize(int new_width, int new_height);};

     This will handle dynamic memory allocation for you (and of course, deallocation) and give you some basic functionality to work directly with the underlying data if you absolutely need to.

     Check all answers on Stack Overflow

     2/5

   • Define data type of enum in C for memory

     Top Answer

     Answered Dec 01, 2016 · 6 votes

     The C standard says that enumeration constants, that is the "members" of the enum, must be compatible with type int. But the enumeration variable itself is allowed to be of other integer types. If you think this doesn't make any sense, it is because it doesn't: the C standard is irrational when it comes to enums.

     As for how to pick which integer type an enumeration variable corresponds to, that's unfortunately a decision made by the compiler, not the programmer. On an 8-bit Atmel, an enum variable is either 8 or 16 bits.

     Several compilers gives an option to set the size of an enum through non-standard compiler options. To use such features might not be a good idea regardless, as that would make the code non-portable.

     However, regardless of the size of an enum, the compiler may (and likely will) optimize expressions where the enum is present, just as it may optimize any expression containing small integer types to not use int for the calculation, as the C standard otherwise mandates through integer promotion.

     In case you have very extreme performance requirements, don't use enums, but uint8_t. But if you had extreme performance requirements, then you wouldn't use a hobbyist 8-bit MCU in the first place! So it turns out that your concern is a non-issue.

     Go ahead and use enum and let the compiler worry about optimizations.

     Check all answers on Stack Overflow

     3/5

   • Memory allocation areas in C++ (Stack vs heap vs Static)

     Top Answer

     Answered Jan 05, 2013 · 14 votes

     A couple of side notes first. The correct terminology is automatic rather than stack, dynamic rather than heap. The other is that with C++11 there are now four rather than three types of memory. C++11 adds thread local memory to the mix.

     Automatic memory is fast because it is implemented using the call stack on most machines. All it takes is to adjust the stack pointer by the right amount and voila! memory is allocated. Dynamic memory requires a whole lot more work underneath the hood. The requisite memory might not be attached to the process, and getting that to happen requires going through the OS. Even if memory is available, the dynamic memory management tools still have to find it and mark it as in use.

     Static memory is "allocated" as a part of the compilation and linking process. When you define a static variable in some source file, the compiled code contains special instructions for the linker to reserve space for that variable. The compiler also converts your C/C++ code to machine code. The linker combines all of those different chunks of data and code and resolves addresses to form the executable binary image. When you run your program, that binary image is loaded into (virtual) memory. The memory for that static variable exists as soon as the program starts executing.

     As far as performance is concerned, it's best not to worry too much about performance ahead of time. While static memory is fast, there are lots and lots of drawbacks. The last thing you want to do is to make all of your data static.

     Check all answers on Stack Overflow

     4/5

   • C++ Assigning heap memory to each element(struct) in array of structs

     Top Answer

     Answered Jun 15, 2016 · 1 votes

     A type A* doesn't hold pointers which should be allocated individually with new. An A* is a contiguous block of memory which holds 1 or more complete instances of A.

     This means that

     A* array = new A[3];-

     will allocate something like

     | A | A | A |-

     and each "cell" will be large sizeof(A) bytes. So in your case you already have 5 A instances, which will be already constructed.

     If you want to have indipendent A instances which are allocated on heap then you don't need a A* but a A**.

     A** array = new A*[3];-

     This creates a contiguous array of 3 A* elements, which are pointers to A sort of:

     | A* | A* | A* |-

     ad each cell is large sizeof(A*).

     Now you can assign to an element of the array a specific instance of A allocated on heap. Eg:

     array[0] = new A();-

     which yields something like

     | A* | ... | | --> | A |

     Check all answers on Stack Overflow

     5/5

   Show moreShow less

2. stackoverflow.com › questions › 2308751malloc - What is a Memory Heap? - Stack Overflow

   stackoverflow.com › questions › 2308751

   • Cached

   Feb 22, 2010 · A very simple explanation is that the heap is the portion of memory where dynamically allocated memory resides (i.e. memory allocated via malloc). Memory allocated from the heap will remain allocated until one of the following occurs: The memory is free'd; The program terminates

   • Presumably you mean heap from a memory allocation point of view, not from a data structure point of view (the term has multiple meanings). A very...
   • A memory heap is a location in memory where memory may be allocated at random access. Unlike the stack where memory is allocated and released in a...
   • Heap is just an area where memory is allocated or deallocated without any order. This happens when one creates an object using the new operator or...
   • You probably mean heap memory, not memory heap. Heap memory is essentially a large pool of memory (typically per process) from which the running p...
   • A memory heap is a common structure for holding dynamically allocated memory. See Dynamic_memory_allocation on wikipedia. There are other structur...
   • It's a chunk of memory allocated from the operating system by the memory manager in use by a process. Calls to malloc() et alia then take memory fr...
   • Memory organization is divided into two parts: heap memory and stack memory. Heap memory is the main working memory, lowest address is the startin...

3. stackoverflow.com › questions › 10200628Heap Memory in C Programming - Stack Overflow

   stackoverflow.com › questions › 10200628

   • Cached

   Apr 6, 2017 · 10. The heap is the diametrical opposite of the stack. The heap is a large pool of memory that can be used dynamically – it is also known as the “free store”. This is memory that is not automatically managed – you have to explicitly allocate (using functions such as malloc), and deallocate (e.g. free) the memory.

   • The heap is part of your process's address space. The heap can be grown or shrunk; you manipulate it by calling brk(2) or sbrk(2). This is in fact...
   • Basically, after memory is consumed by the needs of programs, what is left is the heap. In C that will be the memory available for the computer, fo...
   • Reading through this, this is actually beyond the realms of C. C doesn't specify that there's a heap behind malloc; it could just as easily be call...

4. People also ask

   Why do we use heap memory in C++?

   • In C++ or C, data created on the heap will be pointed to by pointers and allocated with new or malloc respectively. We can use heap memory if you don’t exactly know the actual size of data needed at run time or if you need to allocate a lot of data. It is responsible for memory leaks.

   What is a Memory Heap? - GeeksforGeeks

   www.geeksforgeeks.org/what-is-a-memory-heap/

   See all results for this question

   What is a heap in C?

   • The Heap The heap is a region of your computer's memory that is not managed automatically for you, and is not as tightly managed by the CPU. It is a more free-floating region of memory (and is larger). To allocate memory on the heap, you must use malloc () or calloc (), which are built-in C functions.

   What and where are the stack and heap?

   stackoverflow.com/questions/79923/what-and-where-are-the-stack-and-heap

   See all results for this question

   What is a memory heap?

   • A memory heap is a location in memory where memory may be allocated at random access. Unlike the stack where memory is allocated and released in a very defined order, individual data elements allocated on the heap are typically released in ways which is asynchronous from one another.

   malloc - What is a Memory Heap? - Stack Overflow

   stackoverflow.com/questions/2308751/what-is-a-memory-heap

   See all results for this question

   What is a heap in a data structure?

   • Presumably you mean heap from a memory allocation point of view, not from a data structure point of view (the term has multiple meanings). A very simple explanation is that the heap is the portion of memory where dynamically allocated memory resides (i.e. memory allocated via malloc ).

   malloc - What is a Memory Heap? - Stack Overflow

   stackoverflow.com/questions/2308751/what-is-a-memory-heap

   See all results for this question

5. www.geeksforgeeks.org › what-is-a-memory-heapWhat is a Memory Heap? - GeeksforGeeks

   www.geeksforgeeks.org › what-is-a-memory-heap

   • Cached

   • What Is Heap Memory?
   • Advantages of Heap Memory
   • Disadvantages of Heap Memory
   • Problems That Can Be Solved with Heap Memory

   As a result, the heap segment can be requested and released whenever the program needs it. This memory is also global, which means that it can be accessed and modified from wherever in the program it is allocated instead of being localized by the function in which it is allocated. Dynamically allocated memory is referenced using ‘pointers’, which i...

   See full list on geeksforgeeks.org

   Heap doesn’t have any limit on memory size.

   It allows you to access variables globally.

   Garbage collection runs on the heap memory to free the memory used by the object.

   The heap method is also used in the Priority Queue.

   See full list on geeksforgeeks.org

   It takes too much time to execute compared to the stack.

   It takes more time to compute.

   It can provide the maximum memory an OS can provide

   Memory management is more complicated in heap memory as it is used globally.

   See full list on geeksforgeeks.org

   The following are some important points about Garbage Collection. 1. The Java Virtual Machine invokes garbage collection to get rid of unused heap memory objects. It removes every object that is not being used anymore by the running Java program. In this process, unused memory is freed up for other new objects to use. 2. Garbage collection calls th...

   See full list on geeksforgeeks.org

6. dede.dev › posts › Heap-and-Stack-in-C-ProgrammingUnderstanding Heap and Stack using C Programming

   dede.dev › posts › Heap-and-Stack-in-C-Programming

   • Cached

   May 3, 2020 · The heap is a region of memory used for dynamic memory allocation, allowing for the allocation and deallocation of memory at runtime. Unlike the stack, memory allocated on the heap persists until explicitly freed by the programmer. The heap provides flexibility for managing large data structures, arrays, and dynamic memory requirements.

7. www.programiz.com › dsa › heap-data-structureHeap Data Structure - Programiz

   www.programiz.com › dsa › heap-data-structure

   • Cached

   • Heapify. Heapify is the process of creating a heap data structure from a binary tree. It is used to create a Min-Heap or a Max-Heap. Let the input array be.
   • Insert Element into Heap. Algorithm for insertion in Max Heap. If there is no node, create a newNode. else (a node is already present) insert the newNode at the end (last node from left to right.)
   • Delete Element from Heap. Algorithm for deletion in Max Heap. If nodeToBeDeleted is the leafNode remove the node Else swap nodeToBeDeleted with the lastLeafNode remove noteToBeDeleted heapify the array.
   • Peek (Find max/min) Peek operation returns the maximum element from Max Heap or minimum element from Min Heap without deleting the node. For both Max heap and Min Heap.

8. www.baeldung.com › cs › memory-stack-vs-heapWhat and Where Are the Memory Stack and Heap? - Baeldung

   www.baeldung.com › cs › memory-stack-vs-heap

   • Cached

   May 11, 2023 · Heap Memory. Compared to stack memory, heap memory operates dynamically, which basically means that the program can allocate and deallocate memory areas of different sizes when necessary. This allocation/deallocation of memory depends on the requirements that arise during runtime.

9. en.wikipedia.org › wiki › C_dynamic_memory_allocationC dynamic memory allocation - Wikipedia

   en.wikipedia.org › wiki › C_dynamic_memory_allocation

   • Cached

   C dynamic memory allocation refers to performing manual memory management for dynamic memory allocation in the C programming language via a group of functions in the C standard library, namely malloc, realloc, calloc, aligned_alloc and free. [1] [2] [3]