指针函数怎么调用,求指针函数的使用！！

指针函数怎么调用,求指针函数的使用！！详细介绍

本文目录一览： 当一个函数的返回值为指针类型时如何调用

返回指针的函数必须保证退出函数后该指针的目标原则上没有消亡
方法1，直接赋值给另一个同类型指针
方法2，直接加上指针运算符*在赋值号左边对指针所指目标间接访问
返回值类型为指针的函数格式：type * function(){…}，其中type为某种类型（如char、int等，或类、结构体等等），function为一个函数名。
调用方式：
type * var; //定义一个与返回值类型相同的指针变量
var = function(); //执行函数，并将返回值赋值给变量var
cout<<*var; //输出指针所指向的值，C语言输出用printf()函数
或：cout<
<var[i]; 若指针指向数组变量的，则通过此形式输出或调用其值

指针函数调用add函数吗

能调用
函数指针数组是存放函数指针的数组，数组中每个元素的类型都是函数指针类型。
因为，Add是加法函数，，Sub是减法函数，，两者的参数的个数及类型以及函数返回类型是一样的，，所以对于两个函数指针变量的类型，即函数指针类型就是一样
的，，那么既然类型一样，，能不能把它们存放在同一个数组里面呢？
pf是共同的，，不要动，，此时，因为[ ]的优先级高于*，，所以，pfArr先与[2]组成一个数组，，数组里面有2个元素，因为这是一个数组，把数组名和[2]拿下来，即，我们把 pfArr[2] 拿下来，剩余的就是 int（*）(int，int) ，，这就是我们数组每个元素的类型，对于，数组来说，如果 int arr [10]；这是一个整型数组，，如果把 数组名
arr和[ 10] 去掉得到：int，这就是我们数组arr每个元素的类型，，这样我们就得到了所谓的，函数指针数组，，是数组，我们就可以对他初始化，得：
函数指针数组里面就可以存放多个，同类型的函数指针；
我们这里可以初始化为Add，，Sub，，这两个都是函数名， 而函数名就代表函数的地址，，对于Add来说，，，就是把Add函数的地址放在了函数指针变量pf1中，，对于Sub来说，，，就是把Sub函数的地址放在了函数指针变量pf2中，，这里的pf1===Add，，Sub===pf2，，所以初始化的时候，{ }里面也可以放 pf1，，pf2； 这就相
当于是一个 一维数组；
函数指针数组的用途：转移表
空指针是不可以使用的，即使你初始化为空指针NULL，也不能去使用该空指针。
虽然这个代码已经实现了我们的要求，，但是，过程太啰嗦，，功能不全，，如果我还想在此基础上再实现按位与，按位或，按位异或，左移，右移等等功能的话依然
涉及到两个整数进行运算，，所以就要写出更多的，这种调用函数，，同时下面的switch里面也要对应的增加不少东西，，代码就会越来越长，所以说，这个代码不好，
要进行改正，这时就可以使用函数指针数组进行优化：现在，，我们知道，，如果调用一个函数的话，，不一定必须使用函数名进行调用，也可以使用指针调用一个函

带指针的函数怎么调用？

什么叫带指针的函数？说清楚点嘛？
1.如果是返回值是指针
char* getname()
{
char* pname=new char[23]; //返回指针必须是函数释放后并未释放的内存空间，
cout<<"input your name:\n"; //一般返回两种情况，一是在函数中像该函数一样动态分配堆内存
cin.getline(pname,22); //二是返回指针指向参数中地址，如： int* max(int a,int b) { return &a; }
pname[22]='\0';
return pname;
}
int main()
{
char* name=getname();
cout<<"your name is: "<
<name<<endl;
delete []name; //记得动态释放分配内存

return 0;

}

2.参数是指针类型

常见的是通过指针或引用交换两个数的值

void swa(int* p1,int* p2)

{

int temp=*p1; *p1=*p2; *p2=temp;

}

int main()

{

int a=2,b=3;

swa(&a,&b); //传递地址

return 0;

}

附解：你可以把指针看做是一种复合类型，它之所以可以修改参数值，本质是因为

对指针解除引用*p形式是操作的参数所存数据内存空间，但如果它不解除引用，它

