You use pointers. Specifically, you use a pointer to an address, and using a standard c library function calls, you ask the operating system to expand the heap to allow you to store what you need to. Now, it might refuse, which you will need to handle. The next question becomes – how do you … Read more
Static arrays are created on the stack, and have automatic storage duration: you don’t need to manually manage memory, but they get destroyed when the function they’re in ends. They necessarily have a fixed size at compile time: int foo[10]; Arrays created with operator new[] have dynamic storage duration and are stored on the heap … Read more
malloc is used for dynamic memory allocation. As said, it is dynamic allocation which means you allocate the memory at run time. For example when you don’t know the amount of memory during compile time. One example should clear this. Say you know there will be maximum 20 students. So you can create an array … Read more
Just don’t call free() on your original ptr in the happy path. Essentially realloc() has done that for you. ptr = malloc(sizeof(int)); ptr1 = realloc(ptr, count * sizeof(int)); if (ptr1 == NULL) // reallocated pointer ptr1 { printf(“\nExiting!!”); free(ptr); exit(0); } else { ptr = ptr1; // the reallocation succeeded, we can overwrite our original … Read more
The reason for this bug is that the data used by the create_array function is a local variable that only exists inside that function. The assigned memory address obtained from malloc is only stored in this local variable and never returned to the caller. Consider this simple example: void func (int x) { x = … Read more
My recommendation is to consider your matrix as having some abstract data type that you want to implement. A common way might be to use an array of pointers (to arrays representing rows of your matrix). But I feel it is confusing and inefficient. So what are the operations you want on your matrixes? create … Read more
This is a standard interview question: Dynamic memory allocation Is memory allocated at runtime using calloc(), malloc() and friends. It is sometimes also referred to as ‘heap’ memory, although it has nothing to do with the heap data-structure ref. int * a = malloc(sizeof(int)); Heap memory is persistent until free() is called. In other words, … Read more
Assuming you have the number of rows “r” and the number of columns “c”, you can do this: int **arr; arr = malloc(r*sizeof(int*)); for(int i=0; i < r; i++) { arr[i] = malloc(c*sizeof(int)); } this dynamically allocates an array of pointers to integers, and then allocates arrays of integers to each pointer. Don’t forget to … Read more
The difference exists due to the existence of references in C++. In C++ operator >> for objects of type int is declared the following way basic_istream<charT,traits>& operator>>(int& n); As you see the parameter of the operator has type int &. It means that the argument is passed to the function by reference that is the … Read more
malloc() is not supposed to zero the memory it returns. It seems that in your case it happens to be retrieving memory from the system that has not been previously used and is still zero. You certainly cannot count on this. calloc() on the other hand will zero memory for you before returning.