展开全部
三种校正的传递函数一般形式：
超前：Gc(32313133353236313431303231363533e4b893e5b19e31333431346433s)=(1+a*T*s)/(1+T*s) a>1;
滞后：Gc(s)=(1+b*T*s)/(1+T*s) b<1;
超前-滞后：Gc(s)=(1+b*T1*s)*(1+a*T2*s)/[(1+T1*s)*(1+T2*s)] ，a>1，b<1 且 bT1>aT2
然后就可以判断了，照表达式看应该是滞后。
计算机控制在控制功能如精度、实时性、可靠性等方面是模拟控制所无法比拟的。更为重要的是，由于计算机的引入而带来的管理功能(如报警管理，历史记录等)的增强更是模拟控制器根本无法实现的。
因此，在制冷空调自动控制的应用上，尤其在大中型空调系统的自动控制中，计算机控制已经占有主导地位。
扩展资料：
系统的传递函数与描述其运动规律的微分方程是对应的。可根据组成系统各单元的传递函数和它们之间的联结关系导出整体系统的传递函数，并用它分析系统的动态特性、稳定性，或根据给定要求综合控制系统，设计满意的控制器。
以传递函数为工具分析和综合控制系统的方法称为频域法。它不但是经典控制理论的基础，而且在以时域方法为基础的现代控制理论发展过程中，也不断发展形成了多变量频域控制理论，成为研究多变量控制系统的有力工具。传递函数中的复变量s在实部为零、虚部为角频率时就是频率响应。
DDC控制器中的C P U运行速度很快，并且其配置的输入输出端口(I/O)一般较多。因此，它可以同时控制多个回路，相当于多个模拟控制器。D DC控制器具有体积小、连线少、功能齐全、安全可靠、性能价格比较高等特点。

一种通过函数指针调用未确定原型的函数时参数传递的方法



A method of parameter passing while calling an unknown prototype function using a function pointer

作者：netbrain



0 
引言







如果提供函数原型，我们可以通过函数指针来调用函数并传递参数．但当被调用函数原型是未确定时，如何进行参数传递呢．传统的做法是将所有的参数放在一个结构里，并将其指针作为参数传递．例如_beginthread函数，如此做法显得不够自然和优雅．再有一个明显的例子时导出一组函数作为接口，通过索引进行调用，所有的函数原型不得不全部一样．


 
本文提出一种方法，可以解决上述或者类似问题．文中讲述使用VC/VS2008，以Win32和IA-32为平台，感谢他们．



1 
目的






首先用实例来说明问题．





//

线程1

 


int He(int h, int e)


{


    return h * e;


}


 
//

线程2


int Xie(int x, int i, int e)


{


    return x + i + e;


}



创建两个线程He和Xie，用传统方法，不解释，你懂的．



如果_beginthread可以像printf那样，支持可变参数就好了．但printf是对参数进行解释来实现可变参数的，除去效率原因，目的也与我们的不大一样．本文将要达到以下这样的效果．


void Turf(void)


{


//create_thread是本文即将实现的函数




    create_thread(He, 2, 3);


    create_thread(Xie, 1, 2, 
3);


}


OK，看起来还是非常和谐的．


 
2 
原理






背景知识简单说明一下．




上面为一个栈说明图，由于未确定例如

He

函数的参数个数，所以create_thread不知如何压栈参数去调



用He

．

不过我们可以手动构建一个栈帧，只要He

的参数全部在栈帧内即可以

．恰巧的是，EBP

保存了调用函数的ESP

，而从参数1到调用函数的ESP

的这段空间内

，

一定是包含了所有的参数，我们把这一段栈帧，拷贝到栈顶，然后调用He

，剩下的事He

会自己去做了，虽然这样会多拷贝一些数据．


 
3 
实现





直接给代码，中间注释．

typedef void (__cdecl 
*THREAD_FUNCTION)();


 
//create_thread实际上使用

_create_thread，它的一个参数

stack_size一般不需要使用．




#define create_thread(tf, ...) _create_thread((THREAD_FUNCTION)tf, 0, 
__VA_ARGS__)

 
//主角登场了，实际上

_create_thread以及后面的函数，移植自

