为什么指针函数总是具有void返回类型？

Question

I have seen many programs with pointer functions that have the void return type. What is the reason behind this? What is the actual need of a void pointer function?

void *print_message_function( void *ptr ){
    int *message,i,j;
    message = (int *) ptr;
    if(*message == 1){
        for(i=0;i<5;i++){ res1 += array[i];
        }
    }

    else if(*message == 2){
        for(i=5;i<10;i++){
            res2 += array[i];
        }
    }
}

If possible, please give a real life example of when you'd use a void pointer function.

Answer 1

Your terminology of "pointer function" is confusing. It seems to me that your question is

Of all functions that return a pointer to some type, it appears that very many of them are functions that return a pointer to void. Is there any reason for that?

If that is indeed your question, then -- Yes, in C, a void * can be converted to AnyOtherType * without requiring a cast. As a result, functions such as qsort that take a pointer to a function ("callbacks" as another poster alluded to), can serve as a "generic" function. When sorting values of a particular type, you pass your own comparator function which internally knows that it is really not a void * , but YourOwnType * .

Answer 2

A function pointer can have any return type, it is just a pointer to a function, so if a function does not intend to anything it returns a void and so does the function pointer.

The most common usage of function pointers is in implementing callbacks to provide an asynchronous mechanism.

An previous answer of mine, explains this in much detail:

Callback functions in C/C++/C#

Answer 3

A function pointer can have pretty much any return type. Consider this example:

#include "stdafx.h"
#include <iostream>

using namespace std;

// this defines a type called MathOp that is a function pointer returning
// an int, that takes 2 int arguments
typedef int (*MathOp)(int, int);

enum MathOpType
{
    Add = 1,
    Subtract = 2
};

// some generic math operation to add two numbers
int AddOperation(int a, int b)
{
    return a+b;
}

// some generic math operation to subtract two numbers
int SubtractOperation(int a, int b)
{
    return a-b;
}

// function to return a math operation function pointer based on some argument
MathOp GetAMathOp(MathOpType opType)
{
    if (opType == MathOpType::Add)
        return &AddOperation;

    if (opType == MathOpType::Subtract)
        return &SubtractOperation;

    return NULL;
}


int _tmain(int argc, _TCHAR* argv[])
{
    // declare a variable with the type MathOp, which is a function pointer to
    // a function taking two int arguments, and returning an int.
    MathOp op = &AddOperation;
    std::cout << op(2, 3) << std::endl;

    // switch the operation we want to perform by calling our one op variable
    op = &SubtractOperation;
    std::cout << op(2, 3) << std::endl;

    // just an example of using a function that returns a function pointer
    std::cout << GetAMathOp(MathOpType::Subtract)(5, 1) << std::endl;

    std::getchar();

    return 0;
}

The program above prints 5, -1, and then 4. Function pointers can have any return type, and are very powerful.

Answer 4

There is no requirement for a function pointer to return a void type. 90% of the examples demonstrate function pointers with void types; because, it is less information (and hopefully less confusion) to distract the reader from the focus of the pointer to the function.

This excellent tutorial clearly demonstrates function pointers to functions that return an int type.

Answer 5

How do you define a pointer function? If you mean to say "pointer to a function", it's clearly not that. Instead it is returning a void pointer. The advantage of using void pointer is that it is generic in nature and can be converted to the pointer of our requirement.