这是c++11新添加的,头文件#include <functional>

 

官方说明：

Class template std::function is a general-purpose polymorphic function wrapper. Instances of std::function can store, copy, and invoke any Callable target -- functions, lambda expressions, bind expressions, or other function objects, as well as pointers to member functions and pointers to data members.

The stored callable object is called the target of std::function. If a std::function contains no target, it is called empty. Invoking the target of an empty std::function results in std::bad_function_call exception being thrown.

std::function satisfies the requirements of CopyConstructible and CopyAssignable.

 

类模板std::function是一种通用的多态函数包装器。std::function可以存储，复制和调用任何Callable 目标的实例- 函数，lambda表达式，绑定表达式或其他函数对象，以及指向成员函数和指向数据成员的指针。

所存储的可调用对象被称为目标的std::function。如果a不std::function包含目标，则将其称为空。调用目标的的空std::function的结果的std :: bad_function_call抛出异常。

std::function满足CopyConstructible和CopyAssignable的要求。

 

个人浅解：

将其当做std::string    、std::vector<> 、这样的类型就可以了。只不过其值为函数指针，但比函数指针更灵活。

因为std::function  是一种模板，所以要传入类型，就如std::vector<int>  传入类型int一样

不过,std::function传入的是函数类型  返回值 （参数类型） 如：std::function<void (int)>

 

示例1 ： 普通函数

 

void gFunc()
{
	cout << "gFunc" << endl;
}
int main()
{
	std::function<void()> f = gFunc;
	f();

	getchar();
	return 0;
}

 

示例2 模板函数

template <class T>
T g_Add(T i, T j)
{
	cout << i + j;
	return i + j;
}


int main()
{
	std::function<int(int,int)> f = g_Add<int>;
	f(2,3);

	getchar();
	return 0;
}

 

示例三： 匿名函数

auto g_Lambda = [](int i, int j)
{
	return i + j;
}; //匿名函数 此处有分号

int main()
{
	std::function<int(int, int)> f = g_Lambda;
	cout<<f(2,3);

	getchar();
	return 0;
}


示例四：函数对象

/函数对象
struct Add
{
	int operator()(int i, int j)
	{
		return i + j;
	}
};

//模板函数对象
template <class T>
struct AddT
{
	T operator()(T i, T j)
	{
		return i + j;
	}
};


int main()
{
	std::function<int(int, int)> f = Add();
	cout<<f(2,3)<<endl;

	std::function<int(int, int)> ft = AddT<int>();
	cout << ft(5, 6)<<endl;

	getchar();
	return 0;
}

 

示例5：类成员函数

class Computer
{
public:
	static int Add(int i, int j)
	{
		return i + j;
	}

	template<class T>
	static T AddT(T i, T j)
	{
		return i + j;
	}

	int AddN(int i, int j)
	{
		return i + j;
	}
};

//存储对成员函数的调用 

int main()
{
	//1、 类静态函数
	std::function<int(int, int)> f = &Computer::Add;
	cout << f(1, 1) << endl;

	//2、 类静态模板函数
	std::function<int(int, int)> ft = &Computer::AddT<int>;
	cout << ft(1, 1) << endl;



	//普通函数绑定  需要构造类对象
	Computer c;

	//3、 普通函数 需使用bind,将类对象地址 &c 绑定上
	std::function<int(int, int)> fN = std::bind(&Computer::AddN, &c, placeholders::_1, placeholders::_2);
	cout << fN(1, 1) << endl;


	//4、普通函数， 也可以这样调用  个人觉得这个比 bind 麻烦，不建议
	std::function <int(const Computer ＆, int, int)> fN2 = &Computer::AddN;
	cout << fN2(c,1, 1) << endl;





	getchar();
	return 0;
}


 

 再补充一个 cppreference.com的例子

#include <functional>
#include <iostream>
 
