＆function_name在以下代码中描述了什么

Question

I have following code snippet, what does &main and &user depict here? Each time I run why does it give different values? In what scenarios passing &function_name is useful?

int user()
{
      return 0;  
}

int main()
{
    int a, b = 0;
    a = ((int)&main);
    b = ((int)&user);
    cout << a <<" " << b;
    return 0;
}

Answer 1

It depcits the address of your functions. The reason why its different each time you run it, is because your program probably does not use the same memory space each time.

&main gives you the address of your main function, quite like &var gives you the address of a variable called var. The cast to int is probably problematic. Pointers on a 64 bit system are 64 bit wide, an int may not be that long.

Answer 2

sbi explained it nicely here :

Most examples boil down to callbacks : You call a function f() passing the address of another function g() , and f() calls g() for some specific task. If you pass f() the address of h() instead, then f() will call back h() instead.

Basically, this is a way to parametrize a function: Some part of its behavior is not hard-coded into f() , but into the callback function. Callers can make f() behave differently by passing different callback functions. A classic is qsort() from the C standard library that takes its sorting criterion as a pointer to a comparison function.

In C++, this is often done using function objects (also called functors). These are objects that overload the function call operator, so you can call them as if they were a function. Example:

 class functor { public: void operator()(int i) {std::cout << "the answer is: " << i << '\\n';} }; functor f; f(42); 

The idea behind this is that, unlike a function pointer, a function object can carry not only an algorithm, but also data:

 class functor { public: functor(const std::string& prompt) : prompt_(prompt) {} void operator()(int i) {std::cout << prompt_ << i << '\\n';} private: std::string prompt_; }; functor f("the answer is: "); f(42); 

Another advantage is that it is sometimes easier to inline calls to function objects than calls through function pointers. This is a reason why sorting in C++ is sometimes faster than sorting in C.