What is activation record in the context of C and C++?

An activation record is another name for Stack Frame. It's the data structure that composes a call stack. It is generally composed of:

• Locals to the callee
• Return address to the caller
• Parameters of the callee
• The previous stack pointer (SP) value

The Call Stack is thus composed of any number of activation records that get added to the stack as new subroutines are added, and removed from the stack (usually) as they return.

The actual structure and order of elements is platform and even implementation defined.

For C/C++ programmers, general knowledge of this structure is useful to understand certain implementation features like Calling Conventions and even why do buffer overflows allow 3rd party malicious code to be ran.

A more intimate knowledge will further the concepts above and also allow a programmer to debug their application and read memory dumps even in the absence of a debugger or debugging symbols.

More generally though, a C/C++ programmer can go by a large portion of their hobbyist programming career without even giving the call stack a moments thought.

activation record isn't a concept that is used much in talking about C or C++ langauges themselves. The format of activation records is very much platform specific.

Conceptually, how parameters are passed, the lifetimes of local variables, where functions return to and how the call stack is unwound in response to an expection throw are all important parts of C++ and (with the exception of the latter C). The details of how these are implemented will affect what an activation record looks like for a particular platform but knowledge of this is not usually necessary for writing code in C++ or C.

When we call function, we need someplace to store callers and callees' context, this place is called activation record(AKA stack frame).

Yes, activation records compose call stack, however, that doesn't mean activation records must be stack-based. It is implementation specific.

You may wonder "Any examples?".

• Of course, just take a look at IBM mainframes' stackless design, the stack is not available, its activation record is heap-based.
• Opposite, there is also the platform which doesn't provide heap(AKA heap-less), e.g., Arduino(but it also means new keyword and new-expression cannot be used).
• Apart from hardware limitation, some functional languages cannot store local variables on stack, so their activation records are allocated on heap, if you wonder the reason, here is a good reference.

Just like @FrakHB said, not only heap and stack, other regions of memory could also be activation record, that's what implementation specific means.

The activation record contains the following three things

1.Function definition
2.Variable definition
3.Function application(function call)