并不会修改参数的值：如

void swa(int* p1,int* p2) //函数意思是最初始在函数参数块中定义两个指针p1,p2，使

{ //p1指向a,p2指向b，下面函数体只是使指针指向地址改变，成了

//p1指向b，p2指向a。但并未对a,b内存空间操作，当函数调用结束后，指针p1,p2

//也释放了，所以并未起任何作用

int* temp;

temp=p1; p1=p2; p2=temp;

}

int main()

{

int a=2,b=3;

swa(&a,&b); //传递地址

cout<
<a<<" "<<b;
return 0;

}

这个函数并不会交换a,b的值
</a<
</name<<endl;

C语言 怎么调用指针数组函数

指针数组 就是有一个数组,数组中的元素都是指针,这些指针有相同的类型
int *a[3];
char *b[4];
double *c[5];
--------------------------------------------------------
char paixu(char *a[5]) //这样才是字符串数组
{
int i,j;
char *p;
for(i=0;i<5;i )
{
for(j=0;j<4-i;j )
{
if(strcmp(a[j],a[j 1])>0)
{
p=a[j]; a[j]=a[j 1]; a[j 1]=p;
}
}
}
}
#include

#include

void paixu(char **a)

{

int i,j;

char *p;

for(i=0;i<5;i )

{

for(j=0;j<4-i;j )

{

if(strcmp(a[j],a[j 1])>0)

{

p=a[j];

a[j]=a[j 1];

a[j 1]=p;

}

}

}

}

void main()

{

char *a[]={"Hongkong",

"Singgapore",

"Beijing",

"London",

"Washington"

};

int i;

printf("输出地址\n\n");

for(i=0;i<5;i )

{

printf("%s \n",a[i]);

}

paixu(a);

printf("最终排序是\n\n");

for(i=0;i<5;i )

{

printf("%s \n",a[i]);

}

}

main函数中a是常指针，它指向一组数组，这组数组每个元素又是指向字符串的指针，所以数组中每个元素的类型是char* , 因此变量a的类型是（char*）*，即char**．排序没有必要返回char吧（完成排序功能还用返回一个字符么？），函数参数改为char**类型，这样才能将指针数组首地址传入函数.

向函数里传入的是数组指针，我更改的是数组元素，这是明显的按地址传递方式传递参数，还用再return么．

1.函数指针的数组定义方法：返回值类型( * 指针变量名[Number]) (形参列表)。例如：double add(double a,double b){};double sub(double a,double b){};double mul(double a,double b){};double div1(double a,double b){};double (*oper_func[])(double, double) = {add,sub,mul,div1};//函数指针的数组定义2.函数指针是指向函数的指针变量。 因而“函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上是大体一致的。函数指针有两个用途：调用函数和做函数的参数。3.函数指针的声明方法为：返回值类型( * 指针变量名) (形参列表);“返回值类型”说明函数的返回类型，“( * 指针变量名)”中的括号不能省，括号改变了运算符的优先级。若省略整体则成为一个函数说明，说明了一个返回的数据类型是指针的函数，后面的“形参列表”表示指针变量指向的函数所带的参数列表。例如：int func(int x); /* 声明一个函数 */int (*f) (int x); /* 声明一个函数指针 */f = func; /* 将func函数的首地址赋给指针f */或者使用下面的方法将函数地址赋给函数指针：f = &func;赋值时函数func不带括号，也不带参数，由于func代表函数的首地址，因此经过赋值以后，指针f就指向函数func(x)的代码的首地址。例子：

#include

int max(int x,int y){return (x>y? x:y);}int main(){ int (*ptr)(int, int); int a, b, c; ptr = max; scanf("%d%d", &a, &b); c = (*ptr)(a,b); printf("a=%d, b=%d, max=%d", a, b, c); return 0;}

如何调用指针函数

1.如果是返回值是指针
char* getname()
{
char* pname=new char[23]; //返回指针必须是函数释放后并未释放的内存空间，
cout<<"input your name:\n"; //一般返回两种情况，一是在函数中像该函数一样动态分配堆内存
cin.getline(pname,22); //二是返回指针指向参数中地址，如： int* max(int a,int b) { return &a; }
pname[22]='\0';
return pname;
}
int main()
{
char* name=getname();
cout<<"your name is: "<
<name<<endl;
delete []name; //记得动态释放分配内存

return 0;

}

