学步园

// C
int DoIt (float a, char b,
char c){ printf("DoIt/n"); return a+b+c; }
int DoMore(float a, char b,
char c)const{ printf("DoMore/n");
return a-b+c; }

pt2Function = DoIt; // short form
pt2Function = &DoMore; // correct assignment using address operator

// C++
class TMyClass
{
public:
int DoIt(float a, char b,
char c){ cout << "TMyClass::DoIt"<< endl;
return a+b+c;};
int DoMore(float a, char b,
char c) const
{ cout << "TMyClass::DoMore" << endl;
return a-b+c; };

/* more of TMyClass */
};

// C
if(pt2Function >0){
// check if initialized
if(pt2Function == &DoIt)
printf("Pointer points to DoIt/n"); }
else
printf("Pointer not initialized!!/n");

TMyClass instance1;
int result3 = (instance1.*pt2Member)(12,
'a', 'b');
// C++
int result4 = (*this.*pt2Member)(12,
'a', 'b');
// C++ if this-pointer can be used

// <pt2Func> is a pointer to a function which returns an int and takes a float and two char
void PassPtr(int (*pt2Func)(float,
char, char))
{
int result = (*pt2Func)(12,
'a', 'b');
// call using function pointer
cout << result << endl;
}

// Direct solution: Function takes a char and returns a pointer to a
// function which is taking two floats and returns a float. <opCode>
// specifies which function to return
float (*GetPtr1(const char opCode))(float,
float)
{
if(opCode == '+')
return &Plus;
else
return &Minus; // default if invalid operator was passed
}

// Solution using a typedef: Define a pointer to a function which is taking
// two floats and returns a float
typedef float(*pt2Func)(float, float);

// Function takes a char and returns a function pointer which is defined
// with the typedef above. <opCode> specifies which function to return
pt2Func GetPtr2(const char opCode)
{
if(opCode == '+')
return &Plus;
else
return &Minus; // default if invalid operator was passed
}

// Execute example code
void Return_A_Function_Pointer()
{
cout << endl << "Executing 'Return_A_Function_Pointer'" << endl;

// define a function pointer and initialize it to NULL
float (*pt2Function)(float, float) = NULL;

pt2Function=GetPtr1('+');
// get function pointer from function 'GetPtr1'
cout << (*pt2Function)(2,
4) << endl; // call function using the pointer

// C ---------------------------------------------------------------------------------

// type-definition: 'pt2Function' now can be used as type
typedef int (*pt2Function)(float, char,
char);

// illustrate how to work with an array of function pointers
void Array_Of_Function_Pointers()
{
printf("/nExecuting 'Array_Of_Function_Pointers'/n");

// define arrays and ini each element to NULL, <funcArr1> and <funcArr2> are arrays
// with 10 pointers to functions which return an int and take a float and two char

// first way using the typedef
pt2Function funcArr1[10] = {NULL};

// 2nd way directly defining the array
int (*funcArr2[10])(float,
char, char) = {NULL};

// assign the function's address - 'DoIt' and 'DoMore' are suitable functions
// like defined above in 1-4
funcArr1[0] = funcArr2[1] = &DoIt;
funcArr1[1] = funcArr2[0] = &DoMore;

/* more assignments */

// calling a function using an index to address the function pointer
printf("%d/n", funcArr1[1](12,
'a', 'b'));
// short form
printf("%d/n", (*funcArr1[0])(12,
'a', 'b'));
// "correct" way of calling
printf("%d/n", (*funcArr2[1])(56,
'a', 'b'));
printf("%d/n", (*funcArr2[0])(34,
'a', 'b'));
}

// C++ -------------------------------------------------------------------------------

// type-definition: 'pt2Member' now can be used as type
typedef int (TMyClass::*pt2Member)(float,
char, char);

// illustrate how to work with an array of member function pointers
void Array_Of_Member_Function_Pointers()
{
cout << endl << "Executing 'Array_Of_Member_Function_Pointers'" << endl;

// define arrays and ini each element to NULL, <funcArr1> and <funcArr2> are
// arrays with 10 pointers to member functions which return an int and take
// a float and two char

// first way using the typedef
pt2Member funcArr1[10] = {NULL};

// 2nd way of directly defining the array
int (TMyClass::*funcArr2[10])(float,
char, char) = {NULL};