struct Foo {
    Foo(int num) : num_(num) {}
    void print_add(int i) const { std::cout << num_+i << '\n'; }
    int num_;
};
 
void print_num(int i)
{
    std::cout << i << '\n';
}
 
struct PrintNum {
    void operator()(int i) const
    {
        std::cout << i << '\n';
    }
};
 
int main()
{
    // store a free function
    std::function<void(int)> f_display = print_num;
    f_display(-9);
 
    // store a lambda
    std::function<void()> f_display_42 = []() { print_num(42); };
    f_display_42();
 
    // store the result of a call to std::bind
    std::function<void()> f_display_31337 = std::bind(print_num, 31337);
    f_display_31337();
 
    // store a call to a member function
    std::function<void(const Foo&, int)> f_add_display = &Foo::print_add;
    const Foo foo(314159);
    f_add_display(foo, 1);
    f_add_display(314159, 1);
 
    // store a call to a data member accessor
    std::function<int(Foo const&)> f_num = &Foo::num_;
    std::cout << "num_: " << f_num(foo) << '\n';
 
    // store a call to a member function and object
    using std::placeholders::_1;
    std::function<void(int)> f_add_display2 = std::bind( &Foo::print_add, foo, _1 );
    f_add_display2(2);
 
    // store a call to a member function and object ptr
    std::function<void(int)> f_add_display3 = std::bind( &Foo::print_add, &foo, _1 );
    f_add_display3(3);
 
    // store a call to a function object
    std::function<void(int)> f_display_obj = PrintNum();
    f_display_obj(18);
}



-9
42
31337
314160
314160
num_: 314159
314161
314162
18



 

参考资料：

https://www.cnblogs.com/heartchord/p/5017071.html

https://en.cppreference.com/w/cpp/utility/functional/function

1.创建自定义函数

DELIMITER $$
DROP FUNCTION IF EXISTS genPerson$$
CREATE FUNCTION genPerson(name varchar(20)) RETURNS varchar(50)
BEGIN
  DECLARE str VARCHAR(50) DEFAULT '';
  SET @tableName=name;
  SET str=CONCAT('create table ', @tableName,'(id int, name varchar(20));');
  return str;
END $$
DELIMITER ;

   （1）DELIMITER $$  定义结束符。MySQL默认的结束符是分号，但是函数体中可能用到分号。为了避免冲突，需要另外定义结束符。

   （2）DROP FUNCTION IF EXISTS genPerson$$  如果函数genPerson已经存在了，就删除掉。

   （3）CREATE FUNCTION 创建函数genPerson，函数的参数是name，返回值是varchar(50)。

   （4）函数体放在BEGIN 与 END之间。

   （5）DECLARE 声明变量，str类型是varchar(50)，默认值是空。

   （6）CONCAT连接多个字符串。

   （7）RETURN 返回拼接后的字符串str。

2.执行

select genPerson('student');

  

 

 

函数是由事件驱动的或者当它被调用时可执行的可重复使用的代码块
JavaScript函数语法
函数就是包裹在花括号中的代码块，前面使用了关键词Function:

    function functionName() {
        这里是要执行的代码
    }
调用带参数的函数

在调用函数时，可以向其传递值，这些值被称为参数。
这些参数可以在函数中使用。
可以发送任意多的参数，由逗号 (,) 分隔:

myFunction(argument1,argument2)
当声明函数时，把参数作为变量来声明：


<script>
function demo(name,job) {
    alert("Welcome "+name+", the"+job)
}
</script>
<input type="button" value="button" οnclick="demo('lily','CEO')">
<input type="button" value="button" οnclick="demo('Tom','Builder')">
带有返回值的函数

函数将值返回调用它的地方，通过使用return语句就可以实现。
在使用return语句时，函数会停止执行，并返回指定的值。

function myFunction() {
    var x = 5;
    return x;
}
函数会返回值5.

注：整个javascript并不会停止执行，仅仅是函数。javascript将继续执行代码，从调用函数的地方。
函数调用将被返回值取代：

var myVar = myFunction();
myVar变量的值是5，也就是函数"myFunction()"所返回的值。

即使不把它保存为变量，也可以使用返回值：

document.getElementById("demo").innerHTML=myFunction();
"demo"元素的innerHTML将成为5，也就是函数“myFunction()”所返回的值。

可以使返回值基于传递到函数中的参数：

<p id="demo"></p>

<script>
function myFunction(a,b) {
    return a*b;
}
document.getElementById("demo").innerHTML=myFunction(10,23);
</script>
如果仅仅希望退出函数时，也可以使用return语句。返回值是可选择的：


    function myfunction(a,b) {
        if(a>b){
            return
        }
        x = a+b;
    }


ECMAScript
函数是一组可以随时随地运行的语句，函数是ECMA的核心。
函数声明：关键词function、函数名、一组参数，以及置于括号中的待执行代码。
函数的基本语法：

function functionName(arg0,arg1,...argN){
   statement
}
例如：


function sayHi(sName,sMessage){
    alert("hello"+sName+sMessage);
}
函数返回值，不需要像java使用void专门声明，即使函数确实有值，也不必明确声明它。函数只需要使用return运算符跟要返回的值即可。


function diff(iNum1,iNum2){
   return iNum1+iNum2;
   alert(iNum1+iNum2);
}


ECMAScript  arguments对象

在函数代码中，使用特殊对象arguments，开发者无需明确指出参数名，就能访问它们。

<script>
    function sayHi(message) {
        if(arguments[0] == "bye"){
            return
        }
        alert("message 不是 bye")
    }
    sayHi("bdfa");
</script>
arguments 检查参数个数

引用arguments.length

<script>
    function demo() {
        console.log(arguments.length);
    }
    demo("heoo","sdfs","258");
    demo(1,2,5,11)
    demo();
</script>
模拟函数重载

用arguments对象判断传递给函数的参数个数，即可模拟函数重载：

<script>
    function demo() {
        if(arguments.length==1){
            console.log(arguments[0]+5);
        }else if(arguments.length==2){
            console.log(arguments[0]+arguments[1]);
        }
    }
    demo(10);
    demo(11,12);
    demo();
</script>


ECMAScript 的函数实际上是功能完整的对象
Function对象(类)
ECMAScript 函数是一个功能完整的对象
Function类可以表示开发者定义的任何函数
用Function类直接创建函数语法如下：
var function_name = new function(arg1,arg2,..,argN,function_body)
arg是一个参数，function_body参数是函数主体（要执行的代码）。这些参数必须是字符串
function sayHi(sName,sMessage){
  alert("Hello"+sName+","+sMessage);
}
可以写成
var sayHi=new Function("sName","sMessage","alert(\"hello\"+sName+sMessage);");
Function对象的length属性
ECMAScript定义的属性length声明了函数期望的参数个数。例如：
    function doAdd(iNum) {
        alert(iNum+10);
    }
    function sayHi1() {
        alert("Hi");
    }
    alert(doAdd.length);
    alert(sayHi1.length);


function 与 Function的区别
var a = new Function("document.write(a)");
var b= function(){document.write(b)};
function c(){ document.write(c)};

Function是一个类，类似Array,String,Number,Object等的原型
如var arr= new Array();
Function 是一个构造函数，用于动态构建一个函数
function 是关键字，通过function生成的函数实际上是一个Funciton对象的实例。
ECMAScript支持闭包(closure)
闭包，指的是词法表示包括不被计算的变量的函数，也就是说，函数可以使用函数之外定义的变量
var sMessage = "hello world";

function sayHelloWorld() {
  alert(sMessage);
}

sayHelloWorld();

        近期在学习电机的智能控制，里面用到了Matlab中的S函数，在此先对S-function做一个小结。

