都知道Unity的生命周期有一些函数：Awake、Start、Update等等。

Unity 是如何调用的呢？
在这里进行猜想：
1.虚函数的重载

但是没有 override关键字。
2.反射

mono支持对函数名进行字符串获取，获取到这些函数名之后，进行反射调用。

也就是说

继承 MonoBehavior 类之后，Unity都会统计内部的函数，执行一次遍历反射回调。

c++写了一个test.dll，内部有几个类分别是class A class B class C

类A,B,C下面分别有一些函数func1,func2,func3.....

怎么调用某个类下面的函数

我用的dllimport，入口点entrypoint怎么写？

没有对应的，是用户自己建立的class，下面一堆的函数，比如a::func1，b::func2之类的

问题就在于，不知道entrypoint填什么好，我使用dependency工具去查这dll内部的函数，都是一堆问号开头的比如?a@func1@!@#$%这类的函数名，直接拷贝了填是可以但是会提示内存出错，怀疑是函数调用入口问题

不知道这类带有class的函数要怎么调用，以前用过都是直接import dll然后entrypoint写函数名就可以了，但是现在因为dll里面的函数都在每个类下面，就不知道entrypoint写啥好了

c++/cli最好的解决办法

吧这个类导出来，加上类的头文件，就可以使用 啊

C++需要导出的API,用extern "C"包起来,按C的方法编译的方法名称不会带上参数信息.

关于怎么在托管代码中写非托管方法的声明,建议多了解一点PInovke的知识.

需要示例可以参考:Pinvoke.Net

C++函数导出基本上都是用基础类型。很少用到类的。


原因是不同的编译器，对类的具体实现可以不同。由于布局的不同，C#并不能理解C++的类，甚至同是C++编译器，都会存在兼容的问题l。


在C#中调用C++类，不是说完全不可能，却是代价很高。不容易调试，不容易维护，得不偿失。最可行的做法是，只用小蜜蜂论坛顶帖机基础类型来导出C函数（这也是大部分Win32 API的做法)。

问题起源




我觉得很困惑，于是一顿操作，证明了确实类的静态成员函数不能调用类的非静态成员函数



即如果_data是非静态成员变量的话，编译不通过。


请教了下组内大神 疑问点：类的成员函数不也是类的非静态成员函数嘛？怎么getInstance能访问呢？

大神说：如果类内还有一个bar的非静态成员函数，那么getInstance去访问bar的话，会出错，原因是编译器在访问bar时，会需要提供一个this指针(相当于编译器认为this->bar)，因此，此时调用会出错。

然而调用类的构造函数时，new Singleton 不需要提供一个this指针，因此类的静态成员函数可以调用构造函数，而在new完会产生一个this的指针，此时去调用bar是没有问题的(总结看来：如果类的构造函数不声明为private的话，那么相当于全局可见的，和main没什么差别)


升华

大神说：其实把getInstance作为一个友元函数也可以实现单例！（太强了，以前都没有考虑过。）不过考虑到类的封装，一般还是用static的成员函数

我们要做的是：将一个add函数作为另一个process函数的参数, 并在process函数里调用add；这个我们分别在全局函数中实现和在类中实现，看看两者有什么区别。
函数指针
先联想下，什么是函数指针和什么时候我们需要用到函数指针？

我的第一反应，函数指针，就是指向函数的指针，类比int* p //p是指向int的指针，那么函数指针 它的类型是什么，它应该怎么定义；

这时候我们想想什么时候用到函数指针，我的第一反应两个地方：

a. dll 动态库加载的时候 b. 回调函数的时候
函数指针 它的类型是什么，它应该怎么定义？ 带着这个问题，先回顾下dll 动态库加载的时候，我们怎么用的？
假设一个动态库dll, 里面封装了一个方法add,我们需要再另一个函数里调用它
// add.dll
extern "C" _declspec(dllexport) int __stdcall add(int a, int b)
{
    return a+b;
}

// 另一个进程 main.exe
// 需要定义一个函数指针
typedef int (*ADDPROC)(int a, int b);
// ADDPROC相当于函数指针的类型 类比int* p; ADDPROC相当于int*
ADDPROC addproc; // 定义一个函数指针变量
// 需要加载dll,这里采用动态加载
HINSTANCE hDll = LoadLibary("add.dll");
if(nullptr != hDll)
{
    addproc = (ADDPROC)GetProcAddress(hDll, "add");
}
else
{
    // 加载dll失败
    ...
}

上面是一个加载dll的简单示例，我们发现，动态加载dll，在获取一个函数地址的时候，我们用到了函数指针

ADDPROC它是一个类型，代表着这是一个add函数类型的指针类型，int*， 用它可以定义一个变量，ADDPROC addproc;

