精华内容
下载资源
问答
  • c语言中将函数指针作为形参 在C中将指针作为函数参数 (Pointers as Function Argument in C) Pointer as a function parameter is used to hold addresses of arguments passed during function call. This is also...

    c语言中将函数指针作为形参

    Pointer as a function parameter is used to hold addresses of arguments passed during function call. This is also known as call by reference. When a function is called by reference any change made to the reference variable will effect the original variable.

    指针作为函数参数,用于保存函数调用期间传递的参数的地址。 这也称为按引用调用 。 通过引用调用函数时,对引用变量所做的任何更改都会影响原始变量。

    时间示例:使用指针交换两个数字 (Example Time: Swapping two numbers using Pointer)

    #include <stdio.h>
    
    void swap(int *a, int *b);
    
    int main()
    {
        int m = 10, n = 20;
        printf("m = %d\n", m);
        printf("n = %d\n\n", n);
    
        swap(&m, &n);    //passing address of m and n to the swap function
        printf("After Swapping:\n\n");
        printf("m = %d\n", m);
        printf("n = %d", n);
        return 0;
    }
    
    /*
        pointer 'a' and 'b' holds and 
        points to the address of 'm' and 'n'
    */
    void swap(int *a, int *b) 
    {
        int temp;
        temp = *a;
        *a = *b;
        *b = temp;
    }

    m = 10 n = 20 After Swapping: m = 20 n = 10

    m = 10 n = 20交换后:m = 20 n = 10

    返回指针变量的函数 (Functions returning Pointer variables)

    A function can also return a pointer to the calling function. In this case you must be careful, because local variables of function doesn't live outside the function. They have scope only inside the function. Hence if you return a pointer connected to a local variable, that pointer will be pointing to nothing when the function ends.

    函数也可以return指向调用函数的指针。 在这种情况下,您必须要小心,因为函数的局部变量不在函数外部。 它们仅在函数内部具有作用域。 因此,如果您返回一个连接到局部变量的指针,则该函数结束时该指针将不指向任何内容。

    #include <stdio.h>
    
    int* larger(int*, int*);
    
    void main()
    {
        int a = 15;
        int b = 92;
        int *p;
        p = larger(&a, &b);
        printf("%d is larger",*p);
    }
    
    int* larger(int *x, int *y)
    {
        if(*x > *y)
            return x;
        else
            return y;
    }

    92 is larger

    92大

    返回有效指针的安全方法。 (Safe ways to return a valid Pointer.)

    1. Either use argument with functions. Because argument passed to the functions are declared inside the calling function, hence they will live outside the function as well.

      参数与函数一起使用。 由于传递给函数的参数是在调用函数内部声明的,因此它们也将驻留在函数外部。



    2. Or, use static local variables inside the function and return them. As static variables have a lifetime until the main() function exits, therefore they will be available througout the program.

      或者,在函数内部使用static 局部变量并返回它们。 由于静态变量的生存期一直到main()函数退出,因此它们将在整个程序中可用。

    功能指针 (Pointer to functions)

    It is possible to declare a pointer pointing to a function which can then be used as an argument in another function. A pointer to a function is declared as follows,

    可以声明一个指向某个函数的指针,然后将该指针用作另一个函数的参数。 指向函数的指针声明如下:

    type (*pointer-name)(parameter);

    Here is an example :

    这是一个例子:

    int (*sum)();   //legal declaration of pointer to function
    int *sum();     //This is not a declaration of pointer to function

    A function pointer can point to a specific function when it is assigned the name of that function.

    当为函数指针分配了特定函数的名称时,它可以指向该函数。

    int sum(int, int);
    int (*s)(int, int);
    s = sum;

    Here s is a pointer to a function sum. Now sum can be called using function pointer s along with providing the required argument values.

    s是指向函数sum的指针。 现在可以使用函数指针s以及提供所需的参数值来调用sum

    s (10, 20);

    功能指针的例子 (Example of Pointer to Function)

    #include <stdio.h>
    
    int sum(int x, int y)
    {
        return x+y;
    }
    
    int main( )
    {
        int (*fp)(int, int);
        fp = sum;
        int s = fp(10, 15);
        printf("Sum is %d", s);
    
        return 0;
    }

    25

    25

    复杂功能指针示例 (Complicated Function Pointer example)

    You will find a lot of complex function pointer examples around, lets see one such example and try to understand it.

    您会发现很多复杂的函数指针示例,让我们看一个这样的示例并尝试理解它。

    void *(*foo) (int*);

    It appears complex but it is very simple. In this case (*foo) is a pointer to the function, whose argument is of int* type and return type is void*.

    它看起来很复杂,但是非常简单。 在这种情况下(*foo)是指向函数的指针,该函数的参数为int*类型,返回类型为void*

    翻译自: https://www.studytonight.com/c/pointer-with-function-in-c.php

    c语言中将函数指针作为形参

    展开全文
  • 函数指针做形参带的形参不能使用例如: #include &lt;iostream&gt; using namespace std; int sum(int a, int b) { return a + b; } //形参只是声明了有一个int(*pf1)(int, int)类型的函数函数指针,这里...

    函数指针做形参带的形参不能使用例如:

    #include <iostream>
    using namespace std;
    int sum(int a, int b)
    {
    	return a + b;
    }
    //形参只是声明了有一个int(*pf1)(int, int)类型的函数函数指针,这里的abcd可以省略,
    //没有实际意义,两个int就说明了这是指向一个带有两个int参数和返回一个int值得函数指针。
    int sum_sum(int(*pf1)(int a, int b), int(*pf2)(int c, int d))
    {
    	return  (*pf1)(a, b) + (*pf2)(c, d);//报错a,b,c,d未声明
    }
    int main()
    {
    //在sum(1,2)和sum(3,4)报错"int" 类型的实参与 "int (*)(int a, int b)" 类型的形参不兼容
    //原因是sum(1,2)返回的是一个int类型的值,sum_sum函数的形参是int(*pf1)(int a, int b)指针。	
    	cout << "sum_sum=" << sum_sum(sum(1,2), sum(3,4)) << endl;
    	cin.get();
    
    	return 0;
    }
    
    

    那么我们该如何使用函数指针做形参带的参数呢?

    有一个笨办法,那就是在调用这个函数指针做形参的函数中再加几个形参,这样就可以了。

    展开全文
  • 函数指针形参

    千次阅读 2019-03-22 15:16:04
    一、在介绍指针形参之前,先简要说明下两个运算符 & 和 *。 1、取址运算符 & 用来取得其操作数的地址。取址运算符的操作数必须是在内存中可寻址到。换句话说,该运算符只能用作函数或对象(例如左值),而...

    一、在介绍指针形参之前,先简要说明下两个运算符 & 和 *。

     1、 取址运算符 & 用来取得其操作数的地址。取址运算符的操作数必须是在内存中可寻址到。换句话说,该运算符只能用作函数或对象(例如左值),而不可以用于位字段,以及那些未被存储类型修饰符register声明的内容。

    float x, *ptr;
    ptr = &x;           // 合法:使得指针ptr指向x
    ptr = &(x+1);       // 错误: (x+1) 不是一个左值

      2、当已具有一个指针,并且希望获取它所引用的对象时,使用间接运算符 *(indirection operator),有时候会被称为解引用运算符(dereferencing operator)。它的操作数必须是指针类型。

    float x, *ptr = &x;
    *ptr = 1.7;                                      // 将1.7赋值给变量x
    ++(*ptr);                                        // 并将变量x的值加1

      在这个示例最后,ptr的值保持不变,但x的值变成2.7。

    二、对函数来说,它所传递的任何参数仅仅是原来参数的一个拷贝

      如果通过指针传递参数,其实质仍然是值传递,传递的是地址而已。用指针传递参数,可以实现对实参进行改变的目的,是因为传递过来的是实参的地址,因此使用*a实际上是取存储实参的内存单元里的数据,即是对实参进行改变,因此可以达到目的。在使用的过程中需要通过对地址的解引用来操作其所指向的变量,同时可以通过指针的自增自减移动从而改变所指向的值,灵活度较大。  

      举例说明:

    程序1

    #include<stdio.h>  
    void fun(int *p)  
    {  
        int b=22;  
        p=&b;  
    }  
    int main(void)  
    {  
        int a=1;  
        int *q;  
        q=&a;  
        printf("%d\n",*q);  
        fun(q);  
        printf("%d\n",*q);  
        return 0;  
    } 

    输出为 
    这里写图片描述

     程序2

    #include<stdio.h>  
    void fun(int *p)  
    {  
        *p=22;  
    }  
    int main(void)  
    {  
        int a=1;  
        int *q;  
        q=&a;  
        printf("%d\n",*q);  
        fun(q);  
        printf("%d\n",*q);  
        return 0;  
    } 

    输出为 
    这里写图片描述

    程序1,明明改变了P的指向了,为什么还是输出1呢? 
    其实问题的关键不是指针作为形参的问题,而是函数传参的问题。q是a的地址,以实参形式传递给子函数fun(),而在fun()函数内部使用时,其实p仅仅是q的拷贝值。将p的值修改为&b,只是p的指向从a转向了b而已。而主函数中q及a都没有发生过改变。

    注:C语言里,改变值只能通过指针(地址)方式进行传递,或许你会说传递数组不是也可以改变值么,实际上,传递数组就是传递指针(或许对数组来说,这个指针有点特别)

     

    参考:https://blog.csdn.net/a3748622/article/details/79286974

               https://blog.csdn.net/jiaruitao777/article/details/81569757

               https://www.cnblogs.com/skullboyer/p/9050636.html

    展开全文
  • 在《C++中函数参数类型为指针的指针》中提到,在C++中,每次调用函数时都会重新创建它的形参,并用传入的实参对形参进行初始化...1 定义包含有函数指针的函数 bool (*fp)(const string&); void userFp(const...

    《C++中函数参数类型为指针的指针》中提到,在C++中,每次调用函数时都会重新创建它的形参,并用传入的实参对形参进行初始化。因此,不能用函数当做其他函数的形参,因为在函数内部无法创建函数的副本。而函数的指针可以作为其他函数的参数,指针是可以在函数内部进行复制的。

    1 定义包含有函数指针的函数

    bool (*fp)(const string&);
    
    void userFp(const string& s1, bool (*myFp)(const string&))
    
    {
    
       myFp(s1);
    
    }

    以上代码中,定义了函数指针fp,该指针指向一个返回值是bool类型,有一个const string&形参的函数;另外还定义了一个具有函数指针作为形参的函数userFp。

    除了使用解引用符号来定义函数指针的形参外,还可以使用如下方式定义:

    void userFp(const string& s1, bool myFp(const string&));

    以上两种定义方式等价。

    2 调用包含有函数指针的函数

    可以将函数指针或者函数名作为函数的实参。

    2.1 将函数指针作为函数实参

    bool showInfo(const string& s1)
    
    {
    
      cout << s1 << endl;
    
      return true;
    
    }
    
    fp = showInfo;
    
    userFp("Hello World", fp);

    在以上代码中,定义了showInfo函数,该函数的作用是输出其形参;之后将指针fp指向showInfo函数,最后将fp作为userFp()函数的实参。运行程序,会打印出“Hello World”的信息。

    2.2 将函数名作为函数的实参

    将函数名作为一个值使用时,该函数名自动转换为函数指针。

    userFp("Hello World", showInfo);

    以上代码将函数名作为userFp的实参,此时showInfo自动转换为指向该函数的指针。运行程序,会打印出“Hello World”的信息。

    展开全文
  • 函数指针做形参

    千次阅读 2017-11-21 20:47:31
    函数的参数可以是指针,函数指针------指向函数的指针,也是指针,所以函数指针也可以函数的参数。比如 int get_max(int i,int j,int k,int (*p)(int,int)); 这个函数接受4个参数,第4个参数即为一个指向函数的...
  • 一、函数形参指向指针指针。当链表头指针为空时,需要使用指向指针指针。 1、形参与实参间通过地址传递 (1)、当头指针为空时,向该链表中添加新的节点,此时需要使用到指针指针。InsertNode01 函数...
  • C语言----指针形参(指向指针的指针形参)

    千次阅读 多人点赞 2018-02-08 15:51:10
    一、通过指针形参在子函数改变常量大家都知道,C语言子函数的形参,是可以为普通数据类型,也可以为指针的。最初遇到这问题,是在学习STM32的库函数的使用。当初刚接触库函数,对于函数初始化接口,如:GPIO_Init...
  • 函数指针变量作为函数形参

    千次阅读 2020-09-07 12:17:53
    所以,函数指针变量是一种变量类型,也可以作为函数的形参变量。程序测试例子如下: 程序运行结果如下: 可以看到,函数func1的定义如下: voidfunc1(void(*pfunc)(int)) 其中形参的定义是 void(*pfunc...
  • 一、用二级指针作为函数参数,有两种典型情况: 1.需要传递一级指针的数组时: 例如标准C的main函数: intmain(intargc,char*[]argv),数组最高维可以退化,char*[]argv等价于char**argv。这里argv代表命令行参数...
  • 指针作为函数形参

    万次阅读 多人点赞 2018-08-10 20:49:39
    q作为形参进入fun函数时,不是q本身进入参数,而是克隆了一个指针变量,这个指针变量的值和q相等。 所以,在程序1中,只是克隆的指针变量的指向发生了改变,而q的指向并没有发生改变。 为了验证这一结论,看...
  • 指针数组做函数形参

    千次阅读 2018-10-23 13:43:00
    在设计函数过程中,想要函数参数传入一个指针数组,多为字符串数组,在函数形参的设计上有两种思路,具体以下列两种应用场景为说明 一、字符串处理函数strsort 从程序设计角度来看,将多个字符串传递给函数处理时...
  • 函数指针作为形参,即可实现函数名作为参数,由另一个函数调用。   一、 定义某一函数的指针类型: 就像自定义数据类型一样,我们也可以先定义一个函数指针类型,然后再用这个类型来申明函数指针变量。 我...
  • 在C++中,函数的形参可以是指向函数指针,函数也可以返回函数的指针。例如:int (*ff(int)) (int *,int);表示:ff(int)是一个函数,带有一个int型的形参,该函数返回int (*) (int *,int),它是一个指向函数指针...
  • 函数形参为结构体指针,但是在函数中不仅修改指针指向的值,而且修改指针指向的地址 以下可以改变主函数中a的值,但是a指向的地址不会发生改变 struct student { int aa; int bb; student() {} student(int ...
  • 函数指针指向的是函数而非对象,和其他指针一样,函数指针指向的是某种特定类型。函数的类型由它的返回类型和形参类型共同决定,与函数名无关。例如: //比较两个string对象的长度 bool lengthCompare(const ...
  • 和其它指针一样,函数指针指向某种特定类型。函数的类型由它的返回类型和形参类型共同决定。与函数名无关 void show(int a); //想要声明一个可以指向该函数的指针,只需用指针替换函数名即可 void(*print)(int a)...
  • 因为函数的类型由它的返回类型和形参类型共同决定,与函数名无关,所以想要声明一个函数指针,只需要用指针替换函数名即可,例如:比较字符串长度的函数:bool LengthCompare(const string &amp;, const string ...
  • 函数形参-指针指针

    2017-04-06 21:58:00
    程序1:void myMalloc(char *s) //我想在函数中分配内存,再返回 { s=(char *) malloc(100); } void main() { char *p=NULL; myMalloc(p); //这里的p实际还是NULL,p的值没有改变,为什么? if(p) free(p); }程序2...
  • 在使用的过程中需要通过对地址的解引用来操作其所指向的变量,同时可以通过指针的自增自减移动从而改变所指向的值,灵活度较大。 (2)引用作为函数参数进行传递时,实质上传递的是实参本身,即传递进来的不是...
  • 测试环境: win10 x86-64 gcc: x86_64-pc-cygwin...2)数组作为函数形参时将被转化为指向数组第一个元素的指针,无论是int a[10]还是int a[]形式的形参,在函数内部都是int *a形式指针 3)没有办法直接将数组本身...
  • 理解:定义了一个数组,而它的每个元素的类型是一个指向字符/字符串的指针。 元素表示:char *a[i] char *(a[i])是一样的,因为[]优先级高于* 思考:是否可以这样理解 (char*)arr[4]? 深入理解: 数组...
  • 所以指针本身也可以是常量,指针也可以指向常量,下面区分一下。 1. 指向常量的指针(pointer to const) 指向常量的指针不能用于改变所指对象的值。 const double pi = 3.14; const double *cptr = &amp;pi...
  • 指针做形参时应该注意的地方

    千次阅读 多人点赞 2018-07-23 18:58:45
    2. 只可以对指针指向的值改变。       首先看以下程序:   #include &lt;stdio.h&gt; int *swap(int *px, int *py){   int temp;   temp = *px;   *px = *py;   *py = temp;   ret....
  • 就是一个函数的输入参数是一个指针,该函数需要改变该指针指向的地址,如: 现在有一个全局数组b,现在需要编写一个函数 输入参数是一个指针a,需要通过该函数将该指针a指向数组b,即: int b[3] = {1,2,3}; void ...
  • 指向函数指针变量的用途之一就是可以把该函数的入口地址作为参数传递到其它函数(传递给形参)。 原理举例: 有一个函数名为fun的函数,它有两个形参x1和x2,并且定义x1和x2为指向函数指针变量。在调用fun函数...
  • 指针数组的重要应用是作为main函数形参,在以往的程序中,main函数的第一行一般形式为: int main()或 int main(void) 括号中为空或为“void”,表示main函数没有参数,调用main函数时不必给出参数。 这...
  • 面向对象程序设计,即c++语言。类,函数形参、返回值为不同情况时,复制构造函数的调用。内有详细的注释说明。
  • 通常来说C++函数指针是指指向函数的指针,而非指向对象的指针。就像其他指针一样,函数指针也指向某个特定的类型。函数类型由其返回类型以及形参表确定,而与函数名无关。 定义: char (*fP)(char,int); ...
  • 指针做形参形参的传递详解

    千次阅读 2015-06-16 18:55:01
    一、用二级指针作为函数参数,有两种典型情况: 1.需要传递一级指针的数组时: 例如标准C的main函数: int main(int argc, char*[] argv),数组最高维可以退化,char*[] argv等价于char** argv。这里argv...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 82,121
精华内容 32,848
关键字:

指向函数的指针做形参