精华内容
下载资源
问答
  • c语言函数指针与指针函数

    千次阅读 2018-12-04 22:25:55
    //1 C语言函数指针 //解释:这是一种很特殊的指针,它的指向是一个函数的入口 //作用:该指针可以接受一个函数的地址,代表这个函数执行函数的操作 //函数指针举例 //下面是一个函数指针pFunc,...

    #include <stdio.h>
    #include <stdlib.h>
    #include <vector>

    using namespace std;

    //1 C语言函数指针
    //解释:这是一种很特殊的指针,它的指向是一个函数的入口
    //作用:该指针可以接受一个函数的地址,代表这个函数执行函数的操作

    //函数指针举例
    //下面是一个函数指针pFunc, 它只能指向返回值为float,形参为vector<float>的函数

    float (*pFunc1)(const vector<float> &);

    //函数名   : findMax
    //函数功能  : 查找vector容器的最大值
    //输入参数  : v
    //输出参数  : 无
    //返回值    : 返回vector容器的最大值

    float findMax(const vector<float> &v)
    {
        float fMax = 0;
        for (float curValue : v)
        {
            if (curValue > fMax) fMax = curValue;
        }

        return fMax;
    }

    //函数名   : findMin
    //函数功能  : 查找vector容器的最小值
    //输入参数  : v
    //输出参数  : 无
    //返回值    : 返回vector容器的最小值

    float findMin(const vector<float> &v)
    {
        auto fMin = 0xFFFFFF;
        for (auto curValue : v)
        {
            if (curValue < fMin) fMin = curValue;
        }

        return fMin;
    }

    //函数名   : average
    //函数功能  : 计算vector容器的所有元素的平均值
    //输入参数  : v
    //输出参数  : 无
    //返回值    : 返回vector容器的所有元素的平均值

    float average(const vector<float> &v)
    {
        auto fSum = 0;
        for (auto curValue : v)
        {
            fSum += curValue;
        }

        auto fAverage = fSum / v.size();

        return fAverage;
    }

    typedef float (*pPointer)(const vector<float> &);

    //C语言函数指针举例
    int main()
    {
        //用法1 先定义函数指针类型float (*pFunc1)(const vector<float> &);
        vector<float> v;
        v.push_back(10.44);
        v.push_back(15.8);
        v.push_back(112.9);

        pFunc1 = findMax;
        float fMax = (*pFunc1)(v);

        pFunc1 = findMin;
        float fMini = (*pFunc1)(v);

        pFunc1 = average;
        float fAverage = (*pFunc1)(v);

        //用法2 使用到时再定义函数指针float (*pFunc2)(const vector<float> &) = NULL;
        float (*pFunc2)(const vector<float> &) = NULL;

        pFunc2 = findMax;
        fMax = (*pFunc2)(v);

        pFunc2 = findMin;
        fMini = (*pFunc2)(v);

        pFunc2 = average;
        fAverage = (*pFunc2)(v);

        //用法3 把函数指针定义为数据类型typedef float (*pPointer)(const vector<float> &);
        pPointer pFunc3 = findMax;
        fMax = (*pFunc3)(v);

        pFunc3 = findMin;
        fMini = (*pFunc3)(v);

        pFunc3 = findMin;
        fMini = (*pFunc3)(v);

        return 0;
    }

    //2 C语言指针函数
    //解释:这是一种返回值为指针的函数
    //作用:调用这个函数,他的最终返回值是一个指针,指针类型必须一致,否则赋值失败

    //函数名   : add
    //函数功能  : 两数相加
    //输入参数  : v1 第一个数
    //输入参数  : v2 第二个数
    //输出参数  : 无
    //返回值    : 返回两数相加后的变量指针

    float *add(int v1, int v2)
    {
        float *pSum = (float*)malloc(1 * sizeof(float)); //使用必须调用delete释放内存,否则会有内存泄露
        pSum = NULL;

        //*pSum 是解指针
        *pSum = v1 + v2;

        return pSum;
    }

    //C语言指针函数举例
    int main()
    {
        float *pSum = add(10, 20);
        delete pSum; //一定要释放,否则内存泄露

        return 0;
    }

    展开全文
  • c语言函数指针_指针函数_返回值是函数指针

    千次阅读 多人点赞 2019-03-06 17:38:43
    函数指针作为函数的返回值 1.指针函数的定义 顾名思义,指针函数即返回指针的函数。其一般定义形式如下: 类型名 *函数名(函数参数表列); 其中,后缀运算符括号“()”表示这是一个函数,其前缀运算符星号“*”...

    用函数指针作为函数的返回值

    1.指针函数的定义

    顾名思义,指针函数即返回指针的函数。其一般定义形式如下:

    类型名 *函数名(函数参数表列);

    其中,后缀运算符括号“()”表示这是一个函数,其前缀运算符星号“*”表示此函数为指针型函数,其函数值为指针,即它带回来的值的类型为指针,当调用这个函数后,将得到一个“指向返回值为…的指针(地址),“类型名”表示函数返回的指针指向的类型”。

    “(函数参数表列)”中的括号为函数调用运算符,在调用语句中,即使函数不带参数,其参数表的一对括号也不能省略。其示例如下:

    int *pfun(int, int);

    由于“*”的优先级低于“()”的优先级,因而pfun首先和后面的“()”结合,也就意味着,pfun是一个函数。即:

    int *(pfun(int, int));

    接着再和前面的“*”结合,说明这个函数的返回值是一个指针。由于前面还有一个int,也就是说,pfun是一个返回值为整型指针的函数。

    我们不妨来再看一看,指针函数与函数指针有什么区别?

    int (*pfun)(int, int);

    通过括号强行将pfun首先与“*”结合,也就意味着,pfun是一个指针,接着与后面的“()”结合,说明该指针指向的是一个函数,然后再与前面的int结合,也就是说,该函数的返回值是int。由此可见,pfun是一个指向返回值为int的函数的指针。

    虽然它们只有一个括号的差别,但是表示的意义却截然不同。函数指针的本身是一个指针,指针指向的是一个函数。指针函数的本身是一个函数,其函数的返回值是一个指针。

    2. 用函数指针作为函数的返回值

    在上面提到的指针函数里面,有这样一类函数,它们也返回指针型数据(地址),但是这个指针不是指向intchar之类的基本类型,而是指向函数。对于初学者,别说写出这样的函数声明,就是看到这样的写法也是一头雾水。比如,下面的语句:

    int (*ff(int))(int *, int);

    我们用上面介绍的方法分析一下,ff首先与后面的()结合,即:

    int (*(ff(int)))(int *, int); // 用括号将ff(int)再括起来

    也就意味着ff是一个函数。

    接着与前面的*结合,说明ff函数的返回值是一个指针。然后再与后面的()结合,也就是说,该指针指向的是一个函数。

    这种写法确实让人非常难懂,以至于一些初学者产生误解,认为写出别人看不懂的代码才能显示自己水平高。而事实上恰好相反,能否写出通俗易懂的代码是衡量程序员是否优秀的标准。一般来说,用typedef关键字会使该声明更简单易懂。在前面我们已经见过:

    int (*PF)(int *, int);

    也就是说,PF是一个函数指针“变量”。当使用typedef声明后,则PF就成为了一个函数指针“类型”,即:

    typedef int (*PF)(int *, int);

    这样就定义了返回值的类型。然后,再用PF作为返回值来声明函数:

    PF ff(int);

    下面将以程序清单1为例,说明用函数指针作为函数的返回值的用法。当程序接收用户输入时,如果用户输入d,则求数组的最大值,如果输入x,则求数组的最小值,如果输入p,则求数组的平均值。

     

     

    1.函数指针的定义


      顾名思义,函数指针就是函数的指针。它是一个指针,指向一个函数。看例子:

    ?

    1

    2

    3

    A) char * (*fun1)(char * p1,char * p2);

    B) char * *fun2(char * p1,char * p2);

    C) char * fun3(char * p1,char * p2);

      

    看看上面三个表达式分别是什么意思?


    C)这很容易,fun3是函数名,p1,p2是参数,其类型为char *型,函数的返回值为char *类型。
    B) 也很简单,与C)表达式相比,唯一不同的就是函数的返回值类型为char**,是个二级指针。
    A) fun1是函数名吗?回忆一下前面讲解数组指针时的情形。我们说数组指针这么定义或许更清晰:

    ?

    1

    int (*)[10] p;

    再看看A)表达式与这里何其相似!明白了吧。这里fun1不是什么函数名,而是一个指针变量,它指向一个函数。这个函数有两个指针类型的参数,函数的返回值也是一个指针。同样,我们把这个表达式改写一下:

    ?

    1

    char * (*)(char * p1,char * p2) fun1;

    这样子是不是好看一些呢?只可惜编译器不这么想。^_^。

     

    2.函数指针使用的例子


      上面我们定义了一个函数指针,但如何来使用它呢?先看如下例子:

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    #include <stdio.h>

    #include <string.h>

    char * fun(char * p1,char * p2)

    {

      int i = 0;

      i = strcmp(p1,p2);

      if (0 == i)

      {

        return p1;

      }

      else

      {

        return p2;

      }

    }

    int main()

    {

      char * (*pf)(char * p1,char * p2);

      pf = &fun;

      (*pf) ("aa","bb");

      return 0;

    }

      我们使用指针的时候,需要通过钥匙(“*”)来取其指向的内存里面的值,函数指针使用也如此。通过用(*pf)取出存在这个地址上的函数,然后调用它。

      这里需要注意到是,在Visual C++6.0里,给函数指针赋值时,可以用&fun或直接用函数名fun。这是因为函数名被编译之后其实就是一个地址,所以这里两种用法没有本质的差别。这个例子很简单,就不再详细讨论了。

     

    3.*(int*)&p ----这是什么?


      也许上面的例子过于简单,我们看看下面的例子:

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    void Function()

    {

      printf("Call Function!\n");

    }<br>

    int main()

    {

      void (*p)();

      *(int*)&p=(int)Function;

      (*p)();

      return 0;

    } 


    这是在干什么?*(int*)&p=(int)Function;表示什么意思?
    别急,先看这行代码:

    ?

    1

    void (*p)();

    这行代码定义了一个指针变量p,p指向一个函数,这个函数的参数和返回值都是void。
    &p是求指针变量p本身的地址,这是一个32位的二进制常数(32位系统)。
    (int*)&p表示将地址强制转换成指向int类型数据的指针
    (int)Function表示将函数的入口地址强制转换成int类型的数据。
    分析到这里,相信你已经明白*(int*)&p=(int)Function;表示将函数的入口地址赋值给指针变量p。


    那么(*p) ();就是表示对函数的调用。


    讲解到这里,相信你已经明白了。其实函数指针与普通指针没什么差别,只是指向的内容不同而已。
    使用函数指针的好处在于,可以将实现同一功能的多个模块统一起来标识,这样一来更容易后期的维护,系统结构更加清晰。或者归纳为:便于分层设计、利于系统抽象、降低耦合度以及使接口与实现分开。

     

     

    4.(*(void(*) ())0)()------这是什么?


      是不是感觉上面的例子太简单,不够刺激?好,那就来点刺激的,看下面这个例子:

    ?

    1

    (*(void(*) ())0)();

    这是《C Traps and Pitfalls》这本经典的书中的一个例子。没有发狂吧?下面我们就来分析分析:

    ?

    1

    2

    3

    4

    第一步:void(*) (),可以明白这是一个函数指针类型。这个函数没有参数,没有返回值。

    第二步:(void(*) ())0,这是将0强制转换为函数指针类型,0是一个地址,也就是说一个函数存在首地址为0的一段区域内。

    第三步:(*(void(*) ())0),这是取0地址开始的一段内存里面的内容,其内容就是保存在首地址为0的一段区域内的函数。

    第四步:(*(void(*) ())0)(),这是函数调用。


    好像还是很简单是吧,上面的例子再改写改写:

    ?

    1

    (*(char**(*) (char **,char **))0) ( char **,char **);


    如果没有上面的分析,肯怕不容易把这个表达式看明白吧。不过现在应该是很简单的一件事了。读者以为呢?

     

    5.函数指针数组

     

      现在我们清楚表达式

    ?

    1

    char * (*pf)(char * p);

    定义的是一个函数指针pf。既然pf是一个指针,那就可以储存在一个数组里。把上式修改一下:

    ?

    1

    char * (*pf[3])(char * p);

    这是定义一个函数指针数组

     

      它是一个数组,数组名为pf,数组内存储了3个指向函数的指针。这些指针指向一些返回值类型为指向字符的指针、参数为一个指向字符的指针的函数。

      这念起来似乎有点拗口。不过不要紧,关键是你明白这是一个指针数组,是数组。函数指针数组怎么使用呢?这里也给出一个非常简单的例子,只要真正掌握了使用方法,再复杂的问题都可以应对。

     

    如下:

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    #include <stdio.h>

    #include <string.h>

    <br>char * fun1(char * p)

    {

      printf("%s\n",p);

      return p;

    }

    char * fun2(char * p)

    {

      printf("%s\n",p);

      return p;

    }

    char * fun3(char * p)

    {

      printf("%s\n",p);

      return p;

    }

    <br>int main()

    {

      char * (*pf[3])(char * p);

      pf[0] = fun1; //可以直接用函数名

      pf[1] = &fun2; //可以用函数名加上取地址符

      pf[2] = &fun3;<br>

      pf[0]("fun1");

      pf[0]("fun2");

      pf[0]("fun3");

      return 0;

    } 

     

    6.函数指针数组的指针


      看着这个标题没发狂吧?函数指针就够一般初学者折腾了,函数指针数组就更加麻烦,现在的函数指针数组指针就更难理解了。
    其实,没这么复杂。前面详细讨论过数组指针的问题,这里的函数指针数组指针不就是一个指针嘛。只不过这个指针指向一个数组,这个数组里面存的都是指向函数的指针。仅此而已。


    下面就定义一个简单的函数指针数组指针:

    ?

    1

    char * (*(*pf)[3])(char * p);


    注意,这里的pf和上一节的pf就完全是两码事了。上一节的pf并非指针,而是一个数组名;这里的pf确实是实实在在的指针。这个指针指向一个包含了3个元素的数组;这个数字里面存的是指向函数的指针;这些指针指向一些返回值类型为指向字符的指针、参数为一个指向字符的指针的函数。

      这比上一节的函数指针数组更拗口。其实你不用管这么多,明白这是一个指针就ok了。其用法与前面讲的数组指针没有差别。下面列一个简单的例子:

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    #include <stdio.h>

    #include <string.h>

    char * fun1(char * p)

    {

    printf("%s\n",p);

    return p;

    }

    char * fun2(char * p)

    {

    printf("%s\n",p);

    return p;

    }

    char * fun3(char * p)

    {

    printf("%s\n",p);

    return p;

    }

    int main()

    {

    char * (*a[3])(char * p);

    char * (*(*pf)[3])(char * p);

    pf = &a;

    a[0] = fun1;

    a[1] = &fun2;

    a[2] = &fun3;

    pf[0][0]("fun1");

    pf[0][1]("fun2");

    pf[0][2]("fun3");

    return 0;

    }

    展开全文
  • 有时遇到函数返回值空和函数返回值为指针的情况下,需要在前面定义该函数//函数的返回值为指针也必须在此定义, //函数的返回值void必须在此定义,返回值是整形或者其他基本类型不需要在此定义 #include #...

    有时遇到函数返回值为空和函数返回值为指针的情况下,需要在前面定义该函数
    //函数的返回值为指针也必须在此定义,
    //函数的返回值为void必须在此定义,返回值是整形或者其他基本类型不需要在此定义

    函数功能:把格式化的数据写入某个字符串
    函数原型:int sprintf( char *buffer, const char *format [, argument] … );
    返回值:字符串长度(strlen)
    
    #include 
    
    void main(){
    
    char* who = "I";
    char* whom = "CSDN";
    char s[30];
    sprintf(s, "%s love %s.", who, whom); //产生:"I love CSDN. "  这字符串写到s中
    printf("%s\n",s);
    sprintf(s, "%10.3f", 3.1415626); //产生:" 3.142"
    printf("%s\n",s);
    sprintf(s,"hejianghzou");
    printf("%s\n",s);
    
    
    }


    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    
    char * test3();    //函数的返回值为指针也必须在此定义,
    void test2(void);	//函数的返回值为void必须在此定义,返回值是整形或者其他基本类型不需要在此定义
    					
    void main(void)
    {
    	char *cp;
    //	const int two = 2;
    	test2();
    	cp = test3();
    	printf(cp);
    
    }
     void test2(void)
    {
    	int i = 0;
    	char *available_resources[] = {"afbhd","gbjaf","dajgb","kcdbha"};
    	for(i;i<4;i++){
    		printf("\n ");
    		printf(available_resources[i]);
    		printf("\n");
    	}
    
    }
    char *test3()
    {
    	
    	char *tempbuffer ;
    	char buffer[120] ;
    	tempbuffer = (char*)malloc(100*sizeof(char));
    	memcpy(tempbuffer,"That'd be in the data segment ,bob",100);
    	printf(tempbuffer);
    	strcpy(buffer,(char*)"Game's over");
    	return buffer;
    }


    展开全文
  • C语言 函数指针和指针函数及Main()函数

    万次阅读 多人点赞 2018-09-04 10:59:01
    声明格式:类型标识符 *函数名(参数表) 这似乎并不难理解,再进一步描述一下。 看看下面这个函数声明: int fun(int x,int y); 这种函数应该都很熟悉,其实就是一个函数,然后返回值是一个 int 类型,...

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

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

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

    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 (*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,2) = " << (*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);
    可以简单粗暴的理解为,指针函数的*是属于数据类型的,而函数指针的星号是属于函数名的。
    再简单一点,可以这样辨别两者:函数名带括号的就是函数指针,否则就是指针函数。

    Main()函数俩个参数
    1、定义
    C语言规定main函数的参数只能有两个,习惯上这两个参数写为argc和argv。因此,main函数的函数头可写为: main (argc,argv)C语言还规定argc(第一个形参)必须是整型变量,argv( 第二个形参)必须是指向字符串的指针数组。加上形参说明后,main函数的函数头应写为:
    int main (int argc,char *argv[]){…}或者
    int main (int argc,char **argv){…}
    其中第一个表示参数的个数;第二个参数中argv[0]为自身运行目录路径和程序名,argv[1]指向第一个参数、argv[2]指向第二个参数……
    完整程序如下
    这里写图片描述
    2、如何执行
    由于main函数不能被其它函数调用, 因此不可能在程序内部取得实际值。那么,在何处把实参值赋予main函数的形参呢? 实际上,main函数的参数值是从操作系统命令行上获得的。当我们要运行一个可执行文件时,在DOS提示符下键入文件名,再输入实际参数即可把这些实参传 送到main的形参中去,具体操作如下:
    首先在C++中完成编译之后,然后在dos命令窗口下切换到.exe执行文件所在的文件夹(dos下如何切换目录见DOS中切换盘符及目录),再在该路径下输入带参数的命令:XXX.exe a b c …即可得到输出。

    3、练习题
    不合法的main函数命令行参数表示形式是
    (A) main(int a,char *c[]) (B) main(int arc,char **arv)
    (C) main(int argc,char *argv) (D) main(int argv,char *argc[])

    **分析:**main的第2个参数应该为一个字符数组指针,B的第二个参数是一个指向字符的指针的指针,也就是一个字符串数组;
    C的第二个参数是一个指向字符的指针,也就是一个字符串.
    char **argv或者char *argv[]是个二维数组,也可以理解为一个存放字符指针的数组—字符指针数组。每个元素存放一个字符指针,而字符指针又是可以指向一个字符串的,这n个字符串分别由argv[0]~~~argv[n]来指向.
    这个就是指针数组,不是别的,特别不是二维数组。
    综述,答案为C。

    展开全文
  • C语言程序的命令行参数解析 以及 可选参数解析 ② 函数指针详解 , 对复杂的函数指针解析 ③ 解析复杂的函数声明 ④ gdb调试工具的使用
  • 详解C语言指针函数、函数指针函数指针数组

    万次阅读 多人点赞 2018-07-09 11:08:24
    而在指针中,指针函数、函数指针、指针函数数组、函数指针数组、指向函数指针数组的指针等等概念看着又绕又头疼。本问总结了一下以上一些概念以及用法,并给出例程深化理解。 1. 指针函数 指针函数就是返回指针值...
  • C语言函数传递指针参数的问题

    万次阅读 多人点赞 2016-11-28 12:14:18
    一个问题是,我们想用一个函数来对函数外的变量v...如果你真的理解C语言中【函数】这个工具的本质,我想你稍微仔细的思考一下,可能就不会来查看博主的这篇文章,对函数来说,它所传递的任何参数仅仅是原来参数的一...
  • C语言函数指针做函数参数案例

    千次阅读 2013-10-09 12:38:01
    本案例利用函数指针当作函数的参数,函数 add(int (*pf)(int*,int),int *a,int n)可以做到传入addOne就对数组a中每个数值加1,传入addTwo就对数组a中每个数值加2,案件具体代码如下: #include //对数组每个数加...
  • C语言指针函数和函数指针区别

    千次阅读 多人点赞 2019-02-28 15:24:46
    C语言函数指针和指针函数的区别 C和C++中经常会用到指针,和数据项一样,函数也是有地址的,函数的地址是存储其机器语言代码的内存的开始地址。 指针函数和函数指针经常会混淆,一个是返回指针的函数,另一个是指向...
  • c语言_函数指针作为函数参数的使用

    千次阅读 2016-07-22 20:39:21
    c语言_函数指针作为函数参数的使用 程序代码: 程序运行结果:
  • C语言函数传递指针参数

    千次阅读 2018-09-11 14:59:47
    #include void swap(int *a,int *b) { printf("address in swap():%p %p\n",a,b);...函数的传递实质是形参值对实参值的拷贝。...swap()函数:对拷贝的...更简单的方法引用&,直接对函数外的值进行操作,方便易懂。
  • C语言函数内部改变指针本身

    千次阅读 2012-10-25 23:11:44
    今天发一个C语言基础的小知识点:C语言函数参数传递方式只有一种:值传递。   可能大家在刚开始学习C的时候都被一些教材误导,认为C中有值传递和地址传递两种方式。其实只有值传递一种,无论函数以什么形式进行...
  • C语言函数指针参数传递

    千次阅读 2014-10-16 22:49:30
    c语言函数传递指针的一些杂谈和陷阱。
  • 来源:公众号【编程珠玑】作者:守望先生前言函数传参有三种传参方式:传值、传址、传引用。我们可能听过C语言中的传值和传指针,在其他语言中,也有传引用一说,那么他们到底有什么...
  • C语言tips:函数指针函数指针数组

    千次阅读 2020-09-20 16:20:11
    C语言函数指针函数指针数组 自1972年C语言在贝尔实验室问世以来,经久不衰,堪称编程语言中的常青树。而C语言中的指针更是其中最重要也最难的部分,通过指针可以实现很多让人惊喜的事情。 我们都知道,在C语言...
  • c语言函数指针及指针函数

    千次阅读 2018-11-14 17:41:04
    用最少的字来阐述函数指针与指针函数之间的本质区别及用法。使用过程中,万变不离其宗,只会在返回的类型,参数类型上做文章,本质不便。 概念: 指针函数本质是一个函数,只是函数的返回值是一个指针。 函数指针...
  • C语言函数指针调用函数

    千次阅读 2015-07-01 21:26:18
    1、定义函数指针变量: 函数返回值类型 (*指针变量名)(); 2、将已有函数入口赋值给函数指针变量:fnPt = avg; 3、使用指针变量调用函数:(*指针变量名)(参数); 例子:定义函数指针变量,将不同函数赋值给指针变量...
  • C语言 函数参数和调用函数

    千次阅读 2019-04-14 08:39:07
    如果函数要使用参数,则必须声明接受参数值的变量。这些变量称为函数的形式参数。 形式参数在进入函数时被创建,退出函数时被销毁。 当调用函数时,有两种向函数传递参数的方式: 传值调用 默认情况下,C 语言使用...
  • C语言函数参数引用类型回顾

    千次阅读 2019-07-26 17:12:21
    涉及:数组参数指针参数... *函数参数指针指针引用的区别在于: 参数指针参数可以看作传的是地址,不能改变实参所指向的地址。 参数指针引用:参数可以看作是实参指针本身,可以改变内部所指向的地址...
  • C语言可以通过函数指针来调用函数,可以将要调用的函数名保存到数组中。这样我们可以通过参数来直接调用函数了。 #include &lt;stdio.h&gt; #define FUNCTIONSIZE 2 typedef unsigned char uint8_t; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 278,024
精华内容 111,209
关键字:

c语言函数参数为指针

c语言 订阅