精华内容
下载资源
问答
  • 有时候,我们定义的函数需要接收用户传入的数据,那么就需要使用到函数参数函数参数的数量可以有多个, 返回值一般表示函数计算后的数值,也可以表示执行结果。 主函数传入的参数称为实参,传递到函数体的...

    有时候,我们定义的函数需要接收用户传入的数据,那么就需要使用到函数的参数。

    函数参数的数量可以有多个,

    返回值一般表示函数计算后的数值,也可以表示执行结果。

    主函数传入的参数称为实参,传递到函数体的参数叫做形参。

    传递到形参后就可以直接在函数体当中使用已经定义过的形参的数据。

    函数的设计应该遵从一个函数实现一个功能的原则,

    传入的参数让函数实现更为丰富的功能。

    类型名就是指定函数的返回值,一个函数实现一个功能通常是要反馈结果的,若函数确实不需要返回值,可以使用void来定义。

    函数定义时写的参数就是形参,形式参数,定义时仅仅是一个占位符,没有实际数值,在主函数执行函数时传递的具体的数值就是实际参数。

    实参和形参的功能就是用于数据传输。当函数发生调用的时候,实参的值会传递给形参。并且传递是具有单向性的。当函数执行党的时候形参才会生成具体的空间,才会分配内存,当函数结束之后就会立即释放内存。所以形参的变量只有在函数的内部有效,出了函数他什么也不是。

    传值和传址

    指针也是一个变量,所以可以通过参数(将指针的存值)传递给函数。引进指针的参数有什么意义呢?

    因为作用域的存在,不同的函数是无法直接去访问对方的变量的,所以形参和实参重名也并不冲突。

    当通过传递变量实现对一个变量的更改并打印的话,在函数中更改的仅仅是形参,对在main函数的数据没有影响。

    而函数中指针的使用呢就是拿到实参变量的地址,直接对所在的地址的数据进行修改。

    这是传值和传址的根本区别。

    传递数组

    在主函数中定义的数组,进行实参与形参的传值时,函数调用处的实参直接书写数组名就可以了。实际上不是传输的整个数组的每个值,并不存在将整个数组作为参数传递的形式,而是将数组的第一个元素的地址进行了传递,所以,在函数中对数组元素进行的修改会将主函数中定义的数组的元素一并修改。

    指针函数与函数指针

    指针函数:

    函数的类型实际指的就是函数的返回值。可以返回为整形、浮点型、等、当然也可以返回指针类型的数据,定义时只需要在函数名前面加一个*就可以了。这就称为指针函数。

    指针函数产生并返回的是一个带指针的,比如返回一个字符串,那就是用char类型进行定义的。

    譬如我们使用%s进行输出时需要一个字符串,我们使用函数来进行提供字符串,但是对于字符串没有可以定义字符串的类型,我们是用char类型的指针来定义的字符串,字符串的约定俗成就是给指针读到空字符就可以结束,所以我们知道第一个字符地址就可以知道整个字符串,所以我们定义函数返回值类型时候,对于返回字符串类型都是定义的char类型。

    用指针变量做返回值我们就称之为指针函数。

    注意:不要返回局部变量(在函数中定义的变量)的指针!!

    函数指针:

    是一个指针,指向函数的指针。与数组一样,定义时我们使用小括号将函数的名字与前面的*号括起来。

    函数表示法就是我们平时用的函数,像printf函数,这个函数的名字经过求值之后,就会变成函数的地址。所以呢,在定义了函数指针后,再给他传递一个已经被定义的函数名就可以通过该指针进行调用函数了。

    比如我们定义一个函数指针,希望通过函数指针来对已经定义的函数进行调用,那么就是使指针指向函数,此指针的返回值为函数的返回值,参数为函数的参数。

    譬如定义函数指针fp同过fp调用函数int squre(int ):int (*fp)(int ); 直接让fp = squre ;就可以。

    为什么呢?因为我们定义的指针就规定了此指针只能指向一个参数为int 返回值为int的函数。所指函数各方面就是与squre符合,所以就可以直接相等。这个squre经过运算之后就是函数的地址,这个地址被指针存储了。

    函数指针作为参数:

    函数指针也可以被作为参数进行传递。这就实现了在一个函数里调用另一个函数。

    当我们定义了一个函数,函数的参数的类型可以为指针类型,如果我们为此指针添加了参数类型与返回值类型,那么这个指针我们要求它必须指向符合给他定义的参数与返回值的函数,这就是一个函数指针,它必须指向函数。指针的本质就是存储一个所指的地址,所以传参时传递的就是一个地址,函数的本质也是一个地址,所以传参时我们就可以将函数名作为实参传递出去,这个指针收到地址后存储,就是指向了地址对应的函数,那么我们就成功在一个函数里通过指针调用了另外一个函数。既然调用的函数是有参数与返回值的,所以我们定义的函数的返回值必须与所调函数一致,还需增加参数值,个数与类型都要与所掉函数的参数一致。

    举个例子,我们定义一个calc函数,希望通过这个函数实现对其他函数如sub,add函数自由的调用。

    首先我们定义add函数与sub函数:int add(int ,int );      int sub(int ,int );

    这两个函数的返回值与参数类型都是int,参数都具有两个。

    接下来就是定义calc函数并实现对sub或add的调用了:

    刚刚说过,要实现对其他函数的调用,需要定义一个函数指针,来接收不同的函数的地址,接收谁的地址,就调用谁。然后执行函数的返回值类型与参数个数,类型还必须与所调函数的返回值与参数完全一样。

    所以我们这么定义calc:int calc(int (*fp)(int ,int ),int ,int );

    calc函数有三个参数,第一个参数为函数指针类型的参数,它可以调用其他的函数,第二个、三个为整形参数,为调用成功后函数的参数,所调函数进行运算完毕后,必然返回一个值,所以calc的返回值必须与所调函数的返回值一样,接受了所调函数的返回值再返出calc函数。

    当我们在主函数里调用calc时就是这样:calc(add,5,8); 实参分别为add函数的地址,参数5,和参数8。

    反正就是函数指针他必须接收函数!!,接收了就能实现指针调用函数。可以是函数指针与函数直接相等,也可以通过传参进行传递。当然成功调用的前提是函数指针的定义(即返回值,参数)都要正确,都要符合所指函数的类型。

    当函数指针作为参数时,就表示它要开始调用函数了!

    将函数指针作为返回值:

    什么意思呢?

    比如这个函数的名字叫select,它本身有两个参数,返回的返回值是一个函数指针,这个函数指针也具有两个参数,并且其返回值为整型。那么这个返回函数指针的select函数就是一个返回函数指针(地址)的函数,既然函数指针(地址)作为返回值,那么我们需要再定义一个与返回函数同类型的函数指针来接收它。

    这个函数怎么写?

    int (*select(int ,int ))(int ,int );

    这个式子从第一次出现的变量select看起,向右读,与参数结合形成带两个整形参数的函数,碰到括号想向左看,只有一个*,那么*就是select函数的返回值,select返回一个地址。这个地址可以是一个函数的地址,而最希望得到函数地址的是函数指针,所以我们就定一个函数指针来接收select函数返回的地址,完成函数指针对select返回的函数的调用。

    如果我们想把此函数指针放到其他函数里进行调用,即用其他函数调用这个函数指针作为返回值形成的函数指针,我们最好新建一个函数指针来接收此函数指针 ,int (*fp)(int ,int ) = int (*select(int,int ))(int ,int)  这样调用时就不需要使用函数名select而是使用函数指针fp,这样调用就直观多了。

    说不清楚也容易说错,下面是使用函数指针作为返回值完成的计算器代码:

    #include <stdio.h>
    
    int add(int ,int);
    int sub(int ,int); 
    int (*select(char))(int ,int );  // 定义一个函数指针,指向函数返回的地址 
     
    int add(int num1 ,int num2)
    {
    	return num1 + num2; 
    }  
    int sub(int num1 ,int num2)
    {
    	return num1 - num2;
    }
    //calc方法  调用函数的函数 
    int calc(int (*fp)(int ,int),int num1,int num2) 
    {
    	return (*fp)(num1,num2);
    }
    //select方法  select的返回值是地址
    int (*select(char op))(int ,int)  									 
    {
    	switch(op)
    	{
    		case '+' : return add;
    		case '-' : return sub;
    	}
    }
    
    int main()
    {
    	int num1 ,num2;
    	char op;
            int (*fp)(int ,int);  //定义一个函数指针fp来接受select函数返回的地址形成的函数指针
    
    	printf("请输入一个式子:");
    	scanf("%d%c%d",&num1,&op,&num2);
    
    	fp = select(op);
    	//根据op决定调用的函数
    	printf("%d %c %d = %d",num1,op,num2,calc(fp,num1,num2)); 
    	
    	return 0;
    }

    main函数中,在calc调用那里也可以不用fp接收,直接这么写:

    int main()
    {
    	int num1 ,num2;
    	char op;
    	printf("请输入一个式子:");
    	scanf("%d%c%d",&num1,&op,&num2);
    	int (*fp)(int ,int ) = int (*select(char op))(int ,int ); 
    	
    	//根据op决定调用的函数
    	printf("%d %c %d = %d",num1,op,num2,calc(select(op),num1,num2)); 
    	
    	return 0;
    }

    简而言之,以上实现输入字符就能调用对应方法的原理就是:

    函数select根据输入的字符返回对应方法的函数地址,仅仅返回函数地址不可取,我们需要定义一个函数指针来接收这个地址,由此形成可以指向方法函数的函数指针。而这个函数指针又可以在别的函数中作为参数被调用,执行调用的函数需要定义相同的参数与返回值供此函数指针使用。

     

     

     

     

     

    展开全文
  • g #include <iostream>...// funOne是一个函数,带有一个int型参数,它返回一个指向函数指针 // 这个指向函数指针指向一个返回int型,并带有两个int型的形参的函数 int (*funOne(int number...

    一、指针函数
    指针函数就是返回指针的函数。

    #include<iostream>
    #include<string>
    
    using namespace std;
    
    int *getchar(char c)
    {
    	switch(c)
    	{
    		case'A':cout << "Apple" << endl; break;
    		case'B':cout << "Banana" << endl; break;
    		case'C':cout << "Cat" << endl; break;
    		case'D':cout << "Dog" << endl; break;
    		default:cout << "None" << endl;
    	}
    	return 0;
    }
    
    int main()
    {
    	char input;
    	while (1)
    	{
    		cout << "请输入一个大写字母:" << endl;
    		cin >> input;
    		getchar(input);
    	}
    
    	system("pause");
    	return 0;
    }
    

    其实这时候,把getchar()函数前面的*去掉,结果是一样的。只是意义不同。

    二、函数指针
    即指向函数的指针

    int test(int a)
    {
        return a;
    }
    int main(int argc, const char * argv[])
    {
        
        int (*fp)(int a);
        fp = test;
        cout<<fp(2)<<endl;
        return 0;
    }
    

    三、函数指针作为参数

    vector<int> map(const vector<int> &v,int (*f)(int n))
    {
        vector<int> res(v.size(),0);
        for(unsigned int i=0;i<v.size();i++)
        {
            res[i]=f(v[i]);
        } 
        return res;
    }
    
    int func(int n)
    {
        return n*n;
    }
     
    int func2(int n)
    {
        return n*n*n;
    }
    
    //调用map()函数时
    vector<int> test_vector{1,2,3,4,5};
    vector<int> re1=map(test_vector,func);//re1将会 得到{1,4,9,16,25}
    

    四、返回指向函数指针的函数

    #include <iostream>
     
    using namespace std;
     
    int funTwo(int a, int b)
    {
    	return a * b;
    }
     
    // funOne是一个函数,带有一个int型参数,它返回一个指向函数的指针
    // 这个指向函数的指针指向一个返回int型,并带有两个int型的形参的函数
    int (*funOne(int number))(int a, int b)
    {
    	cout<<number<<endl;
    	return funTwo;
    }
     
    int main()
    {
        cout<<funOne(5)(3, 10)<<endl; 
        system("pause");
        return 0;
    }//结果输出5,30
    
    展开全文
  • 类的成员函数指针作为参数传递给其他函数和普通函数指针的传递是不同的,普通函数指针的传递 只要在参数声明中声明是相同参数个数、类型和相同返回类型的函数指针int (*p)(int),传递时只需传函数名就可以了. 可是...
    类的成员函数指针作为参数传递给其他函数和普通函数指针的传递是不同的,普通函数指针的传递
    只要在参数声明中声明是相同参数个数、类型和相同返回类型的函数指针int (*p)(int),传递时只需传函数名就可以了.
    可是传递成员函数指针用此方法却不能工作。指针是指向一些内存地址的变量,既可以是数据的地址也可以是函数的地址。C++的 成员指针遵从同样的原则。但在类内部没有地址;选择一个类的成员意味着在类中偏移。只有把这个偏移和具体对象的开始地址结合,才能得到实际地址。成员指针的语法要求选择一个对象的同时逆向引用成员指针。
    先来看看一个错误的例子:
    //---------------------------------------------------------------------------
    class A
    {
    public:
            int fun1(int i){return i;};
    };


    void fun2(int j, int (A::*p)(int)){
            cout <<p(j);
    }


    void main()
    {
            A oba;
            int i=1;
            fun2(i,oba.fun1);  //this is an error
    }
    //---------------------------------------------------------------------------




    为了能够正确地传递成员函数指针,我们先来看看成员参数、成员函数指针正确的声明方法:
    //---------------------------------------------------------------------------
    class A
    {
    public:
     int i1;
            int fun1(int i){
                    return i;
            };
    };


    void main()
    {
     int (A::*fp1)(int);    //声明fp1为class A中的成员函数指针
            int A::*ip1;           //声明ip1为class A中的成员变量指针
     fp1=&A::fun1;          //初始化fp1
     ip1=&A::i1;            //初始化ip1 
     A oba;
     oba.*ip1=2;
     (oba.*fp1)(oba.*ip1);
    }
    //---------------------------------------------------------------------------




    以下为正确传递成员函数指针的例子:
    //---------------------------------------------------------------------------
    class A
    {
    public:
            int fun1(int i){
                    return i;
            };
    };


    template <class T>
    void fun2(int j, T *obp, int (T::*p)(int)){
            cout <<(obp->*p)(j);
    }


    void main()
    {
            int (A::*fp1)(int);//声明fp1为class A中的成员函数指针
            fp1=&A::fun1;  //初始化fp1
            A oba;
     A *obap=&oba;
     int i=1;
            fun2(i,obap,fp1);
    }
    //---------------------------------------------------------------------------


    当然,可以把成员函数声明为static(静态函数),这样传递它的指针就像传递普通函数一样。但是又涉及一个问题:类中如何在static 函数中调用 非static 函数 。
    方法:使用静态成员函数
    使回调成员函数为静态。因为静态成员函数不带隐含式参数“this”。因此,可以将其参数中的地址当作是普通函数的指针来使用。如果要从静态成员函数中访问对象的数据成员,显式传入对象的地址即可。例如:
    //---------------------------------------------------------------------------
    class Hack
    {
    private:
     int x;
    public:
     int get_x();// 非静态成员函数
     static void func(Hack * pthis); // 静态成员函数
     void func2(); // 非静态成员函数
    };


    void Hack::func(Hack * pthis)
    {
     int y = pthis->get_x(); // 访问对象的数据成员
    }
    //---------------------------------------------------------------------------
    展开全文
  • 在C++中,成员函数指针作为参数传递给其他函数和普通函数指针的传递是不同的,首先我们来回顾一下普通函数指针的传递方法: //--------------------------------------------------------------------------- int...
    在C++中,成员函数指针作为参数传递给其他函数和普通函数指针的传递是不同的,首先我们来回顾一下普通函数指针的传递方法: 
    //---------------------------------------------------------------------------
    int   fun1(int   i){
                    return   i;
    }

    void   fun2(int   j,   int   (*p)(int)){
                    cout   < <   p(j);
    }

    void   main()
    {
                    int   i=1;
                    fun2(i,fun1);
    }
    //---------------------------------------------------------------------------
    只要在参数声明中声明是相同参数个数、类型和相同返回类型的函数指针int   (*p)(int),传递时只需传函数名就可以了

    可是为什么在C++中,传递成员函数指针用此方法却不能工作呢?我们先来回顾一下指针的概念,指针是指向一些内存地址的变量,既可以是数据的地址也可以是函数的地址。C++的   成员指针遵从同样的原则。困难的是所有的指针需要一个地址,但在类内部没有地址;选择一个类的成员意味着在类中偏移。只有把这个偏移和具体对象的开始地址结合,才能得到实际地址。成员指针的语法要求选择一个对象的同时逆向引用成员指针。
    先来看看一个错误的例子:
    //---------------------------------------------------------------------------
    class   A
    {
    public:
                    int   fun1(int   i){return   i;};
    };

    void   fun2(int   j,   int   (A::*p)(int)){
                    cout   < <p(j);
    }

    void   main()
    {
                    A   oba;
                    int   i=1;
                    fun2(i,oba.fun1);     //this   is   an   error
    }
    //---------------------------------------------------------------------------

    当然,你可以把成员函数声明为static(静态函数),这样传递它的指针就像传递普通函数一样,然而把成员函数定义成static类型无法真正解决问题,因为这样的话,该成员函数就不能存取类中的非静态成员变量,而很多情况下既要求传递成员函数指针,又要求该成员函数能够存取类中的非静态成员变量。

    为了能够正确地传递成员函数指针,我们先来看看成员参数、成员函数指针正确的声明方法:
    //---------------------------------------------------------------------------
    class   A
    {
    public:
    int   i1;
                    int   fun1(int   i){
                                    return   i;
                    };
    };

    void   main()
    {
    int   (A::*fp1)(int);         //声明fp1为class   A中的成员函数指针
                    int   A::*ip1;                       //声明ip1为class   A中的成员变量指针
    fp1=&A::fun1;                     //初始化fp1
    ip1=&A::i1;                         //初始化ip1  
    A   oba;
    oba.*ip1=2;
    (oba.*fp1)(oba.*ip1);
    }
    //---------------------------------------------------------------------------

    接下来就可以构造含有成员函数指针参数的函数了:
    void   fun2(int   j,   A   ob,   int   (A::*p)(int)){
                    cout   < <(ob.*p)(j);
    }
    注意声明时必须加上一个对象参数A   ob,因为只有把这个偏移和具体对象的开始地址结合,才能得到实际地址。

    另外,为了保证函数的健壮性和经济性,我们可以把对象参数改为对象指针参数:
    void   fun2(int   j,   A   *obp,   int   (A::*p)(int)){
                    cout   < <(obp-> *p)(j);
    }

    为了通用,我们还可以把这个函数声明为通用函数:
    template   <class   T>
    void   fun2(int   j,   T   *obp,   int   (A::*p)(int)){
                    cout   < <(obp-> *p)(j);
    }
    这样就可以传递不同的类的成员函数指针给它了,以下为正确传递成员函数指针的例程:
    //---------------------------------------------------------------------------
    class   A
    {
    public:
                    int   fun1(int   i){
                                    return   i;
                    };
    };

    template   <class   T>
    void   fun2(int   j,   T   *obp,   int   (T::*p)(int)){
                    cout   < <(obp-> *p)(j);
    }

    void   main()
    {
                    int   (A::*fp1)(int);
                    fp1=&A::fun1;
                    A   oba;
    A   *obap=&oba;
    int   i=1;
                    fun2(i,obap,fp1);
    }
    //---------------------------------------------------------------------------

    但是这样声明之后就不能再传递普通函数指针给函数fun2了,为了更加通用,当然可以显式地重载一下这个函数,以便它也能使用普通函数指针参数:
    //---------------------------------------------------------------------------
    class   A
    {
    public:
                    int   fun1(int   i){
                                    return   i;
                    };
    };

    template   <class   T>
    void   fun2(int   j,   T   *obp,   int   (T::*p)(int)){
                    cout   < <(obp-> *p)(j);
    }

    void   fun2(int   j,   int   (*p)(int)){
                    cout   < <   p(j);
    }

    int   fun3(int   i){
                    return   i;
    }

    void   main()
    {
                    int   (A::*fp1)(int);
                    fp1=&A::fun1;
                    A   oba;
    A   *obap=&oba;
    int   i=1;
                    fun2(i,obap,fp1);
    fun2(i,fun3);
    }
    //---------------------------------------------------------------------------
    (全文完)
    展开全文
  • 1声明: int (*pfunc)(int) 返回值是int类型的函数指针,函数带一个int类型的参数 ...3作为参数 void create(int id,int (×pfunc)(int)) create函数有两个参数,第一个数是id,第二个参数是一个函数指针
  • 函数指针作为参数的语法如下所示: int compare(int a, int b){ return (a > b) ? a : b; } void function(int x, int y, int (*compare)(int, int)){ //... (*compare)(3, 4); //... } int m
  • 函数指针作为参数(以冒泡排序qsort为例)
  • c++问题:如何在不写重载函数的情况下,将不同的函数指针作为参数传入同一个函数?
  •  1、指针数组  数组里面的每个元素都是指针。  指针数组的案例如下:  易犯错误: 2、数组指针   归根结底还是指针,只是取*的时候能够取出一整个数组...3、函数指针: 在gcc编译的时候增
  • 函数指针作为参数&回调函数

    千次阅读 2014-10-25 16:36:06
    在c/c++中,允许把函数当做指针作为cansh
  • 如果你把函数指针(地址)作为参数传递给另一个函数,当这个指针被用来调用其所指向的函数时,我们就说这是回调函数 2、代码实现 #include <stdio.h> int sub(int a, int b); int sub1(int a, int...
  • 函数指针作为另一函数的参数和函数的嵌套的区别,感觉都是调用,有什么不一样呢?他们都适用在什么情况下!(我是在学非递归遍历二叉树时看到的) Status Visit(TElemType e){ printf("%c\n",e); return OK; ...
  • 函数指针作为参数传递给函数

    千次阅读 2010-10-25 11:16:00
    <br /> 函数指针同样是可以作为参数传递给函数的, #include <iostream> #include <string> using namespace std;   int test(int);   int test2(int (*ra)(int),...
  • ``` 函数实现 void swap(int &a, int &b) { int tmp = a; a = b; b = tmp;...难道这里的a,b代表指针吗? 2、使用swap时为什么没有使用swap(&i,&j)? 初学c++,还望大家多多提点指教,先谢谢各位了
  • 今天给忘了c语言中函数指针怎么作为参数了,记一下,省的再忘。 #include void func_callback(int *arg) { *arg = 54; } int func(int a, void (*callback)(int *)) { int b; callback(&b); return...
  • ②是定义了一个函数指针类型。 ③是一个连接蓝牙设备的函数。 现在的问题是:在我的cpp里面如何调用③地方法ConnectDevice。 我是这样做的: 第一步:在mycpp.cpp的顶部添加引用#include” ...
  • C++传递对象函数指针作为参数

    千次阅读 2014-01-24 14:02:59
    2. 即使第三个调用的时候使用 A::func1和强制转换,但是由于虚函数指针的原因&A::func1其实是&C::func1,所以可以断定这里对象的多态性还是起作用的,结果调用的还是C类的func1 3. 使用template<class T> 来提高...
  • 1、通过typdef关键字指定函数指针
  • 函数指针有两种常用的用法,一种是作为结构体成员,关于函数指针作为结构体成员的用法可移步至上一篇函数指针作为...当函数指针作为参数传递的时候,这时接收参数传递的函数通常需要根据这个指针调用这个函数。...
  • C语言 | 函数指针作为函数的参数

    千次阅读 多人点赞 2019-08-05 08:22:38
    函数指针有两种常用的用法,一种是作为结构体成员,关于函数指针作为结构体成员的用法可移步至上一篇【C语言笔记】函数指针作为...当函数指针作为参数传递的时候,这时接收参数传递的函数通常需要根据这个指针调...
  • 线程的封装很简单,并没有多少东西,但是如果我告诉你,我封装的这个线程类里有个成员函数Start,作用是开启线程运行,可以这样调用:class a{public: DWORD ThreadFunca(LONG lParam); void StartThread(); ...
  • 函数指针有两种常用的用法,一种是作为结构体成员,关于函数指针作为结构体成员的用法可移步至上一篇函数指针作为...当函数指针作为参数传递的时候,这时接收参数传递的函数通常需要根据这个指针调用这个函数。...
  • 函数指针的正常使用 //1 函数指针的正常使用 void test1() { printf("world\n"); } void main() { test1();//call 函数,其实本质就是通过test1这个函数的起始地址进入test1函数里面的代码 //执行这些代码,但是...
  • 函数指针作为参数传递的时候,这时接收参数传递的函数通常需要根据这个指针调用这个函数。作为参数传递的函数指针通常表示回调函数(Callback Functions)。 回调函数已在之前一篇文章中有所介绍,下面我再举其他...
  • 函数指针作为函数参数 ** 跟着视频学习了函数指针作为函数参数的使用方法,再次记录下过程: int add1(int a, int b) //这里通过定义三个很像的函数来实现函数的多态 { cout &lt;&lt;"func add1() &...
  • 函数指针作为形参,即可实现函数名作为参数,由另一个函数调用。   一、 定义某一函数的指针类型: 就像自定义数据类型一样,我们也可以先定义一个函数指针类型,然后再用这个类型来申明函数指针变量。 我...
  • //函数指针 int(*fuc)(int, int) 2.作用保存地址,保存程序的入口地址,可以指向不同的函数,表现不同的功能 fuc = max; int main() { int result; int (*fuc)(int, int) fun = max; result

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,986
精华内容 3,594
关键字:

函数指针作为参数