2.参数是指针类型

常见的是通过指针或引用交换两个数的值

void swa(int* p1,int* p2)

{

int temp=*p1; *p1=*p2; *p2=temp;

}

int main()

{

int a=2,b=3;

swa(&a,&b); //传递地址

return 0;

}

附解：你可以把指针看做是一种复合类型，它之所以可以修改参数值，本质是因为

对指针解除引用*p形式是操作的参数所存数据内存空间，但如果它不解除引用，它

并不会修改参数的值：如

void swa(int* p1,int* p2) //函数意思是最初始在函数参数块中定义两个指针p1,p2，使

{ //p1指向a,p2指向b，下面函数体只是使指针指向地址改变，成了

//p1指向b，p2指向a。但并未对a,b内存空间操作，当函数调用结束后，指针p1,p2

//也释放了，所以并未起任何作用

int* temp;

temp=p1; p1=p2; p2=temp;

}

int main()

{

int a=2,b=3;

swa(&a,&b); //传递地址

cout<
<a<<" "<<b;
return 0;

}

这个函数并不会交换a,b的值
</a<
</name<<endl;

对象或指针怎么调用成员函数？

首先，类对象和对象指针其实就是对应的一段内存的首地址。
调用的成员函数的时候，比如成员函数为：void student::fun(int a);，这个fun有一个参数，但实际fun还有一个隐式参数，这个参数其实传递到函数进去的就是该类的对象或指针，它是该类保存数据的内存首址，当fun中改变成员变量的值时，就是改变这个传递过来的地址指针所指向的那块内存的数据，由此不同的对象所指向的内存不同，所以对象与对象之间互不打扰。

51单片机中，指针函数 在C语言程序 如何使用？

你调用函数的时候是需要给地址的啊，比如说你在主函数中调用子函数，给子函数传递一个地址参数，这个地址是在主函数中的，子函数执行完也不会释放空间，只有主函数执行完才会。
我们
给
单片机函数
起个名字
void
get5Bytes（char*
buf）
在调用get5Bytes时传入一个5字节的数组buf，这样就不用担心函数返回时内存被销毁啦
你好，比较方便的实现方式是在函数的外部申请数组；在调用函数的时候传入数组的地址进行操作。如果一定要在子函数内部申请空间并返回地址，那么需要在子函数内部动态申请内存空间。具体的方法一般是使用标准库中的malloc函数。对于c51函数库，参考这个链接：http://www.keil.com/support/man/docs/c51/c51_malloc.htm

求指针函数的使用！！

指针函数是指函数的返回值类型是一个指针类型, 1楼的好像说错了,慎重,看看我给的链接,希望对你有帮助,
指针函数你就看成为指针就可以了。
如void test(void);
指针函数他就可以定义为， typedef void (*Ttest)(void);
用的时候就可以：
Ttest pFunc = test;//或者为DLL的导出函数在强制Ttest转换一下就可以了。
1．函数指针定义
函数类型 （*指针变量名）(形参列表)；
“函数类型”说明函数的返回类型，由于“()”的优先级高于“*”,所以指针变量名外的括号必不可少，后面的“形参列表”表示指针变量指向的函数所带的参数列表。
例如：
int (*f)(int x);
double (*ptr)(double x);
在定义函数指针时请注意：