S-function模块，位于Simulink/User-Defined Functions模块库中，S-function模块及其对话框如下图所示：



         S-function name:填入S-function的函数名称，这样就建立了S-function模块与M文件形式的S-function之间的对应关系，单机后面的Edit可以打开S-function的M文件的编辑窗口。

        S-function parameters：填入S-function需要输入的外部参数的名称，如果有多个变量的话，中间用逗号隔开，如a,b,c.

        S-function modules:只有S-function是用C语言编写并用MEX工具编译的C MEX文件时，才需要填写该参数。

        设置完这些参数后，S-function模块就成为了一个具有指定功能的模块，它的功能取决于S-function的内容，也可对内容修改进而改变模块功能。

        编写M文件S-function

        在目录toolbol\simulink\blocks中给出了M文件S-function的模板sfuntmpl.m,我电脑上的路径如下图所示：



        该模板由一个主函数和六个子函数组成，每个子函数对应一个特定的flag值。主函数通过flag的值分别调用不同的子函数。在仿真期间，这些子函数被S-function以回调程序的方式调用，执行S-function所需的任务。

       学习S-function最直接有效的方法就是学习S-function范例，下面是我详细分析的sfuntmpl.m模板代码内容：

function [sys,x0,str,ts,simStateCompliance] = sfuntmpl(t,x,u,flag)
%主函数
%主函数包含四个输出：
%                 sys数组包含某个子函数返回的值
%                 x0为所有状态的初始化向量
%                 str是保留参数，总是一个空矩阵
%                 Ts返回系统采样时间
%函数的四个输入分别为采样时间t、状态x、输入u和仿真流程控制标志变量flag
%输入参数后面还可以接续一系列的附带参数simStateCompliance
switch flag,
  case 0,
      [sys,x0,str,ts,simStateCompliance]=mdlInitializeSizes;
  case 1,
    sys=mdlDerivatives(t,x,u);
  case 2,
    sys=mdlUpdate(t,x,u);
  case 3,
    sys=mdlOutputs(t,x,u);
  case 4,
    sys=mdlGetTimeOfNextVarHit(t,x,u);
  case 9,
    sys=mdlTerminate(t,x,u);
  otherwise
    DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag));

end
%主函数结束
%下面是各个子函数，即各个回调过程
function [sys,x0,str,ts,simStateCompliance]=mdlInitializeSizes
%初始化回调子函数
%提供状态、输入、输出、采样时间数目和初始状态的值
%初始化阶段，标志变量flag首先被置为0，S-function首次被调用时
%该子函数首先被调用，且为S-function模块提供下面信息
%该子函数必须存在
sizes = simsizes;
%生成sizes数据结构，信息被包含在其中
sizes.NumContStates  = 0;
%连续状态数，缺省为0
sizes.NumDiscStates  = 0;
%离散状态数，缺省为0
sizes.NumOutputs     = 0;
%输出个数，缺省为0
sizes.NumInputs      = 0;
%输入个数，缺省为0
sizes.DirFeedthrough = 1;
%是否存在直馈通道，1存在，0不存在
sizes.NumSampleTimes = 1;
%采样时间个数，至少是一个
sys = simsizes(sizes);
%返回size数据结构所包含的信息
x0  = [];
%设置初始状态
str = [];
%保留变量置空
ts  = [0 0];
%设置采样时间
simStateCompliance = 'UnknownSimState';
function sys=mdlDerivatives(t,x,u)
%计算导数回调子函数
%给定t,x,u计算连续状态的导数，可以在此给出系统的连续状态方程
%该子函数可以不存在
sys = [];
%sys表示状态导数，即dx
function sys=mdlUpdate(t,x,u)
%状态更新回调子函数
%给定t、x、u计算离散状态的更新
%每个仿真步内必然调用该子函数，不论是否有意义
%除了在此描述系统的离散状态方程外，还可以在此添加其他每个仿真步内都必须执行的代码
sys = [];
%sys表示下一个离散状态，即x(k+1)
function sys=mdlOutputs(t,x,u)
%计算输出回调函数
%给定t,x,u计算输出，可以在此描述系统的输出方程
%该子函数必须存在
sys = [];
%sys表示输出，即y
function sys=mdlGetTimeOfNextVarHit(t,x,u)
%计算下一个采样时间
%仅在系统是变采样时间系统时调用
sampleTime = 1; 
%设置下一次采样时间是在1s以后
sys = t + sampleTime;
%sys表示下一个采样时间点
function sys=mdlTerminate(t,x,u)
%仿真结束时要调用的回调函数
%在仿真结束时，可以在此完成仿真结束所需的必要工作
sys = [];

        S-function应用实例

        用S-function实现Gain增益模块，即对输入信号进行放大。

        (1)首先将模板文件sfuntmpl.m另存为Gain.m,修改主函数，增加新的参数gain,修改函数名为Gain:



        (2)增益参数是用来计算输出值的，所以需要对mdlOutput的调用进行修改：



        (3)修改mdlInitializeSizes初始化回调子函数：



        (4)修改mdlOutput输出子函数：



        (5)保存Gain.m，并建立如下图所示的系统模型，对余弦信号的幅值放大gain倍。在S-function模块的参数对话框中设置S-function parameter 为3（该设置即为外部输入gain的大小）



 

        完整代码如下所示：