`VC/crt/src/thread.c'，中间去掉了一些

检查，主要框架不变，读者可以

根据需要自行修改．




HANDLE _create_thread(THREAD_FUNCTION tf, 
unsigned int ss, ...)


{


    _ptiddata ptd = NULL;


    HANDLE thdl = NULL;


    if(tf)


    {


        __set_flsgetvalue();


 
        //取得参数地址




        va_list ta = NULL;


        va_start(ta, ss);


 
        ptd = 
(_ptiddata)_calloc_crt(1, sizeof(_tiddata));


        if(ptd)


        {


            _initptd(ptd, 
_getptd()->ptlocinfo);


            ptd->_initaddr = (void 
*)tf;


            ptd->_initarg = ta;


 
                    //保存调用函数（比如上述的Turf()函数）的ESP，用以计算栈帧大小


            DWORD caller_esp = 
NULL;


            __asm


            {


                MOV EAX, DWORD 
PTR[EBP]


                MOV 
caller_esp, EAX


            }


            //为何要使用EVENT，后面会说到．


            HANDLE he = 
::CreateEvent(NULL, FALSE, FALSE, NULL);


            if(he)


            {


                            //使用保留字段，后果未知，建议采用更安全的做法．




                ptd->_reserved1 = (void 
*)caller_esp;


                ptd->_reserved2 = (void 
*)he;


                //开始真正的创建线程，注意call_thread

．




                thdl = 
::CreateThread(NULL, ss, call_thread, (LPVOID)ptd, CREATE_SUSPENDED, 
(LPDWORD)&(ptd->_tid));


                if(thdl)


                {


                    ptd->_thandle = 
(unsigned long)thdl;


                    if(::ResumeThread(thdl) == 
(DWORD)(-1L))


                    {


                        goto 
LL_ERROR_RESUME;


                    }


                                    //等待线程已经拷贝栈帧，否则如果_create_thread

函数立即退出，栈帧可能被破坏，线程拷贝错误的数据．




                    ::WaitForSingleObject(he, 
INFINITE);


                    ::CloseHandle(he);


                }


                else


                {


LL_ERROR_RESUME:


                    ::CloseHandle(he);


                    goto 
LL_ERROR;


                }


            }


            else


                goto LL_ERROR;


        }


        else


        {


LL_ERROR:


            thdl = (HANDLE)-1;


            _free_crt(ptd);


        }


    }


    return thdl;


}


 
unsigned long WINAPI _call_thread(void 
*ptd)


{


    unsigned long r = 0L;


    _ptiddata _ptd;


    __set_flsgetvalue();


    if((_ptd = 
(_ptiddata)__fls_getvalue(__get_flsindex())) == NULL)


    {


        if(!__fls_setvalue(__get_flsindex(), 
ptd))


        {


            ::ExitThread(GetLastError());


        }


    }


    else


    {


        _ptd->_initaddr = 
((_ptiddata)ptd)->_initaddr;


        _ptd->_initarg = 
((_ptiddata)ptd)->_initarg;


        _ptd->_thandle = 
((_ptiddata)ptd)->_thandle;


        _ptd->_reserved1 = 
((_ptiddata)ptd)->_reserved1;


        _ptd->_reserved2 = 
((_ptiddata)ptd)->_reserved2;


        _freefls(ptd);


        ptd = _ptd;


    }


    DWORD caller_esp = 
(DWORD)((_ptiddata)ptd)->_reserved1;


    DWORD tf = 
(DWORD)((_ptiddata)ptd)->_initaddr;


    DWORD callee_argument =  
(DWORD)((_ptiddata)ptd)->_initarg;


    UINT caller_stack_frame_size = 
(UINT)

caller_esp - 
(UINT)callee_argument;


    __asm


    {


        //保存ESP


        MOV EBX, ESP


        //开始拷

贝栈帧




        //计数




        MOV ECX, 
caller_stack_frame_size


        //源地址




        MOV ESI, 
callee_argument


        //目的地址，有一个假设ESP

大于ECX






        MOV EAX, EBX


        SUB EAX, ECX


        MOV EDI, EAX


        //拷贝




        REP MOVSB


        //结束拷贝栈帧




        //ESP指向新的栈帧




        MOV ESP, EAX


    }


    //已经完成



拷贝栈帧，create_th



read

可以安全的退出．




    ::SetEvent((HANDLE)(((_ptiddata)ptd)->_reserved2));


    __asm


    {


    

    

//调用线程




        CALL tf


        //恢复ESP






        MOV ESP, EBX


        //保存返回值




        MOV r, EAX


    }


    _destroy_thread();


    return r;


}


 
void 
_destroy_thread(void)


{


    return _endthread();


}







原理应该还是说明白了，余下的读者亲自调试就会清楚．




 
4 附赠






 
关于导出一组函数作为接口，通过索引进行调用，做过的读者应该明白，应用同样的原理同样可以达到．有空再整理出例子．




我还没有找出其它的应用，如果您有其它方面的应用，欢迎指出．




 
5 
版本






2011年03月18日第一次编写．

有时候我们给一个函数传递的参数数量是不确定的，比如如果想打印多个字符串，数量不定，那么可以这么写：
#include <stdarg.h>
#include <iostream>

using namespace std;

void printStrings(int argNum, ...) {
    va_list args;
    va_start(args, argNum);
    for (int i = 0; i < argNum; i++)
    {
        cout << va_arg(args, char*) << ' ';
    }
    cout << endl;
    va_end(args);
}

int main() {
	printStrings(2, "hello", "world");
    return 0;
}

至于如何传递多个数量不定、类型不定的参数呢？，看这里。

简单来说，c++对传递不定数量参数列表是很不友好的，极不建议这样做，所以能用容器装着传就用容器吧。。。（python真香）

函数的参数传递
在讲函数参数传递前先补充两个名词
1、形参： 即形式参数，它是在定义函数名和函数体时使用的参数，目的是接收调用该函数传递参数。

2、实参： 即实际参数，它是在调用时传递给函数的参数，传递给被调用函数的值。实参可以是常量、变量、表达式、函数等，但无论是哪种类型，在进行函数调用时必须具有确定的值，这些值会传递给形参。
下面用一段代码具体说明形参和实参
def sum(a,b):
    retutn a+b
    
sum(10,20)


在sum函数中a和b就是形参。第四行10和20就是实参

函数传递方式如下
1、位置参数传递
当调用函数时传入的参数位置是和定义函数的参数位置相对应，当使用位置参数传递时，调用韩式传入的参数数量要和定义函数参数的数量相同，否则程序会出错。这也是函数默认的传递方式

观察如下代码

fun_01:
def fun_01(a,b,c):
    return a,b,c

print(fun_01(1,2,3))

运行结果：
(1,2,3)

fun_02:
def fun_02(a,b,c):
    return c,b,a

print(fun_01(1,2,3))

运行结果：
(3,2,1)

上面两个函数在定义时参数名是一样的，并且在调用时传入的参数也是一样的，但返回的结果却不同。这是由于当函数调用时，传入的参数位置和定义的函数参数位置相对应，当调用函数传入参数那一刻，函数的参数值就已经确定了，至于输出结果的顺序是由于return返回值的顺序决定的。

2、关键字参数传递
假设某个函数的参数非常复杂，为了不让程序出错，我们可以把参数的名称和值绑定在一起，使用参数名提供的参数叫作关键字参数

观察如下代码

fun_01:
def connect(url,port):
    return 'url is %s,and port is %s'%(url,port)

print(connect(url='www.baidu.com',port='80'))

运行结果：
url is www.baidu.com,and port is 80

注：

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为python解释器能够用参数名匹配参数值
关键字参数可以和位置参数混合使用，但位置参数必须要出现在关键字参数之前


3、参数默认值
在定义函数时，可以给参数赋予默认值，如果该参数最终没有被传递值，将使用该默认值

观察如下代码
def sum(a,b，c=20):
    retutn a+b+c
    
sum(10,20)


运行结果：
50

注： 参数c使用了默认值

4、可变参数
在python中函数可以定义可变参数，即传入函数的参数是可变的

语法格式如下：
def functionname([formal_args,]*args,**kwargs):
    function_sutite
    return [expression]

说明： 在上述格式中，以星号（*）开始的变量args会存放所有的未命名的变量参数，args为元组；以**开始的变量kwargs会存放命名参数，即形如key=value的参数，kwargs为字典。

观察如下代码
def test(*args,**kwargs):
   print(args)
   print(kwargs)
test(1,2,3,a=4,b=5)

运行结果：
(1,2,3)
{'a':4,'b':5}

注： 如果*和**参数混合使用，那么传入的顺序必须和声明的顺序一致，如果调用函数时没有指定参数，那么它就是一个空的元组或者空的字典

对*和**总结：


使用*可以将未命名的参数打包成元组类型


使用**可以将命名的参数打包成字典类型



5、解包裹
所谓解包裹就是在调用函数时使用*和**。但是解包裹课可变参数传递并不是相反的操作，他们是两个独立的过程
观察如下代码
*解元组类型
def test(a,b,c):
   print(a,b,c)

args=(1,2,3)
test(*args)

运行结果：
1 2 3

**解字典类型
def test(a,b,c):
   print(a,b,c)

kwargs=('a':1,'b':2,'c':3)
test(**kwargs)

运行结果：
1 2 3


6、混合传递方式
前面介绍的五种参数传递方式在定义和调用函数时可以混合使用，但在混合使用需要符合以下规则：

先位置参数传递
再关键字参数传递
再可变参数传递

注： 此方式在此不做代码演示