The advantages of function pointer [closed] - c++

Question

Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 8 years ago.
Improve this question
Can anyone explain me the advantages of function poiner?
I know that there are many possible duplicates with my question but they only explain in words , that's not very helpful , I need an example of the case that not using the function pointer compare to the case of using the function pointer.
Thanks a lot.

Answer 1

How about mapping data to behaviour, things like:
void DoIt();
void DontDoIt();
std::map<std::string, std::function<void()> word_map {
{"DoIt", DoIt},
{"DontDoIt", DontDoIt}
};
std::string word;
// ... get "DoIt" or "DontDoIt" into word
word_map[word](); // execute correct function

Answer 2

Simple example : suppose you have N record comprising of names and phone numbers.
You're asked to sort
based on names
based on phone numbers
A nice approach would just be to vary a comparison function passed as a function pointer inside a sorting routine.
void sort( records r[], int N,
bool (*fptr)( const record& lhs, const record& rhs ) ) { }
If you won't use function pointer you'll end up coding same logic merely for two different comparison function.
void sort_by_name( records r[], int N) { }
void sort_by_phoneno( records r[], int N) { }

Answer 3

By using a function pointer you can, for example, prevent code duplication.
Without function pointers:
void AddOneToVectorElements( vector<int> v )
{
// implementation
}
void MultiplyVectorElementsByTwo( vector<int> v )
{
// implementation
}
// usage
AddOneToVectorElements(v);
MultiplyVectorElementsByTwo(v);
Using function pointers:
typedef int (*func)(int);
int TransformVecotr ( vector<int> v, func f)
{
// implementation by application of f to every element
}
int AddOne(int x)
{
return x + 1;
}
int MultiplyByTwo(int x)
{
return 2 * x;
}
// usage
TransformVecotr(v, &AddOne);
TransformVecotr(v, &MultiplyByTwo);
In C++11 there are lambda functions and they make the whole thing even more convenient.

Answer 4

The key point is that function pointers are used "under the hood" all the time in generic programming. One tends to forget this, because template argument deduction hides the function pointer syntax.
For example:
#include <algorithm>
#include <iterator>
bool f(int i)
{
return i == 1;
}
int main()
{
int arr[] = { 1, 1, 3 };
int count = std::count_if(std::begin(arr), std::end(arr), f);
}
The f in main's last line is a function pointer, because the std::count_if template function will accept anything that can be used with the () syntax. Quoting cppreference.com:
template< class InputIt, class UnaryPredicate >
typename iterator_traits<InputIt>::difference_type
count_if( InputIt first, InputIt last, UnaryPredicate p );
UnaryPredicate can be a function pointer, and is one in the example above.
The compiler just deduces its exact type, bool(*)(int), automatically when you pass f. Technically, you could also write the call like this:
// just for illustration:
std::count_if<int*, bool(*)(int)>(std::begin(arr), std::end(arr), f);
If there were no function pointers in C++, then you could not directly use functions as predicates in the standard-library algorithms. You'd instead have to wrap them in classes all the time:
#include <algorithm>
#include <iterator>
bool f(int i)
{
return i == 1;
}
struct Functor
{
bool operator()(int i) const
{
return f(i);
}
};
int main()
{
int arr[] = { 1, 1, 3 };
int count = std::count_if(std::begin(arr), std::end(arr), Functor());
}