How much memory for Arrays will be allocated

Question

I write a piece of code in c++ where I need to create Arrays.

Let us assume the length of array depends on some external factors(eg: numberOfStudents) which can vary .

my code follows


typedef struct Student{
    //some attributes
}Student;

if(numberOfStudents < 50)
{
  Student students[50];
 //some more code manipulating the array
}
else if(numberOfStudents > 50 && numberOfStudents < 200)
{
   Student students[200];
  //some more code manipulating the array
}
else
{
  Student students[1000];//assuming there cannot be more than 1000 students
  //some more code manipulating the array
}

clearly I created array at three places depending on some criteria.

I want to know how much memory will be allocated. if numberOfStudents is very small, say 10, then will the other arrays in else if and else blocks also consume memory? in such a case will 50 blocks of memory be used for smallest array or will it result in 1000+200+50=1250 block of memory usage.

My compiler is NOT c99 compliant.So, whenever i try creating dynamic length arrays,which I always preferred, I get compilation errors.

Also, I cannot use Vectors. For any suggestion, that why don't you use vector, I will say thanks. But unfortunately I cannot use it as MISRA C does not allow the same.

To be noted, I am relatively new to C++. Was a Java developer!

FYI, the way to create dynamically sized arrays in C++ is to use `std::vector` — UnholySheep, Apr 30 '20 at 18:28
"whenever i try creating dynamic length arrays,which I always preferred, I get compilation errors." so use a `std::vector` — Cory Kramer, Apr 30 '20 at 18:28
0 bytes on the stack. The life of a local variable is limited to its immediate scope. Variable inside the if block is accessible inside the if and else only. Your program wont work.. — Luv, Apr 30 '20 at 18:29
`typedef struct` is a C construct that doesn't make much sense in C++. And since your question also mentions C99 and MISRA C I am confused whether you are trying to write C++ or C code — UnholySheep, Apr 30 '20 at 18:30
*So, whenever i try creating dynamic length arrays,which I always preferred, I get compilation errors.* -- That is because C++ does not allow variable-length arrays. It has nothing to do with C99 compliancy -- it has everything to do with C++ compliancy. — PaulMcKenzie, Apr 30 '20 at 18:30
I think whether the program will work or not depends on how much I put inside my if blocks. — Nostalgic, Apr 30 '20 at 18:30
@RohitGaneshan "*I cannot use vector*" - then use `new[]` directly, or even `malloc()` with `placement-new`. "*whenever i try creating dynamic length arrays,which I always preferred, I get compilation errors*" - then you are doing something wrong, but we can't see what that is since you did not show that code. — Remy Lebeau, Apr 30 '20 at 19:24
@RemyLebeau : please see what I meant, ```int numberOfStudents= ; Student students[numberOfStudents];``` also ```new``` or ```malloc()``` are discouraged due to MISRA c guidelines not allowing heap memory allocation. — Nostalgic, May 04 '20 at 14:05
@RohitGaneshan `Student students[numberOfStudents];` is not standard C++ when `numberOfStudents` is not a compile-time constant. Only a few compilers support that syntax, as a language extension. See [Why aren't variable-length arrays part of the C++ standard?](https://stackoverflow.com/questions/1887097/). — Remy Lebeau, May 04 '20 at 15:53

Jeremy Friesner · Accepted Answer · 2020-05-03T03:13:17.513

is very small, say 10, then will the other arrays in else if and else blocks also consume memory?

No. The compiler will allocate stack space when entering a block, and deallocate stack space when leaving the block, so:

if(numberOfStudents < 50)
{
   // 50*sizeof(Student) bytes of stack space allocated at this point
   Student students[50];
   [... code executes here...]
   // 50*sizeof(Student) bytes of stack space deallocated at this point
}
else if(numberOfStudents > 50 && numberOfStudents < 200)
{
   // 200*sizeof(Student) bytes of stack space allocated at this point
   Student students[200];
   [... code executes here...]
   // 200*sizeof(Student) bytes of stack space deallocated at this point
}
else
{
   // 1000*sizeof(Student) bytes of stack space allocated at this point
   Student students[1000];//assuming there cannot be more than 1000 students.  
   [... code executes here...]
   // 1000*sizeof(Student) bytes of stack space allocated at this point
}

Blocks that are never entered will not have any effect on the amount of stack space allocated.

That said, if you want to properly support an arbitrary number of Students, you're probably better off using a std::vector<Student>, or if that's not allowed, you could fall back to heap-allocation instead (e.g. Student * students = new Student[numberOfStudents]; [...]; delete [] students;).

Sounds like this will be the accepted answer. However, since you pointed to use new, I have been advised to refrain from using new as heap allocation is discouraged in real time applications.At least that's what I have been told by people. — Nostalgic, Apr 30 '20 at 18:42
@RohitGaneshan heap allocation can take an unpredictable amount of time, which is why its use is discouraged in a real-time *thread*. Note that with some care, a real-time *application* can still use it, though, by making sure the all heap allocations and frees are done outside of the real-time context (e.g. either only at application startup or application shutdown, or by doing the allocations in a non-real-time thread and then passing them to the real-time thread(s) to use afterwards). — Jeremy Friesner, Apr 30 '20 at 18:57
@RohitGaneshan the other "gotcha" of heap allocation is that it can fail if/when you reach your available RAM limits. In particular, it introduces the possibility of memory leaks if you don't code carefully. MISRA might be more concerned about that aspect than about its real-time implications. — Jeremy Friesner, Apr 30 '20 at 18:58

How much memory for Arrays will be allocated

1 Answers1