Will return statements in an inline function in C++ actually return and terminate the code flow?

Question

I was reading about inline functions in C++ , and mostly what I understood was that the compiler will copy paste the function code which is inlined. If an inline function contains a return statement and the function is used in some other function will it cause the caller function to terminate and return?

As an example consider

inline int foo(void) {
return 1;
}

int bar(void) {
//Some statements
foo()
//Some more statements
return 2;
}

Will the foo() in bar() return before bar reaches return 2; line because the code is copy-pasted by compiler? Else how is the return statement handled in inline functions? I do understand that this will not break the code flow now, but how is the return statement handled if the code is copy-pasted or inlined?

Answer 1

Inline functions are more than a simple copy-paste procedure (in contrast to, say, preprocessor macros). They behave like normal functions, so any return value would be reflected to the caller just like a normal function.

Answer 2

Optimizations should generally not alter the observable behavior of the code. This is true in C++ except for a few cases (floating point operation reordering, copy elision). Inlining a function will not change the code flow of the program.

Answer 3

Think of functions as if they are rules for computing the values, not returning something. It's just that a return keyword says that if control reaches the keyword then the value computed by the current function is whatever is next to the keyword and the current function should exit immediately (unconditional jump onto the closing { of the current function).

In your example some function foo() is programmed to return 1. If it is not inlined then the compiler emits code that indeed puts 1 somewhere where the caller expects to find it and there's an instruction for return. If it isn't inlined - okay, the compiler just sees that the function result is 1 at all times and compiles the code which calls this function appropriately - whereever that function result is used it simply "inserts" 1. In your example foo() result is not used, so the compiler simply ignores the result and the function call is compiled into no-op.