Stack and const

Questions 1 to 5 of 7

1. 1. A recursive function sum_to(n) makes n nested calls before it returns, and each call keeps its frame on the call stack until it returns. In Big-O terms, how much stack does one call to sum_to(n) use?

   O(1)O(log n)O(n)O(n squared)
2. 2. The function count_on_stack, with a 100 KB local array in each call, crashed at 83 levels, while count_on_heap reached about 87,000 levels. What explains the difference?

   Each stack frame holds the 100 KB array, so about 84 frames need 8.4 MB, more than the 8 MB stack. The heap version's frame holds only a small handle to its buffer.The heap version has no base case, so it returns before the stack fills.std::vector is stored in a larger stack that the compiler enlarges automatically.std::array is slower to build than std::vector, so it runs out of time before the stack fills.
3. 3. Which statement about int* const q = &x; is true?

   It makes x read-only, so x = 5 is refused everywhereIt stops the value at the address from changing through q, so *q = 42 is refusedIt fixes the address that q holds, so q = &y; is refused, but *q = 42; still changes xIt makes both the address and the value read-only, the same as const int* const
4. 4. The compiler rejects this class. What does it report, and why? ``cpp class Counter { public: int value() const { ++count_; return count_; } private: int count_ = 0; }; ``

   It compiles, and value() increments count_ on each callerror: assignment of read-only variable 'count_', because count_ is privateerror: increment of member 'Counter::count_' in read-only object, because value() is marked const and must not change the objectwarning: infinite recursion detected, because value() calls itself
5. 5. What is wrong with this recursive function, and what does -Wall report? ``cpp #include <cstdio> int countdown(int n) { std::printf("%d\n", n); return countdown(n - 1); } ``

   The printf format is wrong for an int, and -Wall reports a format errorThe function is missing a return statement, and -Wall reports 'control reaches end of non-void function'It is correct under -Wall, and only crashes at -O0 because the tail call is not removedIt has no base case, so the calls never stop; -Wall reports 'infinite recursion detected'