这里参考https://www.cnblogs.com/AnnieKim/archive/2011/11/20/2255813.html，给出函数指针的定义赋值的总结

1）  函数指针的初始化。
//函数如下：
int CompareString(const string& str1, const string& str2)
{
   return str1.compare(str2);  
}

函数指针的初始化有两种方式：
第一种，也是最普遍的方式：
int (*CompareFunction)(const string&, const string&) = CompareString;

第二种，是使用typedef定义函数类型，这种写法有助于对代码的理解：
typedef int (*CompareFunctionType)(const string&, const string&);
CompareFunctionType CompareFunction = CompareString;

2）  函数指针赋值。

函数名可以理解为该类型函数的指针。当然，取地址操作符作用于函数名上也能产生指向该类型函数的指针。也就是说下面两种赋值都是可行的:
CompareFunctionType CompareFunction = CompareString;
CompareFunctionType CompareFunction = &CompareString;

在全局函数中使用函数指针
已经知道函数指针定义和初始化，那么我们想要在全局函数中；将add函数作为参数传递给process函数，如下
int add(int a, int b)
{
    return a+b;
}
typedef int (*ADDPROC)(int a, int b);
// ADDPROC addproc
int process(ADDPROC addproc, int a, int b)
{
    addproc(a,b); // 直接调用add函数
}

int main()
{
    ADDPROC addproc = add; // 定义一个add指针类型的变量，并赋值为add函数的地址，也可以写成ADDPROC addproc = &add
    int res = addproc(2,1); // res=3 可以通过定义好的函数指针来访问函数 
    res = process(addproc, 1, 4); //res = 5  也可以把函数指针当成参数传入 
    res = process(add, 5, 4);  // res=9 这里也可以直接传add这个函数名进去 
    return 0;
}

这里我们就已经完成了全局函数里，将函数作为变量传递给另一个函数；

那如果放在类中，应该怎么做呢？
在类中使用函数指针
这里实现的的，类内需要用到函数指针，调用类的成员函数add，这种类内使用函数指针，则add函数（函数指针指向的函数）应该为静态成员函数

我们先把这种全局函数版的直接搬到类里，看看会报什么错
class Solution {
public:
    // 非静态函数
    int add(int a, int b)
    {
        return a+b;
    }
    typedef int (*ADDPROC)(int a, int b);// 声明一个函数指针类型
    int process(ADDPROC addproc, int a, int b)
    {
        return addproc(a,b); // 直接调用add函数
    }
    // 类里调用
    int test()
    {
        //error: reference to non-static member function must be called
        process(Solution::add, 3, 4);
        return 0;
    }
};

int main()
{
    Solution sol;
    //error: reference to non-static member function must be called
    sol.process(sol.add, 3, 4); // 类外调用
    return 0;
}

测试后发现，无论是类里面调用还是类外调用，编译都会报错；报错信息，跟静态成员函数相关;

我们把add函数挪到类外作为全局函数，或者把add声明成静态成员函数，则可以通过编译；为什么？

这是因为非静态的成员函数还多了一个隐式this指针参数(implicit parameter)

int add(Solution* this, int a, int b) // 普通成员函数的全部形参

这时，把add函数放在类外或者加上static声明，则没有问题；

说明静态成员函数和类实例没有关系，所有的类是共享的同一个static成员函数；

修改后的代码如下：
typedef int (*ADDPROC)(int a, int b); // 函数指针类型定义写在类里类外都可以

class Solution {
public:
    // 非静态函数版
    static int add(int a, int b)
    {
        return a+b;
    }

    int process(ADDPROC addproc, int a, int b)
    {
        return addproc(a,b); // 直接调用add函数
    }

    ADDPROC _addproc;
};

int main()
{
    ADDPROC addproc = &Solution::add;
    Solution sol;
    int res = sol.process(sol.add, 3, 4); // 直接通过函数名当参数
    res = sol.process(addproc, 3, 4); // 通过局部变量函数指针当参数
    res = addproc(2,4); // 相当于调用sol.add(2,4)
    res = (*addproc)(7,8); // 严格遵守指针解引用到函数的方式,相当于调用sol.add(7,8)

    // 类的成员变量 函数指针
    sol._addproc = &sol.add; //  也可以写成这样：sol._addproc = sol.add;
    res = sol._addproc(1, 2);
    return 0;
}

这个链接里，是类外声明的函数指针类型，然后函数指针是全局的；函数指针指向类的静态成员函数和非静态成员函数都是可以的；本质上还是类外使用函数指针；

https://www.cnblogs.com/AnnieKim/archive/2011/12/04/2275589.html