函数指针和它指向的函数的参数个数和类型都应该是—致的；
函数指针的类型和函数的返回值类型也必须是一致的。
2．函数指针的赋值
函数名和数组名一样代表了函数代码的首地址，因此在赋值时，直接将函数指针指向函数名就行了。
例如，
int func(int x); /* 声明一个函数 */
int (*f) (int x); /* 声明一个函数指针 */
f=func; /* 将func函数的首地址赋给指针f */
赋值时函数func不带括号，也不带参数，由于func代表函数的首地址，因此经过赋值以后，指针f就指向函数func(x)的代码的首地址。
3．通过函数指针调用函数
函数指针是通过函数名及有关参数进行调用的。
与其他指针变量相类似，如果指针变量pi是指向某整型变量i的指针，则*p等于它所指的变量i；如果pf是指向某浮点型变量f的指针，则*pf就等价于它所指的变量f。同样地，*f是指向函数func(x)的指针，则*f就代表它所指向的函数func。所以在执行了f=func;之后，(*f)和func代表同一函数。
由于函数指针指向存储区中的某个函数，因此可以通过函数指针调用相应的函数。现在我们就讨论如何用函数指针调用函数，它应执行下面三步：
首先，要说明函数指针变量。
例如：int (*f)(int x);
其次，要对函数指针变量赋值。
例如： f=func; (func(x)必须先要有定义)
最后，要用 (*指针变量)(参数表);调用函数。
例如： (*f)(x);(x必须先赋值)
【例】任意输入n个数，找出其中最大数，并且输出最大数值。
main()
{
int f();
int i，a，b;
int (*p)(); /* 定义函数指针 */
scanf("%d"，&a);
p=f; /* 给函数指针p赋值，使它指向函数f */
for(i＝1;i<9;i )
{
scanf("%d"，&b);
a＝(*p)(a，b); /* 通过指针p调用函数f */
}
printf("The Max Number is:%d"，a)
}
f(int x，int y)
{
int z;
z＝(x>y)?x:y;
return(z);
}
运行结果为：
343 -45 4389 4235 1 -534 988 555 789↙
The Max Number is：4389
【指针函数】
一个函数不仅可以带回一个整型数据的值，字符类型值和实型类型的值，还可以带回指针类型的数据，使其指向某个地址单元。
返回指针的函数，一般定义格式为：
类型标识符 *函数名(参数表)
int *f(x，y);
其中x，y是形式参数，f是函数名，调用后返回一个指向整型数据的地址指针。f(x，y)是函数，其值是指针。
如：char *ch();表示的就是一个返回字符型指针的函数，请看下面的例题：
【例】将字符串1(str1)复制到字符串2(str2)，并输出字符串2.
#include "stdio.h"
main()
{
char *ch(char *，char *);
char str1[]="I am glad to meet you!";
char str2[]="Welcom to study C!";
printf("%s"，ch(str1，str2));
}
char *ch(char *str1，char *str2)
{
int i;
char *p;
p=str2

if(*str2==NULL) exit(-1);
do
{
*str2=*str1;
str1 ;
str2 ;
}while(*str1!=NULL);
return(p);
}
通过分析可得
函数指针是一个指向函数的指针，而指针函数只是说明他是一个返回值为指针的函数，
函数指针可以用来指向一个函数。

派生类指针指向基类对象，如何调用其成员函数

　　用：pb->f(); 即可。
　　类A中有了虚函数就会再类的数据成员的最前面添加一个vfptr指针(void** vfptr)，这个指针用来指向一个vtable表（一个函数指针数组）（一个类只有一个该表），该表存储着当前类的所有 虚函数 的地址。这样vfptr就成为了一个类似成员变量的存在。访问虚函数的时候通过vfptr间址找到vtable表，再间址进而找到要调用的函数。这样就在一定程度上摆脱了类型制约。
　　只要vptr的值不同，那么访问函数成员的时候使用的vtable表就不同，就可能访问到不同类的函数成员。B类对象中的vptr指向B类自己的vtable。
　　当B类继承A类的时候，因为A中有虚函数，编译器就自动的给B类添加vfprt指针和vtable表。也可以理解为B类继承来了A类中的那个vptr指针成员。
　　当A类指针指向B类对象时，发生假切割。要知道这个过程只是切掉A类中没有的那些成员，由于vptr是从A类中继承来的，所以这个量仍将保留。而对于vptr的值则不会改变，仍然指向B类的vtable表。所以访问F1函数的时候是通过B类的vtable表去寻址的，自然就是使用子类的函数。
　　当B类的指针指向A类的对象时（当B类存在新增数据成员时可能出错），同理。
而对于普通函数则受类型的制约，（因为没有vptr指针）使用哪个类的指针调用函数，那么所调用的就是那个累的函数。
　　 总而言之，普通函数通过对象或指针的类型来找所调用的函数，而虚函数是通过一个指针来找到所要调用的函数的。