In C++, when declaring a function with default arguments, the = operator followed by a default value is used to specify the default argument. For example, int func(int a, int b = 0) declares a function func with a default argument of 0 for the parameter b.

Inline functions can increase the overall size of the compiled code when used in header-only libraries. Since the function's code is included in each translation unit that includes the header, it can result in code duplication and larger executables.

The ternary operator, represented as ? :, provides a shorthand way to express a simple if-else statement. It evaluates a condition and returns one of two values depending on whether the condition is true or false. This concise syntax is often used to make code more compact and readable.

In C and C++, assignment operators associate right-to-left. So, b = c is evaluated first, assigning the value of c to b, and then a = b assigns the value of b to a. This behavior is consistent with other binary operators in these languages.

The decision of whether to inline a function is influenced by various factors. These include the complexity of the function, compiler optimization settings, available memory, and the size of the function. If the function is too complex or exceeds a certain size, the compiler may choose not to inline it, even if marked as such.

Yes, if a function is declared multiple times but defined only once in a program, it will compile successfully. This is because function declarations inform the compiler about the function's signature and return type, allowing it to check for consistency when the function is called in different parts of the code. The definition provides the actual implementation.

In C++, you can specify default arguments for some middle arguments while skipping the last ones. However, all arguments to the right of a default argument must also have default values.

Inline functions should be avoided in scenarios where the function is complex and large. The purpose of inline functions is to reduce function call overhead, but in the case of large or complex functions, inlining can lead to code bloat, impacting performance and code maintainability. In such cases, it's better to use regular functions.

To ensure that overloaded functions are chosen correctly during compile time, developers should use different parameter types. This helps the compiler distinguish between the various overloaded functions and select the appropriate one based on the provided arguments.

Sarah should use Function Overloading. This allows her to define multiple functions with the same name but different parameter types. In this case, she can create overloaded functions that accept different combinations of integers and floats to achieve the desired behavior for her sum function.