function [sys,x0,str,ts,simStateCompliance] = Gain(t,x,u,flag,gain)
switch flag,
  case 0,
    [sys,x0,str,ts,simStateCompliance]=mdlInitializeSizes;
  case 1,
    sys=mdlDerivatives(t,x,u);
  case 2,
    sys=mdlUpdate(t,x,u);
  case 3,
    sys=mdlOutputs(t,x,u,gain);
  case 4,
    sys=mdlGetTimeOfNextVarHit(t,x,u);
  case 9,
    sys=mdlTerminate(t,x,u);
  otherwise
    DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag));
end
function [sys,x0,str,ts,simStateCompliance]=mdlInitializeSizes
sizes = simsizes;
sizes.NumContStates  = 0;
sizes.NumDiscStates  = 0;
sizes.NumOutputs     = 1;
sizes.NumInputs      = 1;
sizes.DirFeedthrough = 1;
sizes.NumSampleTimes = 1; 
sys = simsizes(sizes);
x0  = [];
str = [];
ts  = [0 0];
simStateCompliance = 'UnknownSimState';
function sys=mdlDerivatives(t,x,u)
sys = [];
function sys=mdlUpdate(t,x,u)
sys = [];
function sys=mdlOutputs(t,x,u,gain)
sys =gain*u;
function sys=mdlGetTimeOfNextVarHit(t,x,u)
sampleTime = 1;   
sys = t + sampleTime;
function sys=mdlTerminate(t,x,u)
sys = [];

          (6)运行仿真，仿真结果如下图所示蓝线为输入，黄线为输出，输出放大了3（gain）倍。



 

        注：在参数gain的设置时，为了更直观的表达可以对S-function模块进行封装

        右击S-function模块，选择Mask，Creat Mask...对模块进行封装，如下图所示：



        进行参数设置，如下图所示：



        对S-function的S-function parameter 选项重新设置，如下图所示：



        S-function parameter 的名称要和封装模块中的参数名称一样，此例中都为gain。都设置完成后再次点击S-function函数Gain会弹出如下参数设置框：



        把增益gain设置为5，仿真结果如下：



        这样可以更方便的对增益参数gain进行设置。

        以上就是Matlab S-function 函数的使用心得，要用好S-function还是要多编几个程序，孰能生巧。S-function是Simulink最具魅力的地方，结合了Simulink框图简洁的特点和编程灵活的有点，增强和扩展了Sinulink的强大机制。