C++ 返回函式指標的函式

Dba_sys發表於2023-12-03

0 前言

就像C++其他型別一樣,函式也擁有指標,不過不得不說C++和C的函式指標非常抽象,語法空前絕後。加之C++有C的一面,有物件導向的一面,還有面向模板的一面,在《Effective C++》裡,作者第一條就點明題意,不能把C++當成1種語言來看,而是4種,每種語言都有獨特的風情,而混合起來,你甚至得學習一點密碼學...

接下來這段程式碼(來自小彭老師),核心功能是註冊GLFW的回撥函式,即接受使用者的鍵盤輸入,變換相機位姿進行模型顯示。

image

image

但看起來卻讓人望而卻步。下面將對此程式碼進行解讀。

template <class, class ...Ts>
static void (*_impl_glfw_input_callback(void (InputCtl::*pFn)(Ts...)))(GLFWwindow *, Ts...) {
    static void (InputCtl::*gpFn)(Ts...);
    gpFn = pFn;
    return [] (GLFWwindow *window, Ts ...args) -> void {
        auto game = (Game *)glfwGetWindowUserPointer(window);
        if (game) [[likely]] {
            (game->m_inputCtl.*gpFn)(args...);
        }
    };
}

template <class FpFn>
static auto glfw_input_callback(FpFn fpFn) {
    return _impl_glfw_input_callback<FpFn>(fpFn());
}

// usage
glfwSetCursorPosCallback(window, glfw_input_callback([] { return &InputCtl::cursor_pos_callback; }));

1 Function Pointer in C/C++ type

1.1 ordinary function Pointer

以下這段程式碼來自 Author Vysandeep3

// C++ program for the above approach
#include <iostream>
using namespace std;

void demo(int& a)
{
    a += 10;
}
 
// Driver Code
int main()
{
    int num = 20;
 
    // Now ptr contains address of demo
    // function or void
    void (*ptr)(int*) = &demo;
 
    // or (*ptr)(num);
    ptr(num);
 
    cout << num << endl;
 
    return 0;
}

returnType (*function_pointer_name)(Type a, Type b, Type ... n)

其中 function_pointer_name 定義了一個變數,他可以儲存類似 returnType XXXX(Type a, Type b, Type ... n) 這種形式函式的指標。

但是有些時候我們有多個這種型別的函式,例如

int add(int a, int b);
int sub(int a, int b);
int mul(int a, int b);
int rat(int a, int b);

int (*ptr)(int, int) = NULL;
if(a == b) {
	ptr = &add;
}else{
	ptr = &mul;
}

我們需要在main()函式里決定什麼時間什麼條件一個這種型別的指標指向的函式,需要一段程式碼來完成這種操作。

問題是,我們可不可以寫一個函式來完成這種操作呢?這也是一種重構的思想,當一段程式碼可能需要用到多次的時候,為什麼不把他寫成一個函式呢?

1.2 non-static member function of class

Its type is int (Fred::*)(char,float) if a non-static member function of class Fred
Note: if it’s a static member function of class Fred, its type is the same as if it were an ordinary function: “int (*)(char,float)”.
https://isocpp.org/wiki/faq/pointers-to-members

float (SomeClass::*my_memfunc_ptr)(int, char *);
// For const member functions, it's declared like this:
float (SomeClass::*my_const_memfunc_ptr)(int, char *) const;

my_memfunc_ptr = &SomeClass::some_member_func;
// This is the syntax for operators:
my_memfunc_ptr = &SomeClass::operator !;


// There is no way to take the address of a constructor or destructor

給出一篇學習資料: Member Function Pointers and the Fastest Possible C++ Delegates by Don Clugston

1.3 Lambda To Function Pointer

#include <iostream>
using namespace std;
#define PI(x) x, #x, x##x

auto noCapture =
    [](int res) -> float
    {
        std::cout << "No capture lambda called with " << res << "\n";
        return 99.9f;
    };
 
typedef float(*NormalFuncType)(int);


int main(){
    NormalFuncType noCaptureLambdaPtr = noCapture; //----------- (1)
    float res = noCaptureLambdaPtr(100); //----------- (2)
    return 0;
}

// COUT
// No capture lambda called with 100

注意這東西的地址需要用 auto noCapture = [](int res) -> float{} 來接。除此之外,就當成一個普通的函式指標就行

給出一篇學習資料: How To Bind Lambda To Function Pointer

