Abstraction in C++ refers to the concept of hiding the complicated reality of an object while only exposing operations relevant for that object. This allows for simplifying complex systems by breaking them down into smaller, more manageable parts, enabling developers to focus on high-level functionalities.

Each recursive call creates a new set of the function's local variables. This is maintained in what's called the call stack, where each call has its own memory space.

Tail-call optimization (or TCO) is a technique where the compiler replaces a function's tail call (a recursive call that's the last thing the function does) with a jump instruction, essentially converting the recursion into iteration and thereby avoiding new stack frame creation.

Template metaprogramming (TMP) shifts computations to the compile-time, making the generated code more optimized. This results in increased compile times because the computations and code generation are happening at that phase. However, at runtime, the program may run faster or at least not have an added overhead from TMP since the computations were already done during compilation.

Passing by pointer often conserves memory because only the address of the variable (usually 4 or 8 bytes, depending on the architecture) is passed, regardless of the size of the actual data. While pass by value creates a copy of the actual data, which can consume more memory, especially for large objects or structs. Pass by reference behaves similarly to pass by pointer in this regard.

Many modern C++ compilers can recognize tail-recursive functions and optimize them by converting the recursion into a loop, thus avoiding the overhead of repeated function calls and potentially consuming less stack space. This transformation, commonly known as tail call optimization (TCO), can lead to more efficient runtime behavior, especially for functions that would otherwise involve deep or infinite recursion.

In a nested if-else structure, the compiler evaluates conditions sequentially. Once a true condition is found, the subsequent "else if" or "else" conditions are not evaluated. If the outermost condition in a nested structure is false, the inner conditions won't be evaluated at all.

A weak_ptr is a type of smart pointer that holds a non-owning reference to an object that's managed by shared_ptr. It's particularly useful to prevent circular references which can cause memory leaks because objects reference each other preventing them from being deleted.

Function templates in C++ allow developers to write a single function definition that can work with data of various types. Instead of writing multiple functions for each type, templates allow for type-generic implementations, meaning one can handle data of multiple types with the same function logic.

In C++, the "final" keyword is used to prevent a class from being inherited. This means that no other class can be derived from a class declared as "final".