函数 订阅
函数(function)的定义通常分为传统定义和近代定义,函数的两个定义本质是相同的,只是叙述概念的出发点不同,传统定义是从运动变化的观点出发,而近代定义是从集合、映射的观点出发。函数的近代定义是给定一个数集A,假设其中的元素为x,对A中的元素x施加对应法则f,记作f(x),得到另一数集B,假设B中的元素为y,则y与x之间的等量关系可以用y=f(x)表示,函数概念含有三个要素:定义域A、值域B和对应法则f。其中核心是对应法则f,它是函数关系的本质特征。 [1]  函数,最早由中国清朝数学家李善兰翻译,出于其著作《代数学》。之所以这么翻译,他给出的原因是“凡此变数中函彼变数者,则此为彼之函数”,也即函数指一个量随着另一个量的变化而变化,或者说一个量中包含另一个量。 展开全文
函数(function)的定义通常分为传统定义和近代定义,函数的两个定义本质是相同的,只是叙述概念的出发点不同,传统定义是从运动变化的观点出发,而近代定义是从集合、映射的观点出发。函数的近代定义是给定一个数集A,假设其中的元素为x,对A中的元素x施加对应法则f,记作f(x),得到另一数集B,假设B中的元素为y,则y与x之间的等量关系可以用y=f(x)表示,函数概念含有三个要素:定义域A、值域B和对应法则f。其中核心是对应法则f,它是函数关系的本质特征。 [1]  函数,最早由中国清朝数学家李善兰翻译,出于其著作《代数学》。之所以这么翻译,他给出的原因是“凡此变数中函彼变数者,则此为彼之函数”,也即函数指一个量随着另一个量的变化而变化,或者说一个量中包含另一个量。
信息
提出者
莱布尼茨(G.W.Leibniz)
表示法
列表法、图像法、解析法
三要素
自变量、因变量、对应法则
应用学科
数学、计算机科学等
中文名
函数
外文名
function
提出时间
17世纪
表达式
y=f(x)
函数详细介绍
首先要理解,函数是发生在集合之间的一种对应关系。然后,要理解发生在A、B之间的函数关系不止且不止一个。最后,要重点理解函数的三要素。函数的对应法则通常用解析式表示,但大量的函数关系是无法用解析式表示的,可以用图像、表格及其他形式表示 [2]  。在一个变化过程中,发生变化的量叫变量(数学中,常量为x,而y则随x值的变化而变化),有些数值是不随变量而改变的,我们称它们为常量。自变量(函数):一个与它量有关联的变量,这一量中的任何一值都能在它量中找到对应的固定值。因变量(函数):随着自变量的变化而变化,且自变量取唯一值时,因变量(函数)有且只有唯一值与其相对应。函数值:在y是x的函数中,x确定一个值,y就随之确定一个值,当x取a时,y就随之确定为b,b就叫做a的函数值 [2]  。设A和B是两个非空集合,如果按照某种对应关系 ,对于集合A中的任何一个元素a,在集合B中都存在唯一的一个元素b与之对应,那么,这样的对应(包括集合A,B,以及集合A到集合B的对应关系f)叫做集合A到集合B的映射(Mapping),记作 。其中,b称为a在映射f下的象,记作: ; a称为b关于映射f的原象。集合A中所有元素的象的集合记作f(A)。则有:定义在非空数集之间的映射称为函数。(函数的自变量是一种特殊的原象,因变量是特殊的象) [2]  函数与不等式和方程存在联系(初等函数)。令函数值等于零,从几何角度看,对应的自变量的值就是图像与X轴的交点的横坐标;从代数角度看,对应的自变量是方程的解。另外,把函数的表达式(无表达式的函数除外)中的“=”换成“<”或“>”,再把“Y”换成其它代数式,函数就变成了不等式,可以求自变量的范围 [2]  。如果X到Y的二元关系 ,对于每个 ,都有唯一的 ,使得 ,则称f为X到Y的函数,记做: 。当 时,称f为n元函数 [2]  。输入值的集合X被称为f的定义域;可能的输出值的集合Y被称为f的值域。函数的值域是指定义域中全部元素通过映射f得到的实际输出值的集合。注意,把对应域称作值域是不正确的,函数的值域是函数的对应域的子集。计算机科学中,参数和返回值的数据类型分别确定了子程序的定义域和对应域。因此定义域和对应域是函数一开始就确定的强制进行约束。另一方面,值域是和实际的实现有关 [2]  。 单射函数,将不同的变量映射到不同的值。即:对于所有 和 ,当 时有 。满射函数,其值域即为其对应域。即:对映射f的对应域中之任意y,都存在至少一个x满足 y=f(x)。双射函数,既是单射的又是满射的。也叫一一对应。双射函数经常被用于表明集合X和Y是等势的,即有一样的基数。如果在两个集合之间可以建立一个一一对应,则说这两个集合等势 [2]  。 元素在的象就是f(x),他们所取的值为0 [2]  。函数f的图象是平面上点对 的集合,其中x取定义域上所有成员的。函数图象可以帮助理解证明一些定理。如果X和Y都是连续的线,则函数的图象有很直观表示注意两个集合X和Y的二元关系有两个定义:一是三元组(X,Y,G),其中G是关系的图;二是索性以关系的图定义。用第二个定义则函数f等于其图象 [2]  。
收起全文
精华内容
下载资源
问答
  • 函数
    万次阅读 多人点赞
    2018-05-24 08:11:10

    前言

    函数指针和指针函数,在学习 C 语言的时候遇到这两个东西简直头疼,当然还有更头疼的,比如什么函数指针函数、指针函数指针、数组指针、指针数组、函数指针数组等等,描述越长其定义就越复杂,当然理解起来就越难,特别是刚开始学习这门语言的童鞋,估计碰到这些东西就已经要崩溃了,然后好不容易死记硬背下来应付考试或者面试,然后过了几天发现,又是根本不会用,也不知道该在哪些地方用,这就尴尬了。
    今天这里只讲两个相对简单的,其实上面说那些太复杂的东西也真的很少用,即便是用了理解起来很麻烦,所以莫不如先深刻理解这两个比较容易的,并且项目中比较常用到。

    正文

    先来看看两者的定义以及说明。

    指针函数

    定义

    指针函数,简单的来说,就是一个返回指针的函数,其本质是一个函数,而该函数的返回值是一个指针。
    声明格式为:*类型标识符 函数名(参数表)

    这似乎并不难理解,再进一步描述一下。
    看看下面这个函数声明:

    int fun(int x,int y);
    

    这种函数应该都很熟悉,其实就是一个函数,然后返回值是一个 int 类型,是一个数值。
    接着看下面这个函数声明:

    int *fun(int x,int y);
    

    这和上面那个函数唯一的区别就是在函数名前面多了一个*号,而这个函数就是一个指针函数。其返回值是一个 int 类型的指针,是一个地址。

    这样描述应该很容易理解了,所谓的指针函数也没什么特别的,和普通函数对比不过就是其返回了一个指针(即地址值)而已。

    指针函数的写法

    int *fun(int x,int y);
    int * fun(int x,int y);
    int* fun(int x,int y);
    

    这个写法看个人习惯,其实如果*靠近返回值类型的话可能更容易理解其定义。

    示例

    (由于本人习惯于 Qt 中进行开发,所以这里为了方便,示例是在 Qt 工程中写的,其语法是一样的,只是输出方式不同)
    来看一个非常简单的示例:

    typedef struct _Data{
        int a;
        int b;
    }Data;
    
    //指针函数
    Data* f(int a,int b){
        Data * data = new Data;
        data->a = a;
        data->b = b;
        return data;
    }
    
    int main(int argc, char *argv[])
    {
        QApplication a(argc, argv);
        //调用指针函数
        Data * myData = f(4,5);
        qDebug() << "f(4,5) = " << myData->a << myData->b;
    
        return a.exec();
    }
    
    

    输出如下:

    f(4,5) =  4 5
    

    注意:在调用指针函数时,需要一个同类型的指针来接收其函数的返回值。
    不过也可以将其返回值定义为 void*类型,在调用的时候强制转换返回值为自己想要的类型,如下:

    //指针函数
    void* f(int a,int b){
        Data * data = new Data;
        data->a = a;
        data->b = b;
        return data;
    }
    
    调用:
    Data * myData = static_cast<Data*>(f(4,5));
    

    其输出结果是一样的,不过不建议这么使用,因为强制转换可能会带来风险。

    函数指针

    定义

    函数指针,其本质是一个指针变量,该指针指向这个函数。总结来说,函数指针就是指向函数的指针。
    声明格式:类型说明符 (*函数名) (参数)
    如下:

    int (*fun)(int x,int y);
    

    函数指针是需要把一个函数的地址赋值给它,有两种写法:

    fun = &Function;
    fun = Function;
    

    取地址运算符&不是必需的,因为一个函数标识符就表示了它的地址,如果是函数调用,还必须包含一个圆括号括起来的参数表。

    调用函数指针的方式也有两种:

    x = (*fun)();
    x = fun();
    

    两种方式均可,其中第二种看上去和普通的函数调用没啥区别,如果可以的话,建议使用第一种,因为可以清楚的指明这是通过指针的方式来调用函数。当然,也要看个人习惯,如果理解其定义,随便怎么用都行啦。

    示例

    int add(int x,int y){
        return x+y;
    }
    int sub(int x,int y){
        return x-y;
    }
    //函数指针
    int (*fun)(int x,int y);
    
    int main(int argc, char *argv[])
    {
        QApplication a(argc, argv);
        //第一种写法
        fun = add;
        qDebug() << "(*fun)(1,2) = " << (*fun)(1,2) ;
    	//第二种写法
        fun = &sub;
        qDebug() << "(*fun)(5,3) = " << (*fun)(5,3)  << fun(5,3);
    
        return a.exec();
    }
    
    

    输出如下:

    (*fun)(1,2) =  3
    (*fun)(5,2) =  2 2
    

    上面说到的几种赋值和调用方式我都分别使用了,其输出结果是一样的。

    二者区别

    通过以上的介绍,应该都能清楚的理解其二者的定义。那么简单的总结下二者的区别:

    定义不同

    指针函数本质是一个函数,其返回值为指针。
    函数指针本质是一个指针,其指向一个函数。

    写法不同

    指针函数:int* fun(int x,int y);
    函数指针:int (*fun)(int x,int y);
    可以简单粗暴的理解为,指针函数的*是属于数据类型的,而函数指针的星号是属于函数名的。
    再简单一点,可以这样辨别两者:函数名带括号的就是函数指针,否则就是指针函数。

    用法不同

    上面已经写了详细示例,这里就不在啰嗦了。

    总而言之,这两个东西很容易搞混淆,一定要深入理解其两者定义和区别,避免犯错。

    另外,本文都是针对普通函数指针进行介绍,如果是C++非静态成员函数指针,其用法会有一些区别,在另外一篇博客中单独介绍,文章在这里

    更多相关内容
  • 指针函数函数指针

    万次阅读 多人点赞 2019-03-30 16:21:36
    很多人因为搞不清这两个概念,干脆就避而远之,我刚接触C语言的时候对这两个概念也比较模糊,特别是当指针函数函数指针、函数指针变量、函数指针数组放在一块的时候,能把强迫症的人活活逼疯。 其实如果理解了这些...

    概述

    指针函数和函数指针是C语言里两个比较绕的概念。但是不仅面试题爱考,实际应用中也比较广泛。很多人因为搞不清这两个概念,干脆就避而远之,我刚接触C语言的时候对这两个概念也比较模糊,特别是当指针函数、函数指针、函数指针变量、函数指针数组放在一块的时候,能把强迫症的人活活逼疯。
    其实如果理解了这些概念的本质,是不需要死记硬背的,理解起来也比较容易。

    指针函数

    指针函数: 顾名思义,它的本质是一个函数,不过它的返回值是一个指针。其声明的形式如下所示:

    ret *func(args, ...);
    

    其中,func是一个函数,args是形参列表,ret *作为一个整体,是 func函数的返回值,是一个指针的形式。
    下面举一个具体的实例来做说明:

    文件:pointer_func.c

    # include <stdio.h>
    # include <stdlib.h>
    
    int * func_sum(int n)
    {
        if (n < 0)
        {
            printf("error:n must be > 0\n");
            exit(-1);
        }
        static int sum = 0;
        int *p = &sum;
        for (int i = 0; i < n; i++)
        {
            sum += i;
        }
        return p;
    }
    
    int main(void)
    {
        int num = 0;
        printf("please input one number:");
        scanf("%d", &num);
        int *p = func_sum(num); 
        printf("sum:%d\n", *p);
        return 0;
    }
    

    上例就是一个指针函数的例子,其中,int * func_sum(int n)就是一个指针函数, 其功能十分简单,是根据传入的参数n,来计算从0到n的所有自然数的和,其结果通过指针的形式返回给调用方。
    以上代码的运行结果如下所示:
    运行结果1
    如果上述代码使用普通的局部变量来实现,也是可以的,如下所示:

    文件:pointer_func2.c

    # include <stdio.h>
    # include <stdlib.h>
    
    int func_sum2(int n)
    {   
        if (n < 0)
        {   
            printf("error:n must be > 0\n");
            exit(-1);
        }
        int sum = 0;
        int i = 0;
        for (i = 0; i < n; i++)
        {   
            sum += i;
        }
        return sum;
    }
    
    int main(void)
    {
        int num = 0;
        printf("please input one number:");
        scanf("%d", &num);
        int ret = func_sum2(num);
        printf("sum2:%d\n", ret);
        return 0;
    }
    

    本案例中,func_sum2函数的功能与指针函数所实现的功能完全一样。
    在这里插入图片描述
    不过在使用指针函数时,需要注意一点,相信细心地读者已经发现了,对比func_sumfunc_sum2函数,除了返回值不一样之外,还有一个不同的地方在于,在func_sum中,变量sum使用的是静态局部变量,而func_sum2函数中,变量sum使用的则是普通的变量。
    如果我们把指针函数的sum定义为普通的局部变量,会是什么结果呢?不妨来试验一下:

    文件:pointer_func3.c

    # include <stdio.h>
    # include <stdlib.h>
    
    int * func_sum(int n)
    {
        if (n < 0)
        {
            printf("error:n must be > 0\n");
            exit(-1);
        }
        int sum = 0;
        int *p = &sum;
        for (int i = 0; i < n; i++)
        {
            sum += i;
        }
        return p;
    }
    
    int main(void)
    {
        int num = 0;
        printf("please input one number:");
        scanf("%d", &num);
        int *p = func_sum(num); 
        printf("sum:%d\n", *p);
        return 0;
    }
    

    执行以上程序,发现仍然能得到正确的结果:
    在这里插入图片描述
    可是如果我们把main函数里面稍微改动一下:

    int main(void)
    {
        int num = 0;
        printf("please input one number:");
        scanf("%d", &num);
        int *p = func_sum(num);
        printf("wait for a while...\n");    //此处加一句打印
        printf("sum:%d\n", *p);
        return 0;
    }
    

    我们在输出sum之前打印一句话,这时看到得到的结果完全不是我们预先想象的样子,得到的并不是我们想要的答案。
    在这里插入图片描述
    为什么会出现上面的结果呢?
    其实原因在于,一般的局部变量是存放于栈区的,当函数结束,栈区的变量就会释放掉,如果我们在函数内部定义一个变量,在使用一个指针去指向这个变量,当函数调用结束时,这个变量的空间就已经被释放,这时就算返回了该地址的指针,也不一定会得到正确的值。上面的示例中,在返回该指针后,立即访问,的确是得到了正确的结果,但这只是十分巧合的情况,如果我们等待一会儿再去访问该地址,很有可能该地址已经被其他的变量所占用,这时候得到的就不是我们想要的结果。甚至更严重的是,如果因此访问到了不可访问的内容,很有可能造成段错误等程序崩溃的情况。
    因此,在使用指针函数的时候,一定要避免出现返回局部变量指针的情况。
    那么为什么用了static就可以避免这个问题呢?
    原因是一旦使用了static去修饰变量,那么该变量就变成了静态变量。而静态变量是存放在数据段的,它的生命周期存在于整个程序运行期间,只要程序没有结束,该变量就会一直存在,所以该指针就能一直访问到该变量。
    因此,还有一种解决方案是使用全局变量,因为全局变量也是放在数据段的,但是并不推荐使用全局变量。

    函数指针

    与指针函数不同,函数指针 的本质是一个指针,该指针的地址指向了一个函数,所以它是指向函数的指针。
    我们知道,函数的定义是存在于代码段,因此,每个函数在代码段中,也有着自己的入口地址,函数指针就是指向代码段中函数入口地址的指针。
    其声明形式如下所示:

    ret (*p)(args, ...);
    

    其中,ret为返回值,*p作为一个整体,代表的是指向该函数的指针,args为形参列表。其中p被称为函数指针变量

    关于函数指针的初始化

    与数组类似,在数组中,数组名即代表着该数组的首地址,函数也是一样,函数名即是该数组的入口地址,因此,函数名就是该函数的函数指针。
    因此,我们可以采用如下的初始化方式:

    函数指针变量 =  函数名;
    

    下面还是以一个简单的例子来具体说明一下函数指针的应用:

    文件:func_pointer.c

    #include <stdio.h>
    
    int max(int a, int b)
    {
        return a > b ? a : b;
    }
    
    int main(void)
    {
        int (*p)(int, int); //函数指针的定义
        //int (*p)();       //函数指针的另一种定义方式,不过不建议使用
        //int (*p)(int a, int b);   //也可以使用这种方式定义函数指针
        
        p = max;    //函数指针初始化
    
        int ret = p(10, 15);    //函数指针的调用
        //int ret = (*max)(10,15);
        //int ret = (*p)(10,15);
        //以上两种写法与第一种写法是等价的,不过建议使用第一种方式
        printf("max = %d \n", ret);
        return 0;
    }
    

    上面这个函数的功能也十分简单,就是求两个数中较大的一个数。值得注意的是通过函数指针调用的方式。
    首先代码里提供了3种函数指针定义的方式,这三种方式都是正确的,比较推荐第一种和第三种定义方式。然后对函数指针进行初始化,前面已经提到过了,直接将函数名赋值给函数指针变量名即可。
    上述代码运行的结果如下:
    在这里插入图片描述
    调用的时候,既可以直接使用函数指针调用,也可以通过函数指针所指向的值去调用。(*p)所代表的就是函数指针所指向的值,也就是函数本身,这样调用自然不会有问题。有兴趣的同学可以去试一试。

    为什么要使用函数指针?

    那么,有不少人就觉得,本来很简单的函数调用,搞那么复杂干什么?其实在这样比较简单的代码实现中不容易看出来,当项目比较大,代码变得复杂了以后,函数指针就体现出了其优越性。
    举个例子,如果我们要实现数组的排序,我们知道,常用的数组排序方法有很多种,比如快排,插入排序,冒泡排序,选择排序等,如果不管内部实现,你会发现,除了函数名不一样之外,返回值,包括函数入参都是相同的,这时候如果要调用不同的排序方法,就可以使用指针函数来实现,我们只需要修改函数指针初始化的地方,而不需要去修改每个调用的地方(特别是当调用特别频繁的时候)。

    回调函数

    函数指针的一个非常典型的应用就是回调函数
    什么是回调函数?
    回调函数就是一个通过指针函数调用的函数。其将函数指针作为一个参数,传递给另一个函数。
    回调函数并不是由实现方直接调用,而是在特定的事件或条件发生时由另外一方来调用的。
    同样我们来看一个回调函数的例子:

    文件:callback.c

    #include<stdio.h>
    #include<stdlib.h>
    
    //函数功能:实现累加求和
    int func_sum(int n)
    {
            int sum = 0;
            if (n < 0)
            {
                    printf("n must be > 0\n");
                    exit(-1);
            }
            for (int i = 0; i < n; i++)
            {
                    sum += i;
            }
            return sum;
    }
    
    //这个函数是回调函数,其中第二个参数为一个函数指针,通过该函数指针来调用求和函数,并把结果返回给主调函数
    int callback(int n, int (*p)(int))
    {
            return p(n);
    }
    
    int main(void)
    {
            int n = 0;
            printf("please input number:");
            scanf("%d", &n);
            printf("the sum from 0 to %d is %d\n", n, callback(n, func_sum));       //此处直接调用回调函数,而不是直接调用func_sum函数
            return 0;
    }
    

    上面这个简单的demo就是一个比较典型的回调函数的例子。在这个程序中,回调函数callback无需关心func_sum是怎么实现的,只需要去调用即可。
    这样的好处就是,如果以后对求和函数有优化,比如新写了个func_sum2函数的实现,我们只需要在调用回调函数的地方将函数指针指向func_sum2即可,而无需去修改callback函数内部。
    以上代码的输出结果如下:
    在这里插入图片描述
    回调函数广泛用于开发场景中,比如信号函数、线程函数等,都使用到了回调函数的知识。

    展开全文
  • Swift之函数的语法分析和使用示例

    万次阅读 2022-05-09 14:20:27
    一、函数简介 Swift 函数用来完成特定任务的独立的代码块。 Swift 使用一个统一的语法来表示简单的 C 语言风格的函数到复杂的 Objective-C 语言风格的方法: 函数声明:告诉编译器函数的名字,返回类型及参数。 ...

    一、函数简介

    • Swift 函数用来完成特定任务的独立的代码块。
    • Swift 使用一个统一的语法来表示简单的 C 语言风格的函数到复杂的 Objective-C 语言风格的方法:
      • 函数声明:告诉编译器函数的名字,返回类型及参数。
      • 函数定义:提供了函数的实体。
    • Swift 函数包含了参数类型及返回值类型。

    二、函数定义

    • Swift 定义函数使用关键字 func,定义函数的时候,可以指定一个或多个输入参数和一个返回值类型。
    • 每个函数都有一个函数名来描述它的功能,通过函数名以及对应类型的参数值来调用这个函数,函数的参数传递的顺序必须与参数列表相同。
    • 函数的实参传递的顺序必须与形参列表相同,-> 后定义函数的返回值类型。

    ① 一般用法

    • 不带参数:
    func pi() -> Double {
    	return 3.1415
    }
    
    pi()
    
    • 带参数:
    // 求和
    //
    // 将两个整数相加
    // - Parameters:
    //   - v1: v1 第一个整数
    //   - v2: v2 第二个整数
    // - Returns: 2个整数的和
    //
    // - Note : 传入2个整数即可
    func sum(v1: Int,v2: Int) -> Int {
        v1 + v2
    }
    
    sum(v1: 10, v2: 20)
    
    • 说明:
      • 所有的函数前面都用 func 来修饰;
      • 函数名()的()里写的是参数,这里是虚参,也就是参数名称;
      • 函数的参数默认是常量,而且只能是常量;
      • 返回值是写在参数的后面,并且使用 -> 隔开,sum 函数返回的是 Int 类型;
      • 在调用时也需要加上参数名称,这样传值会更准确;
      • 在 sum 函数中我写了文档注释,这样便于后续维护,而且在调用函数时可以更加明确函数的职责;
      • 因为是单一的表达式,所以无需写 return,编译期会自动判断。
    • 注意:
      • 若没有返回值有三种写法:返回 Void,Void 其实就是(),Void 是 () 空元祖的别名(注意 Void 的 V 是大写,跟其他语言不一样),返回(),也就是直接返回空元组;
      • 也可以不写返回值就表示没有返回值;
      • 如果整个函数体只是简单的单一表达式,可以不写 return 来返回,编译器会自动增加 return;
      • 形参默认是 let,也只能是 let,所以以后就不要写就行。

    ② 返回元组

    • 如下所示:
    func calculate(v1: Int,v2: Int) -> (sum: Int,diffence: Int,average: Int) {
    	let sum = v1+v2
    	return(sum,v1-v2,sum>>1)
    }
    
    let result = calculate(v1: 20, v2: 10)
    result.sum
    result.diffence
    result.average
    result.0
    result.1
    result.2
    
    • 运行结果:

    在这里插入图片描述

    • 说明:
      • 以元组的形式返回就可以一次性得到多个返回值;
      • 函数接收的时候就直接用一个 let 或 var 就行,因为是不确定数据类型的,所以可以接收任意类型;
      • 接收后使用上就和正常的元组一样,可以通过标识符取用,也可以使用下标取用。

    三、函数参数

    ① 参数标签

    • Swift 有参数标签这个东西,常见的参数名称是为了在函数内部有更好的语义化,而参数标签是为了再外界调用时有更好的语义化:
    // 函数标签的案例
    func goToWork(at time: String) {
    // 内部语义化:this time is time
    	print("this time is \(time)")
    }
    
    goToWork(at: "08:00")
    // 外部语义化:go to work at 08:00
    
    // 省略参数标签
    func sum(_ v1: Int, _ v2: Int) -> Int {
        v1 + v2
    }
    sum(10, 20)
    
    • 说明:
      • 在函数定义中使用的是 time 时间,这样更易读,this time is 08:00;
      • 在函数调用时用 go to work at 08:00 这样来写更易读;
      • 在定义函数时需要加上 at 这个参数标签;
      • 函数的一个参数既有在函数内部使用的函数名称,也有在函数外使用的函数标签;
      • 函数标签可以省略,使用_就可以省略,此时外部调用时就无需使用参数标签。
    • 注意:
      • 加_省略和不写参数标签是不一样的;
      • 这种情况在调用时就可以直接传值,如果是定义时不写参数标签,在外部调用时仍然要写参数名称,而不能直接写参数。

    ② 默认参数

    • 可以在定义函数时添加默认参数时,这样在调用函数时可以不传入这个参数的值:
    func check(name: String = "nobody", age: Int,job: String = "none") -> () {
        print("name=\(name),age=\(age),job=\(job)")
    }
    check(age: 18)
    check(name: "wy", age: 18, job: "iOS")
    check(age: 18,job: "iOS")
    
    • 执行结果:
    ame=nobody,age=18,job=none
    name=wy,age=18,job=iOS
    name=nobody,age=18,job=iOS
    
    • 说明:
      • 在函数中 name 和 job 参数有自己的默认参数值;
      • 在调用时函数时可以不给 name 和 job 传值,函数内部会使用默认参数值来计算;
      • 但是 age 必须要传值,因为没有默认参数值;
      • 在传值时会使用到参数标签所以不会有歧义,可以任意决定传值的参数,这与 C 语言不同。

    ③ 可变参数

    • 在 Swift 中使用可变参数会很方便,当然了和其他语言一样其实在内部也是编译成一个数组:
    func sum(_ numbers: Int...) -> Int {
    	var total = 0
    	for number in numbers {
            total += number
        }
    	return total
    }
    sum(10,20,30,40)
    sum(10, 20)
    
    • 说明:
      • 传入的参数中在数据类型的后面加上…,这样就是可变参数;
      • 在函数内部把这个参数看做数组来处理;
      • 一个函数最多只能有 1 个可变参数;
      • 紧跟在可变参数后面的参数不能省略参数标签/参数名称,否则无法区分这个值是哪个参数的。

    四、函数内修改外部变量的值(inout 的使用)

    • 函数的参数只能是常量,所以正常情况下无法修改这个参数,如果想要修改参数,就需要使用 inout 来修饰这个参数,这样做并且不仅可以修改参数内部,还可以修改外部的变量。本质是将值传递改为了指针传递。
    // inout的使用
    func swapValues(_ v1: inout Int, _ v2: inout Int) -> Void {
    	let tmp = v1
        v1 = v2
        v2 = tmp
    }
    
    var num1 = 10
    var num2 = 20
    swapValues(&num1, &num2) // 传入地址(其实就是指针,虽然Swift中没有指针变量的概念)
    
    • 说明:
      • 不同于其他语言,Swift 的虚参只能是常量,不能是变量,所以无法修改;
      • 如果是值传递,也无法修改外部变量的值;
      • 可以使用 inout 来修饰,就可以修改外部变量的值;
      • 调用函数时传入的值要传入变量地址,而不是变量本身;
      • 可变参数不可以加 inout;
      • inout 参数不可以有默认值。

    五、函数类型

    • 函数也有自己的数据类型,数据类型就是参数数据类型+返回值数据类型,这里的函数类型可以视作 OC 中 block,在使用上和 block 基本一样,block 简单说来其实就是可作为变量/参数/返回值的能够捕获变量的匿名函数;
    • 如下所示,演示作为变量、参数、返回值的具体使用,可以看到和 block 的使用完全一致:

    ① 函数类型

    • 函数的函数类型就是参数数据类型+返回值数据类型;
    • test() 函数的函数类型就是() -> ();
    • test2() 函数的数据类型为:(Int,String) -> (Int,Double)。
    // 数据类型为:()->() 或者()->Void
    func test(){
    	print("lalala")
    }
    // 数据类型为:(Int,String) -> (Int,Double)
    func test2(a: Int,b: String) -> (Int,Double) {
    	return(7,7.0)
    }
    

    ② 作为变量

    • 定义一个函数类型的变量,就可以将这个函数赋值给这个变量,之后通过这个变量来调用函数;
    • 通过函数变量调用时不需要参数标签和参数名称,直接传值;
    • 为更方便的说明,可以把定义变量和赋值参数分开写了,其实也可以写到一起。
    //(Int,Int) -> Int
    func sum2(a:Int,b:Int) -> Int {
        a+b
    }
    
    // 1、通过函数的数据类型定义一个函数变量
    var fn: (Int,Int) -> Int;
    // 2、赋值一个函数
    fn = sum2(a:b:)
    // 3、调用
    fn(2,3)
    

    ③ 作为参数传递

    // 加法
    func sum3(v1: Int, v2: Int) -> Int {
        v1+v2
    }
    
    // 减法
    func difference(v1: Int,v2: Int) -> Int {
        v1-v2
    }
    
    // 通过传入的函数和对变量进行对应的加减操作
    // (Int, Int) -> Int 是mathFn参数的数据类型
    func printResult(_ mathFn: (Int, Int) -> Int , _ a: Int, _ b:Int) {
    print("Result: \(mathFn(a,b))")
    }
    
    printResult(sum, 20, 10)
    printResult(difference, 20, 10)
    
    • 在 printResult 函数中第一个参数就是一个函数,这里传递到时候参数的数据类型就是函数类型;
    • (Int, Int) -> Int 是 mathFn 参数的数据类型;
    • 在 PrintResult 函数中就可以使用传入的函数进行调用了,通过传入的函数和对变量进行对应的加减操作。

    ④ 作为返回值

    // +1
    func next(_ input: Int) -> Int {
        input + 1
    }
    
    // -1
    func previous(_ input: Int) -> Int {
        input - 1
    }
    
    // 通过传入的Bool值判断返回哪个函数
    // (Int) -> Int是返回值类型,是个函数类型,因此返回函数
    // 因为返回的是函数所以只写名称,不需要带参数
    func forward(_ forward: Bool) -> (Int) -> Int {
        forward ? next : previous
    }
    forward(true)(3)  // 4
    forward(false)(4) // 2
    
    • forward 函数的返回值类型是 (Int) -> Int,这是一个函数类型;
    • 返回的是函数所以只写名称,不需要带参数,如果带参数就是具体的值;
    • forward(true) 得到的是函数 next,因此 next(3) 就是 4。

    六、函数的嵌套

    • 函数嵌套指的是函数内定义一个新的函数,外部的函数可以调用函数内定义的函数。实例如下:
    import Cocoa
    
    func calcDecrement(forDecrement total: Int) -> () -> Int {
       var overallDecrement = 0
       func decrementer() -> Int {
          overallDecrement -= total
          return overallDecrement
       }
       return decrementer
    }
    let decrem = calcDecrement(forDecrement: 30)
    print(decrem())
    
    • 执行输出结果为:
    -30
    
    展开全文
  • 函数函数式编程 函数的定义 函数与过程 返回值与返回值类型 前向引用 内部/内嵌函数 函数装饰器 传递函数 参数的种类 位置参数 参数默认值 命名关键字参数 关键字参数:**others,便于函数功能的扩展 ...

    目录

    函数与函数式编程

    函数的定义

    函数与过程

    返回值与返回值类型

    前向引用

    内部/内嵌函数

    函数装饰器

    传递函数

    参数的种类

    位置参数

    参数默认值

    命名关键字参数

    关键字参数:**others,便于函数功能的扩展

    任意的参数列表 *others

    解包参数列表  

    解包参数列表  


    函数与函数式编程

    函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。

    函数能提高应用的模块性,和代码的重复利用率。Python提供了许多内建函数,比如print()。我们也可以自己创建函数,这被叫做用户自定义函数。

    函数的定义

    我们可以定义一个由自己想要功能的函数,以下是简单的规则:

    函数代码块以def关键词开头,后接函数标识符名称和圆括号()。

    任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。

    函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

    函数内容以冒号起始,并且缩进。

    return[表达式]结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回None。

    以创建一个输出任意范围内 Fibonacci 数列的函数为例:

    def fib(n):
        a,b=0,1
        while a<n:
            print(a,end=" ")
            a,b=b,a+b
        print()
    fib(2000)

    关键字def引入一个函数定义。它必须后跟函数名称和带括号的形式参数列表。构成函数体的语句从下一行开始,并且必须缩进。

    函数体的第一个语句可以(可选的)是字符串文字;这个字符串文字是函数的文档字符串或docstring。

    函数的执行会引入一个用于函数局部变量的新符号表。更确切地说,函数中所有的变量赋值都将存储在局部符号表中;而变量引用会首先在局部符号表中查找,然后是外层函数的局部符号表,再然后是全局符号表,最后是内置名称的符号表(变量作用域问题,之后会详细介绍)。因此,全局变量和外层函数的变量不能在函数内部直接赋值(除非是在global语句中定义的全局变量,或者是在nonlocal语句中定义的外层函数的变量),尽管它们可以被引用。

    在函数被调用时,实际参数(实参)会被引入被调用函数的本地符号表中;因此,实参是通过按值调用传递的(其中值始终是对象引用而不是对象的值)。当一个函数调用另外一个函数时,将会为该调用创建一个新的本地符号表。

    函数定义会把函数名引入当前的符号表中。函数名称的值具有解释器将其识别为用户定义函数的类型。这个值可以分配给另一个名称,该名称也可以作为一个函数使用。这用作一般的重命名机制:

    print(fib)
    f=fib
    f(
    100)

    上面这个函数是无返回值的函数,即没有return语句,默认返回None。一般来说解释器不会打印出单独的返回值None,如果真想看到它,可以使用print()

    print(fib(0))

    print(fib(1))

    写一个返回斐波那契数列的列表(而不是把它打印出来)的函数,非常简单:

    def fib2(n):
        result=[]
        a,b=0,1;
        while a<n:
            result.append(a)
            a,b=b,a+b
        return result
    f100=fib2(100)
    print(f100)

    函数与过程

    函数与过程都是可以被调用的实体,一般来说,函数有一定的返回值,过程是简单、特殊、没有返回值的函数。

    返回值与返回值类型

    当没有返回值时,Python的实际返回对象是None。

    当返回对象的数目为1时,Python的返回值类型是该对象的类型。

    当返回对象的数目大于1时,Python的返回值类型是元组。

    def fun1():
        pass
    print(fun1())
    def fun2():
        return '123'
    print(fun2())
    def fun_list():
        return ['123','xyz',456]
    print(fun_list())
    def fun_tuple1():
        return 1,2,3
    print(fun_tuple1())
    def fun_tuple2():
        return (1,2,3)
    print(fun_tuple2())

    运行结果:

    None

    123

    ['123', 'xyz', 456]

    (1, 2, 3)

    (1, 2, 3)

    fun1()返回None,fun2()的返回值类型是字符串,fun_list()、fun_tuple1()、fun_tuple2()的返回值大于1个,fun_list()返回的是一个列表,fun_tuple1()、fun_tuple2()等价,都是一个元组。

    所以在我们看来。返回一个容器对象时,好像是返回了多个对象(元组在语法上不需要带括号),事实上,他们仍返回的是一个,一个容器罢了。

    保存元组返回值的三种方法:

    def fun_tuple():
        return 'abc',5,['k','p']
    aTuple=fun_tuple()
    x,y,z=fun_tuple()
    (a,b,c)=fun_tuple()
    print(aTuple)
    print(x,y,z)
    print((a,b,c))

    运行结果:

    ('abc', 5, ['k', 'p'])

    abc 5 ['k', 'p']

    ('abc', 5, ['k', 'p'])

    在对x、y、z和a、b、c的赋值中,根据返回值的顺序,每个变量会接收到与之对应的返回值。而aTuple直接获得函数隐式返回的整个元组。

    前向引用

    def foo():
        print(
    '1')
        bar()

    def bar():
        print(
    '2')
    foo()

    运行结果:

    1

    2

    可见上例中foo()先调用的bar(),然后bar()才声明,系统不会报错。但是不推荐这么写,从感觉上来说,有悖常识,自己尽量让需要用的放在前面吧。

    内部/内嵌函数

    在函数体内部创建另外一个函数是完全合法的,这种函数叫内嵌函数。

    如:

    def foo():
        print('1')
        def bar():
            print('2')
        bar()
    foo()

    运行结果:

    1

    2

    内部函数的整个函数体都在外部函数的作用域里。如果没有任何对bar()的外部引用,那么除了在外部函数体foo()内,任何其他地方都不能对其进行调用。

    另外一个函数体内创建函数对象的方式是使用lambda语句。这个之后的学习会涉及。

    函数装饰器

    暂时看不懂,先不写。

    传递函数

    传递函数的方式大致有三种:

    1. 被引用(访问或者以其他变量作为其别名)
    2. 作为参数传入函数
    3. 作为字典、列表等容器对象的元素

    下面详细介绍一下用其他的变量作为函数的别名。

    def foo():
        print('1')
    bar=foo
    bar()

    运行结果:

    1

    当我们把foo赋给bar时,bar和foo引用了同一个函数对象,所以能以调用foo()相同的方式调用bar()。

    故:foo是函数对象的引用;foo()是函数对象的调用。

    再如:

    def foo():
        print('1')
    def bar(argfunc):
        argfunc()
    bar(foo)

    运行结果:

    1

    参数的种类

    位置参数

    位置参数必须以在被调用函数中的定义的准确顺序来传递。若没有任何默认参数的话,传入函数的参数的精确的数目必须和声明中的数字一致。

    当然,我们也可以不按位置地将关键字参数传入函数,给出关键字来匹配其在参数列表中的合适位置,但是位置参数的数字一定要对。

    def info(name,sex,grades,school='abc'):
        print(name)
        print(sex)
        print(grades)
        print(school)
    info('Jennifer','female','3')
    print()
    info(sex='female',name='Jennifer',school='lalala',grades='1')
    print()
    info(grades='1',sex='male',name='frank')

    运行结果:

    Jennifer

    female

    3

    abc

     

    Jennifer

    female

    1

    lalala

     

    frank

    male

    1

    abc

    参数默认值

    最有用的形式是对一个或多个参数指定一个默认值。这样创建的函数,可以用比定义时允许的更少的参数调用,设置默认参数,必选参数在前,默认参数在后。比如:

    def ask_ok(prompt,retries=4,reminder='Please try again!'):
        while True:
            ok=input(prompt)
            if ok in ('y','ye','yes'):
                return True
            if ok in ('n','no','nop','nope'):
                return False
            retries=retries-1
            if retries<0:
                raise ValueError('invalid user response')
            print(reminder)

    这个函数可以通过几种方式调用:

        只给出必需的参数:ask_ok('Do you really want to quit?')

        给出一个可选的参数:ask_ok('OK to overwrite the file?', 2)

    或者给出所有的参数:ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')

    这个示例还介绍了 in 关键字。它可以测试一个序列是否包含某个值。

    默认值是在定义过程中在函数定义处计算的,所以下例会打印5。

    i=5
    def f(arg=i):
        print(arg)
    i=6
    f()

    重要警告: 默认值只会执行一次这条规则在默认值为可变对象(列表、字典以及大多数类实例)时很重要。比如,下面的函数会存储在后续调用中传递给它的参数:

    def f(a,L=[]):
        L.append(a)
        return L
    print(f(1))
    print(f(2))
    print(f(3))

    打印结果如下:

    如果你不想要在后续调用之间共享默认值,你可以这样写这个函数:

    def f(a,L=None):
        if L is None:
            L=[]
        L.append(a)
        return L
    print(f(1))
    print(f(2))
    print(f(3))

    命名关键字参数

    函数调用时,指定参数名称,称为关键字参数(别和默认参数混淆,这里是函数调用)

    def temp(a,b,c):
    
        print(a)
    
        print(b)
    
        print(c)
    
    temp(1,3,c=99)
    
    temp(a=1,b=2,c=3)
    
    temp(1,b=2,c=100)

    顺序要求:函数调用时,关键字参数必须在普通参数(位置参数)的后面

    temp(100,b=200,c=300)

    temp(a=100,32,100) #错误语法,关键字参数不能在普通参数的前面

    使用字典解包方式传入关键字参数(后面小节中会详细讲到)

    hi = {"a":100,"b":99,"c":1000}

    temp(**hi) #等同于下面#

    temp(a=100,b=99,c=1000)

    函数调用时,当剩余的参数全部为关键字参数时,可随意定义顺序

    当全部为关键字参数时,调用函数时的参数顺序可随意书写,因为你指定了参数名,但是参数的数量不能少于函数定义时要求的位置参数的数量

    temp(c=100,b=38,a=10)

    也可以使用形如kwarg=value的关键字参数来调用函数。例如下面的函数:

    def parrot(voltage,state='a stiff',action='voom',type='Norwegian Blue'):
        print("--This parrot wouldn't",action,end=' ')
        print("if you put",voltage,"volts though it.")
        print("-- Lovely plumage, the", type)
        print("-- It's", state, "!")

    接受一个必需的参数(voltage)和三个可选的参数(state, action,和 type)。这个函数可以通过下面的任何一种方式调用:

    • 一个位置参数:parrot(1000)
    • 一个关键字参数:parrot(voltage=1000)
    • 两个关键字参数;parrot(voltage=1000000, action='VOOOOOM')
    • 两个关键字参数;parrot(action='VOOOOOM', voltage=1000000)
    • 三个位置参数:parrot('a million', 'bereft of life', 'jump')
    • 一个位置参数,一个关键字参数:parrot('a thousand', state='pushing up the daisies')

    但下面的函数调用都是无效的:

    • 丢失必要参数:parrot()
    • 在关键字参数之后的非关键字参数 :parrot(voltage=5.0, 'dead')
    • 同一参数的重复值 :parrot(110, voltage=220)
    • 未知的关键字参数:parrot(actor='John Cleese')

    在函数调用中,关键字参数必须跟随在位置参数的后面。传递的所有关键字参数必须与函数接受的其中一个参数匹配(比如 actor 不是函数 parrot 的有效参数),它们的顺序并不重要。这也包括非可选参数,(比如 parrot(voltage=1000) 也是有效的)。不能对同一个参数多次赋值。下面是一个因为此限制而失败的例子:

    def function(a):
        pass
    function(0,a=0)

    关键字参数:**others,便于函数功能的扩展

    当存在一个形式为**name最后一个形参时,它会接收一个字典其中包含除了与已有形参相对应的关键字参数以外的所有关键字参数。这可以与一个形式为*name接收一个包含除了已有形参列表以外的位置参数的元组的形参组合使用(*name必须出现在**name之前,下一小节会讲到)。例如,如果我们这样定义一个函数:

    def cheeseshop(kind, *arguments, **keywords):
        print("-- Do you have any", kind, "?")
        print("-- I'm sorry, we're all out of", kind)
        for arg in arguments:
            print(arg)
        print("-" * 40)
        for kw in keywords:
            print(kw, ":", keywords[kw])

    它可以像这样调用:

    cheeseshop("Limburger", "It's very runny, sir.",
               "It's really very, VERY runny, sir.",
               shopkeeper="Michael Palin",
               client="John Cleese",
               sketch="Cheese Shop Sketch")

    注意打印时关键字参数的顺序保证与调用函数时提供它们的顺序是相匹配的。

    任意的参数列表 *others

    最后,最不常用的选项是可以使用任意数量的参数调用函数。这些参数会被包含在一个元组里。在可变数量的参数之前,可能会出现零个或多个普通参数。:

    def write_multiple_items(file, separator, *args):
        file.write(separator.join(args))

    一般来说,这些可变参数将在形式参数列表的末尾,因为它们收集传递给函数的所有剩余输入参数。出现在*args参数之后的任何形式参数都是‘仅关键字参数’,也就是说它们只能作为关键字参数而不能是位置参数。

    def concat(*args, sep="/"):
       
    return sep.join(args)
    print(concat("earth", "mars", "venus"))
    print(concat("earth", "mars", "venus", sep="."))

    解包参数列表  

    当参数已经在列表或元组中但需要为需要单独位置参数的函数调用解包时,会发生相反的情况。例如,内置的 range() 函数需要单独的 start 和 stop 参数。如果它们不能单独使用,请使用 * 运算符编写函数调用以从列表或元组中解包参数,*args输出结果是3 6:

    list(range(3,6))
    print(list(range(3,6)))
    args=[3,6]
    print(list(range(*args)))

    以同样的方式,字典可以使用 ** 运算符来提供关键字参数:

    def parrot(voltage, state='a stiff', action='voom'):
        print("-- This parrot wouldn't", action, end=' ')
        print("if you put", voltage, "volts through it.", end=' ')
        print("E's", state, "!")
    d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
    parrot(**d)

    更多Python框架梳理,请参考: 【Python学习】Python最全总结

     有问题请下方评论,转载请注明出处,并附有原文链接,谢谢!如有侵权,请及时联系。

    展开全文
  • 常用激活函数(激励函数)理解与总结

    万次阅读 多人点赞 2018-05-13 23:07:19
    学习神经网络的时候我们总是听到激活函数这个词,而且很多资料都会提到常用的激活函数,比如Sigmoid函数、tanh函数、Relu函数。那么我们就来详细了解下激活函数方方面面的知识。本文的内容包括几个部分: 什么是...
  • Mysql 窗口函数

    万次阅读 多人点赞 2022-03-04 23:36:32
    一, MySQl 8.0 窗口函数 窗口函数适用场景: 对分组统计结果中的每一条记录进行计算的场景下, 使用窗口函数更好; 可以跟Hive的对比着看: 点我, 特么的花了一晚上整理, 没想到跟Hive 的基本一致, 还不因为好久没复习...
  • C语言回调函数详解(全网最全)

    千次阅读 多人点赞 2021-10-31 00:10:41
    概念2,如何用函数指针调用函数3.**函数指针作为某个函数的参数**4.函数指针作为函数返回类型5.函数指针数组6.函数指针总结二、回调函数1.什么是回调函数2 为什么要用回调函数?3 怎么使用回调函数?4.下面是一个四则...
  • C语言中函数的基本知识

    万次阅读 多人点赞 2018-12-02 18:09:04
    1:函数是C语言的模块,一块块的,有较强的独立性,可以相互调用,也就是说,你可以在函数A中调用函数B,又可在函数B中调用函数C,不仅如此,你还可以调用函数自身(递归)。 2:函数是完成一个个特定任务的语句集合...
  • count意思是计数、计算、数数等,count函数和counta函数都是计算非空单元格个数。区别在于:count函数在计算非空单元格的个数时,将把数字型的数字计算进去,错误值、文字、逻辑值、空值将被忽略;如果要统计含有...
  • C++虚函数详解

    千次阅读 多人点赞 2021-05-26 10:25:43
    1.虚函数的使用? 1.1虚函数的定义 在实现c++多态时会用到虚函数。虚函数使用的其核心目的是通过基类访问派生类定义的函数。所谓虚函数就是在基类定义一个未实现的函数名,为了提高程序的可读性,建议后代中虚函数...
  • C++ 虚函数详解

    千次阅读 多人点赞 2021-12-27 20:43:38
    这里写目录标题概述类的虚表一般继承(无虚函数覆盖)一般继承(有虚函数覆盖)多重继承(无虚函数覆盖)多重继承(有虚函数覆盖)虚表指针动态绑定 概述 C++中的虚函数的作用主要是实现了多态的机制。关于多态,...
  • MATLAB 匿名函数详解(超级全面)

    千次阅读 多人点赞 2021-03-04 19:14:00
    目录1 匿名函数的生成1.1基础生成1.2 多参数匿名函数1.3 含定参匿名函数1.4 sym转匿名函数1.5 字符串转匿名函数1.6 函数工厂(匿名函数的自动生成)1.6.1 已知参数个数1.6.2 未知参数个数1.7 拟合结果转匿名函数1.8 ...
  • 普通函数和箭头函数的区别

    万次阅读 多人点赞 2019-03-24 14:06:13
    普通函数和箭头函数的区别: 箭头函数的this指向规则: 1. 箭头函数没有prototype(原型),所以箭头函数本身没有this 2. 箭头函数的this指向在定义的时候继承自外层第一个普通函数的this。 3. 不能直接修改箭头函数的...
  • python 3.4 chm api 函数手册

    千次下载 热门讨论 2015-01-19 16:43:10
    python 3.4 chm api 函数手册
  • 高中函数对称性总结

    万次阅读 2020-12-24 11:10:10
    一、对称性的概念及常见函数的对称性1、对称性的概念函数轴对称:如果一个函数的图像沿一条直线对折,直线两侧的图像能够完全重合,则称该函数具备对称性中的轴对称,该直线称为该函数的对称轴。中心对称:如果一个...
  • c语言回调函数的使用及实际作用详解

    万次阅读 多人点赞 2021-07-16 23:49:20
    回调函数这个知识点其实并不是很难,难是难在网上很多讲解回调函数的都说的太学术化了化了,一点也不亲民。 很多人即使知道怎么写回调函数也根本就搞不懂它们在实际产品中也有什么用,什么时候用。 所以这节课呢...
  • C语言中函数指针和回调函数的详解

    万次阅读 多人点赞 2019-05-18 23:10:01
    函数指针:指向函数的指针变量。 因此“函数指针”本身首先应是指针变量,只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样,这里是指向函数。如前所述,C在编译时,每一个函数都有一个...
  • 函数详解

    万次阅读 多人点赞 2019-03-09 20:05:26
    文章目录一、虚函数实例二、虚函数的实现(内存布局)1、无继承情况2、单继承情况(无虚函数覆盖)3、单继承情况(有虚函数覆盖)4、多重继承情况(无虚函数覆盖)5、多重继承情况(有虚函数覆盖)三、虚函数的相关...
  • 使用回调函数实际上就是在调用某个函数(通常是API函数)时,将自己的一个函数(这个函数为回调函数)的地址作为参数传递给那个函数。而那个函数在需要的时候,利用传递的地址调用回调函数,这时你可以利用这个机会...
  • 【图文详细 】Hive 函数、Hive 函数、Hive 函数

    千次阅读 多人点赞 2018-12-02 14:34:15
    1.hive内置函数 1.1、内容较多,见《Hive 官方文档》  https://cwiki.apache.org/confluence/display/Hive/LanguageManual+UDF   1.2、测试内置函数的快捷方式:   第一种方式:直接使用,例如:select ...
  • 伽马函数(Γ(x)伽马函数公式)

    万次阅读 2021-04-26 13:21:04
    相信很多人对于伽马函数(Γ(x)伽马函数公式)并不是非常的了解,因此小编在这里为您详解的讲解一下相关信息!Γ(x)称为伽马函数,它是用一个积分式定义的,不是初等函数。伽马函数有性质:Γ(x+1)=xΓ(x),Γ(0)=1,...
  • C++拷贝构造函数、构造函数和析构函数

    万次阅读 多人点赞 2018-08-30 22:09:15
    一、拷贝构造函数 转载自:http://www.cnblogs.com/BlueTzar/articles/1223313.html 1、类对象的拷贝  对于普通类型的对象来说,它们之间的复制是很简单的,例如: int a=88; int b=a;   而类对象与普通...
  • Oracle日期函数

    万次阅读 2022-01-17 15:38:54
    Oracle日期类型函数是操作日期、时间类型的相关数据,返回日期时间类型或数字类型结果,常用的函数有:SYSDATE()、ADD_MONTHS()、LAST_DAY()、TRUNC()、ROUND()等等。 系统日期、时间函数: SYSDATE函数:该...
  • 什么是C语言函数

    万次阅读 2021-05-21 08:53:50
    什么是C语言函数int max(a,b)int a,b;{if (a>b) return a;else return b;}第一行说明max函数是一个整型函数,其返回的函数值是一个整数。形参为a,b。第二行说明a,b均为整型量。 a,b 的具体值是由主调函数在调用时...
  • 要成为虚函数必须满足两点,一就是这个函数依赖于对象调用,因为虚函数就是依赖于对象调用,因为虚函数是存在于虚函数表中,有一个虚函数指针指向这个虚表,所以要调用虚函数,必须通过虚函数指针,而虚函数指针是...
  • C++——友元函数&内联函数

    千次阅读 多人点赞 2018-12-07 23:55:15
    友元函数 类的友元函数是定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是一个函数,该函数被...
  • c++ 构造函数详解

    万次阅读 多人点赞 2019-05-31 17:20:58
    c++构造函数详解。(构造函数的分类、拷贝构造函数
  • function函数 function函数的具体用法

    万次阅读 2021-04-26 19:51:28
    我们在用Excel的过程当中经常会看到各种各样的函数,其中就包括funection函数,然而对于funectioe函数步了解的朋友一定不知道这一个函数是如何使用的,所以今天小编就来讲解这一个函数的具体使用方式是怎么样的。...
  • 【Matlab基础】 自定义函数

    千次阅读 2021-04-19 07:09:04
    函数——是编程的核心概念之一,是能够完成相对独立功能的代码封装成的模块。在主程序中通过函数名和实参调用它,通过接口(即函数的输入、输出参数)来实现“通讯”。所以在调用函数时,你只要知道“被调用的函数是...
  • excel乘积函数_excel相乘函数使用方法

    万次阅读 2021-07-26 05:11:31
    Excel中经常需要使用到相乘函数进行数据的计算,相乘函数具体该如何使用呢?接下来是学习啦小编为大家带来的excel 相乘函数使用方法,供大家参考。excel 相乘函数使用方法:函数相乘步骤1:鼠标点选到C1的单元格中,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,682,187
精华内容 4,672,875
关键字:

函数

友情链接: asynchronous_fifo.rar