1.4 總結什麼是指標

int* pInt;
char* pChar;

一個指標,指向一塊記憶體中的地址(儲存地址)。但是同時他又有對應的型別,char* 意為從這個地址開始讀取1個位元組,int* 意為從這個地址開始讀取4個位元組。這就是指標的核心。指標型別決定了程式如何對待一個地址。

另外C語言可以透過2個指標實現物件導向程式設計。當然正常的物件導向程式設計也是需要2個指標(*this, *underThis)。想要深入瞭解的話,可以搜尋 opaque-pointers 這方面的知識。

給出一篇學習資料: Practical Design Patterns: Opaque Pointers and Objects in C

2 Returning a function pointer from a function in C/C++

以下這段程式碼來自 Author Vysandeep3

#include <iostream>
using namespace std;
 
int add(int a, int b) {
    return a + b;
}
 
int subtract(int a, int b) {
    return a - b;
}
 
int (*get_operation(char op))(int, int) {
    if (op == '+') {
        return &add;
    } else if (op == '-') {
        return &subtract;
    } else {
        return NULL;
    }
}
 
int main() {
    int (*op)(int, int) = get_operation('+');
    int result = op(3, 4);
    cout << "Result: " << result << endl;
    return 0;
}

int (*get_operation(char op))(int, int):

  • 其中 get_operation(char op) 是一個返回函式指標的函式
  • int (*) (int, int) 是返回的函式指標所指向的函式型別

這東西看起來確實很怪..., 但是我們只能接受。

這裡給出一種理解方式, 首先一個指標需要兩個識別符號 Type* ptr_name

int* ptr;       // ptr is a pointer to an integer

int(*)(int, int);	// key idea: function pointer type

// ptr lost a pointerType like int*
int (*ptr)(int, int);	// ptr is a pointer to a function that takes that takes two arguments and returns an integer

// int(*)(int, int) ptr;

//---------------------------------------------------------------------//

int ptr(char op); 	// ptr is a function that takes that takes one char type argument and returns an integer

// ptr() lost a returnType like int
int (*ptr(char op))(int, int){};	// ptr() is a function that takes one char argument returns a pointer to a function which two arguments and returns an integer.

// int(*)(int, int) ptr(char op) {};

https://www.learncpp.com/cpp-tutorial/introduction-to-pointers/

3. C - Variable Arguments (Variable length arguments)

printf("Some values: %d, %s, %c!", 4, "foo", 'z')

#include <stdarg.h>

void my_printf(char* format, ...)
{
  va_list argp;
  va_start(argp, format);
  while (*format != '\0') {
    if (*format == '%') {
      format++;
      if (*format == '%') {
        putchar('%');
      } else if (*format == 'c') {
        char char_to_print = va_arg(argp, int);
        putchar(char_to_print);
      } else {
        fputs("Not implemented", stdout);
      }
    } else {
      putchar(*format);
    }
    format++;
  }
  va_end(argp);
}

The C library macro void va_start(va_list ap, last_arg) initializes ap variable to be used with the va_arg and va_end macros. The last_arg is the last known fixed argument being passed to the function i.e. the argument before the ellipsis.

https://www.tutorialspoint.com/cprogramming/c_variable_arguments.htm
https://jameshfisher.com/2016/11/23/c-varargs/
https://www.tutorialspoint.com/c_standard_library/c_macro_va_start.htm

4. Variadic Template

C++ Primer P700.

這個東西說白了,就是類似C - Variable Arguments,可以接收任意長度的函式引數,不過與C - Variable Arguments這種需char* format來自己告知函式對應引數的型別。Variadic Template 會自動生成相應的函式定義以及宣告,這是模板程式設計的優勢。詳情看下面的例項程式碼。

// Args is a template parameter pack; rest is a function parameter pack
// Args represents zero or more template type parameters
// rest represents zero or more function parameters
template <typename T, typename... Args>
void foo(const T &t, const Args& ... rest);

int i = 0; double d = 3.14; string s = "how now brown cow";
foo(i, s, 42, d); // three parameters in the pack
foo(s, 42, "hi"); // two parameters in the pack
foo(d, s); // one parameter in the pack
foo("hi"); // empty pack

the compiler will instantiate four different instances of foo:

void foo(const int&, const string&, const int&, const double&);
void foo(const string&, const int&, const char(&)[3]);
void foo(const double&, const string&);
void foo(const char(&)[3]);

