c++ typedef 函数指针（c++中的函数引用与指针的区别）
本文目录
- c++中的函数引用与指针的区别
- C++函数指针和空指针的问题
- c++ 静态成员函数返回对象指针
- c++怎么定义API函数指针
- C++语言中，指针的英文单词是什么
- C++里面如何typedef一个类的函数引用
- c/C++指针函数问题P=P->next
- c++里怎么把类中的函数的指针传递给另一个类
- C++类成员函数如何赋值给函数指针
c++中的函数引用与指针的区别
#include 《stdio.h》
void F(int a, int b){printf("hello %d %d\n", a, b);};
typedef void (&pF)(int, int);
int main()
{
int a = 1, b = 3;
pF x = F;
x(a, b);
printf("0x%X 0x%X", F, x);
}
全局变量是被存储在内存中的全局静态区的, 全局变量的声明总是定义, 因为编译器会将他们的值初始化为其默认值, 可以在全局范围内定义变量, 但不能在全局范围内实施操作, 因为操作是在函数中实现的, 你要分清初始化和赋值的不同, 所以比如有一个全局变量a;
int a; // 等价于int a(int());
则以下对a的操作都是违法的:
++a;
a--;
a += 1;
....
程序是由函数构建的, 而不是文件构建的, 所以以上操作根本执行不到, 所以编译不同过, 而且C/C++编译器貌似只识别全局范围内变量的声明定义, 所以在你试图global = 10的时候它认为你要创建一个不带类型标识符的变量global, 所以给你一个错误; 另外它又发现你企图声明的这个变量与已存在的变量名有冲突, 所以它又给你一个错误...
C++函数指针和空指针的问题
函数int plus(int b)的指针类型原型为：int (*)(int)
其中左侧int指定函数返回类型，右侧(int)表示函数的参数类型。指针类型定义中，凡是右侧有括号的都表示是个函数指针，而括号内可以定义0个或多个参数，以逗号分隔。中间的(*)把星号独立起来表示是个指针定义。
当要直接定义一个函数指针时将变量名放星号后面，比如这样：
int (*p)(int) =NULL;
双参数定义：int (*p)(int,int) =NULL;
图例中由于pV是个虚指针（万能指针），可以赋值任意类型的地址，因此pV=Plus不会报错，但访问时必须强转，否则编译器不知道如何访问指针（强转就是将指定类型放在变量左侧，比如(int)a就是将a的值强转为int类型），强转格式：(类型) 变量 ,那么外面要套一层括号：(int (*)(int))pV，我们需要用强转后的函数指针传递参数进行函数调用，为避免歧义，因此需要连同变量名再打包一次：((int (*)(int))pV)，随后再传递参数10：
((int (*)(int))pV)(10)
括号打包的内容可以看作一个整体/对象，你迷惑的主要因素应该有两点：
1、不知道如何定义函数指针类型。
实际上就是将函数定义中的函数名用（*）替换，再将参数名去掉就可以了，比如下面这个函数
int * Fun(int a,char c){。。。。。。}
其函数指针类型为： int * (*)(int,char)
指针定义：int* (*p)(int, char);
2、括号嵌套多了看起来比较乱。这个很简单，一层一层拆解一层层理解。
c++ 静态成员函数返回对象指针
首先 函数指针是指向一组同类型的函数的指针；而类成员函数我们也可以相似的认为，它是指向同类中同一组类型的成员函数的指针，当然这里的成员函数更准确的讲应该是指非静态的成员函数。前者是直接指向函数地址的，而后者我们从字面上也可以知道 它肯定是跟类和对象有着关系的。
函数指针实例：
代码如下:
typedef int (*p)(int,int);//定义一个接受两个int型且返回int型变量的函数指针类型
int func(int x,int y)
{
printf("func:x=%d,y=%d/n",x,y);
return (x《y?x:y);
}
int main()
{
p fun=func;//定义函数指针并给它赋上一个函数指针
cout《《"min:"《《(*fun)(4,5)《《endl;//为什么*fun需要用()扩起来呢?因为*的运算符优先级比()低,如果不用()就成了*(fun())
return 0;
}
而“指向类成员函数的指针”却多了一个类的区别：
class A
{
public:
int func(int x,int y)
{
printf("A::func:x=%d,y=%d/n",x,y);
return (x《y?x:y);
}
};
typedef int (A::*p)(int,int);//指针名前一定要加上所属类型类名 A::的限定
int main()
{
p fun=&A::func;
A a; //因为成员函数地址的解引用必须要附驻与某个对象的地址，所以我们必须创建某个对象。
cout《《"min:"《《(a.*fun)(4,5)《《endl;
return 0;
}
嘿嘿。。只是用起来 .* 感觉怪怪滴。
接下来 我们可以再扩展一下下：
代码如下:
#include 《tchar.h》
#include 《iostream》
#include 《stdio.h》
using namespace std;
class A
{
public:
int func1(int x,int y)
{
printf("A::func:x=%d,y=%d/n",x,y);
return (x《y?x:y);
}
virtual int func2(int x,int y)
{
printf("A::func:x=%d,y=%d/n",x,y);
return (x》y?x:y);
}
};
class B:public A
{
public:
virtual int func2(int x,int y)
{
printf("B::func:x=%d,y=%d/n",x,y);
return (x+y);
}
};
typedef int (A::*p)(int,int);//指针名前一定要加上所属类型类名 A::的限定
typedef int (B::*p0)(int,int);
int main()
{
A a; //因为成员函数地址的解引用必须要附驻与某个对象的地址，所以我们必须创建某个对象。
p fun=&A::func1;
cout《《(a.*fun)(4,5)《《endl;
cout《《(b.*fun)(4,5)《《endl《《endl;
fun=&A::func2;
cout《《(a.*fun)(4,5)《《endl;//请注意这里调用的是虚函数，嘿嘿 还真神奇 类成员函数指针也支持多态。
cout《《(b.*fun)(4,5)《《endl《《endl;
//fun=&B::func2; //这样式错误滴，因为不存在派生类的"指向类成员函数的指针"到基类的"指向类成员函数的指针"的隐式转换
fun=(int (A::*)(int,int))&B::func2;//应该进行强制转换
cout《《(a.*fun)(4,5)《《endl;
cout《《(b.*fun)(4,5)《《endl《《endl;
p0 fun0=&B::func2;
cout《《(a.*fun)(4,5)《《endl;
cout《《(b.*fun)(4,5)《《endl《《endl;
fun0=&A::func2; //正确，因为这里进行了隐式转换
cout《《(a.*fun)(4,5)《《endl;
cout《《(b.*fun)(4,5)《《endl《《endl;
//从上面我们不难发现 指向类成员函数的指针基类和派生类的关系和指向类对象的指针基类和派生类的关系完全相反，
//基类成员函数的布局被认为是派生类成员函数布局的一个子集
return 0;
}
接下 是有关模板类的类成员函数指针的使用
实例如下：
代码如下:
#include 《tchar.h》
#include 《iostream》
#include 《stdio.h》
using namespace std;
class A
{
public:
int func(int x,int y)
{
printf("A::func : x=%d,y=%d/n",x,y);
return (x《y?x:y);
}
};
class B
{
public:
int func(int x,int y)
{
printf("B::func : x=%d,y=%d/n",x,y);
return (x》y?x:y);
}
};
template《class T》
class C
{
public:
T c;
void Print()
{
int (T::*p)(int,int)=&T::func;
(c.*p)(4,5);
}
};
int main()
{
C《A》 ca;
C《B》 cb;
ca.Print();
cb.Print();
return 0;
}
从上面 可以很清晰地看到。。其实它和普通的模板没有什么区别。。只不过将限定名称该为参数名酒OK啦。。。
c++怎么定义API函数指针
第一处，你需要一个强制类型转换，最好用typedef，这样更轻松。
typedef int (WINAPI(如果有修饰的话，写这里) *PROCTYPE)(int n,int b,int c);
PROCTYPE clGetPlatformIDs = (PROCTYPE)GetProcAddress(lib,"clGetPlatformIDs");
这样就可以过去了。
后面的是因为err的首字母大小写吧。
第三个是因为num参数类型不符，你声明的时候是int，调用时候传#，是int *。
恩就这样
C++语言中，指针的英文单词是什么
指针英文单词是Pointer item不是缩写，就是item，项目的意思。操作方法如下：
1、函数指针的声明：typedef void (*p)(c***t char *name)：void (*p2)(c***t char *name)：这两种定义方式都是可以的。
2、函数指针的使用，如下图所示。
3、函数指针的overloading（重载），如下图所示。
4、c++11对函数指针写法的简化，c++让人头疼的就是写法多样化，一个意思可以有n多种写法。
5、最后返回函数指针，如下图所示，就完成了。
C++里面如何typedef一个类的函数引用
无法定义，因为定义后无法使用。使用成员函数指针的方法是运算符.*，例如：
class A {
public:
int f();
};
int (*A::fn)() = &A::f;
A a;
a.*fn(); //在这里调用成员函数指针
而如果是引用则无法分辨正常的成员搜索和通过引用调用，所以无法定义类A的函数引用。你无法定义任何类成员引用，只能定义成员指针。
c/C++指针函数问题P=P->next
按照你的说法其实是有问题的，（1）w指向地址A指针，w-》next指向地址B；说明w是指针变量，A，B可能是结构体变量；（2）将w地址赋给空指针P，这句话说明P是指针的指针
（3）则P-》next指向地址B；以及P=P-》next；这两条代码却又只能判断P是指针而并非是指针的指针 其中（2）（3）两条矛盾了！
如果w P都是指针变量，按你说的可能是指向结构体变量的指针吧
看看下面程序代码：
#include 《stdio.h》
#include 《stdlib.h》
typedef struct LNode
{
struct LNode *next;
}Lnode;
int main()
{
Lnode *w,*P,A,B,C;
A.next=&B
B.next=&C
C.next=NULL;
w=&A
P=w;
P=P-》next;
printf("A的地址是%d\n",&A);
printf("B的地址是%d\n",&B);
printf("C的地址是%d\n",&C);
printf("A的内容是%d\n",A);
printf("B的内容是%d\n",B);
printf("C的内容是%d\n",C);
printf("A.next的内容是%d\n",A.next);
printf("B.next的内容是%d\n",B.next);
printf("C.next的内容是%d\n",C.next);
printf("w的内容是%d\n",w);
printf("p的内容是%d\n",P);
return 0;
}
应该没有问题啊？可能是你的表达有问题，最好把代码发上来！
c++里怎么把类中的函数的指针传递给另一个类
1、成员函数指针还需要类实例对象来参与调用，而不是仅仅一个函数指针就可以调用。因此成员函数指针和全局函数指针是不兼容的：
typedef void (T::*B)(int x, int y, int z);
B b = &T::foo;
T t;
t.*b(x, y, z); // 必须指定t
2、通过context传入到你最终的回调函数里面。
void fun(A a, B b, C c, void* context)
{
T* t = reinterpret_cast《T*》(context);
t-》*b(x, y, z);
}
T t;
B b = &T::foo;
fun(a, b, c, &t);
C++类成员函数如何赋值给函数指针
完善了一下。
#include《iostream》
using namespace std;
class Ca{
public:
int max(int a,int b)
{
return a》b?a:b;
}
};
int (Ca::*p)(int,int);
int main()
{
p=&Ca::max;
Ca a;
cout《《(a.*p)(2,3);
system("pause");
return 0;
}
