Use of '&' operator before a function name in C++ - c++

Question

A reference defines an alternative name for an object. A reference type “refers to”
another type. We define a reference type by writing a declarator of the form &d,
where d is the name being declared.
The next thing is a reference is not an object. Instead, a reference is just another name for an already existing object. So we'll use these references to pass the parameter by reference so that it directly effect the actual parameters.
Question:
What happens when we use a reference (&) before a function name?
I'm a little bit confused, as in my opinion it will return the alias of return (variable name). Or am I wrong?.
std::vector<std::string> &split(const std::string &s, char delim,
std::vector<std::string> &elems) {
std::stringstream ss(s);
std::string item;
while (std::getline(ss, item, delim)) {
elems.push_back(item);
}
return elems;
}

Answer 1

In C++, when the ref-sign (&) is used before the function name in the declaration of a function it is associated with the return value of the function and means that the function will return by reference.
int& foo(); // Function will return an int by reference.
When not used within a declaration context, putting the ref-sign before a function name results in calling the address-of operator returning the address of the function. This can be used to e.g. create a pointer to a function.
// Some function.
int sum(int a, int b) {
return a + b;
}
int main() {
// Declare type func_ptr_t as pointer to function of type int(int, int).
using func_ptr_t = std::add_pointer<int(int, int)>::type;
func_ptr_t func = ∑ // Declare func as pointer to sum using address-of.
int sum = func(1, 2); // Initialize variable sum with return value of func.
}
In C, the only use of & is for the address-of operator. References does not exist in the C language.

Answer 2

In C, &func where func is a function evaluates to the address of the function which can be assigned to a function pointer which points to a function having the same signature as the function func.
int func(float);
int (*fp)(float) = &func;
// equivalent to
int (*fp)(float) = func;

Answer 3

'// return the plural version of word if ctr is greater than 1
string make_plural(size_t ctr, const string &word,
const string &ending)
{
return (ctr > 1) ? word + ending : word;
}'
The return type of this function is string, which means the return value is copied to
the call site. This function returns a copy of word, or it returns an unnamed
temporary string that results from adding word and ending.
As with any other reference, when a function returns a reference, that reference is
just another name for the object to which it refers. As an example, consider a function
that returns a reference to the shorter of its two string parameters:
'// return a reference to the shorter of two strings
const string &shorterString(const string &s1, const string
&s2)
{
return s1.size() <= s2.size() ? s1 : s2;
}'
The parameters and return type are references to const string. The strings are
not copied when the function is called or when the result is returned.
Never Return a Reference or Pointer to a Local Object
When a function completes, its storage is freed. After a function
terminates, references to local objects refer to memory that is no longer valid: