Is it possible to do the stack calling without manually typing it out?
The less human, less mistakes, less debug, less cost in development.
Really? Typing it out is more cost in development?
If you are worried about the extra 23 keystrokes required to call the base class functionality, why not change the name of your classes to "d" and "s" and the need of your functions to "a" and "b"?
The answer to this should be obvious. The clarity that longer names provides greatly aids in the understand-ability and maintainability of the code.
Typing out baseclass::function() clearly shows the programmers intentions of calling the base class functionality. And it allows the base class functionality to be called at the beginning, in the middle, or at the end of the derived class function, depending on the programmer's needs.
I guess there could be a keyword like SUPER_CALL or something that calls the base class functionality using the arguments passed in, but I don't think it really buys you anything.
Now imagine if there was some whacky machinery in place that always called base::execute() at the beginning of DerivedXYZ::execute(). In that case, we'd have to do some code gymnastics to make it do what we wanted, even though what we wanted was pretty clear.
Yes, there were a few cases where someone forgot to call the base method, but those always turned up in unit testing or system testing.
One thing we DID do was a typedef to ensure we call the right base class. During development, sometimes we found that a class needed to be somewhere else in the hierarchy and we didn't want to have to change all the base class qualifiers:
1 2 3 4 5 6 7 8
typedef MultiSjob MultiNormalSjobBase;
class MultiNormalSjob : public MultiNormalSjobBase
If you always want to call deep::stackTrigger(), no more, no less, no matter how deep the inheritance chain is, you could instead make the stackTrigger() function call a protected virtual function that the derived classes can override instead.