In each case, the type of T is deduced from the type of the first argument. The
remaining arguments (if any) provide the number of, and types for, the additional
arguments to the function.

#include<iostream>
using namespace std;

template<typename ... Args> void g(Args ... args) {
    cout << sizeof...(Args) << endl; // number of type parameters
    cout << sizeof...(args) << endl; // number of function parameters
}

int main(){
    g(1,2,3,4);
    return 0;
}

/*
*	4
*	4
*/

5 Variadic Template with member function pointer

當 Variadic Template 來接收 member function pointer時,不需要顯式的宣告成員函式的引數型別,編譯器會自動推導。

#include <cstdio>
class A{
  public:
  void func(int xpos, int ypos);
};

void A::func(int xpos, int ypos){
  printf("Hello World!");
}

template <class ...Ts>
void (* Test(void (A::*pFn)(Ts...)))(Ts ...){
	return nullptr;
};


/* First instantiated from: insights.cpp:19 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
void (*Test<int, int>(void (A::*pFn)(int, int)))(int, int)
{
  return nullptr;
}
#endif
;

int main()
{
  A a;
  Test(&A::func); // line == 19
  return 0;
}

https://cppinsights.io/
https://adroit-things.com/programming/c-cpp/how-to-bind-lambda-to-function-pointer/
https://www.codeproject.com/Articles/7150/Member-Function-Pointers-and-the-Fastest-Possible

6 最終解析

template <class, class ...Ts>
static void (*_impl_glfw_input_callback(void (InputCtl::*pFn)(Ts...)))(GLFWwindow *, Ts...) {
    static void (InputCtl::*gpFn)(Ts...);
    gpFn = pFn;
    return [] (GLFWwindow *window, Ts ...args) -> void {
        auto game = (Game *)glfwGetWindowUserPointer(window);
        if (game) [[likely]] {
            (game->m_inputCtl.*gpFn)(args...);
        }
    };
}

template <class FpFn>
static auto glfw_input_callback(FpFn fpFn) {
    return _impl_glfw_input_callback<FpFn>(fpFn());
}

// usage
glfwSetCursorPosCallback(window, glfw_input_callback([] { return &InputCtl::cursor_pos_callback; }));
  1. glfw_input_callback([] { return &InputCtl::cursor_pos_callback; })
    傳入一個lambda函式指標, 型別使用 template <class FpFn> FpFn自動定義,函式指標值使用 fpFn承接。

  2. _impl_glfw_input_callback<FpFn>(fpFn());
    fpFn()呼叫匿名函式,返回 &InputCtl::cursor_pos_callback 成員函式指標。

  3. Variadic Template with member function pointer

template <class, class ...Ts>
static void (*_impl_glfw_input_callback(void (InputCtl::*pFn)(Ts...)))(GLFWwindow *, Ts...) 

_impl_glfw_input_callback(void (InputCtl::*pFn)(Ts...)) 使用模板自動承接相應的成員函式指標,不必明確指出函式的引數等資訊。

  1. 函式呼叫
return [] (GLFWwindow *window, Ts ...args) -> void {
		// Game class 的 *this 指標
        auto game = (Game *)glfwGetWindowUserPointer(window);
        if (game) [[likely]] {
		// 成員函式呼叫
            (game->m_inputCtl.*gpFn)(args...);
        }
    };

註冊回撥函式的核心無非就是執行回撥函式中的程式碼

X.Refference

  1. Author Vysandeep3
  2. https://isocpp.org/wiki/faq/pointers-to-members
  3. Member Function Pointers and the Fastest Possible C++ Delegates by Don Clugston
  4. How To Bind Lambda To Function Pointer
  5. Practical Design Patterns: Opaque Pointers and Objects in C
  6. Author Vysandeep3
  7. https://www.learncpp.com/cpp-tutorial/introduction-to-pointers/
  8. https://www.tutorialspoint.com/cprogramming/c_variable_arguments.htm
  9. https://jameshfisher.com/2016/11/23/c-varargs/
  10. https://www.tutorialspoint.com/c_standard_library/c_macro_va_start.htm
  11. https://cppinsights.io/
  12. https://adroit-things.com/programming/c-cpp/how-to-bind-lambda-to-function-pointer/
  13. https://www.codeproject.com/Articles/7150/Member-Function-Pointers-and-the-Fastest-Possible
  14. 小彭老師 OPENGL 課程實驗原始碼