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啦。。。
嘿嘿。。。

赞 (0)

相关推荐

  • 浅谈C++ 基类指针和子类指针的相互赋值

    浅谈C++ 基类指针和子类指针的相互赋值

    首先,给出基类animal和子类fish //============================================================== // animal.h // // author : zwq // describe: 非虚函数情况下,将子类指针赋给积累指针,验证最终调用 // 基类函数还是子类函数. //============================================================== #ifndef ANIMA

  • 实例解析C++中类的成员函数指针

    C语言的指针相当的灵活方便,但也相当容易出错.许多C语言初学者,甚至C语言老鸟都很容易栽倒在C语言的指针下.但不可否认的是,指针在C语言中的位置极其重要,也许可以偏激一点的来说:没有指针的C程序不是真正的C程序. 然而C++的指针却常常给我一种束手束脚的感觉.C++比C语言有更严格的静态类型,更加强调类型安全,强调编译时检查.因此,对于C语言中最容易错用的指针,更是不能放过:C++的指针被分成数据指针,数据成员指针,函数指针,成员函数指针,而且不能随便相互转换.而且这些指针的声明格式都不一样:

  • C++中指针的数据类型和运算相关知识小结

    C++中指针的数据类型和运算相关知识小结

    C++有关指针的数据类型和指针运算的小结 前面已用过一些指针运算(如p++,p+i等),现在把全部的指针运算列出如下. 1) 指针变量加/减 一个整数 例如:p++,p--,p+i,p-i,p+-i,p-=i等. C++规定,一个指针变量加/减一个整数是将该指针变量的原值(是一个地址)和它指向的变量所占用的内存单元字节数相加或相减.如p+i代表这样的地址计算:p+i*d,d为p所指向的变量单元所占用的字节数.这样才能保证p+i指向p下面的第i个元素. 2) 指针变量赋值 将一个变量地址赋给一个指

  • C++ 基类指针和子类指针相互赋值的实现方法

    C++ 基类指针和子类指针相互赋值的实现方法

    首先,给出基类animal和子类fish //============================================================== // animal.h // // author : zwq // describe: 非虚函数情况下,将子类指针赋给积累指针,验证最终调用 // 基类函数还是子类函数. //============================================================== #ifndef ANIMA

  • C/C++静态类和this指针详解及实例代码

     C/C++静态类和this指针详解 1.静态类 C++的静态成员不仅可以通过对象来访问,还可以直接通过类名来访问. class CBook{ public: static double price;//需要通过类外来进行初始化 } int main(void){ CBook book; book.price;//通过对象来访问 CBook::price//通过类名来访问 return 0; } 静态成员变量 对应静态成员有以下几点需要注意: (1)静态数据成员可以是当前类的类型,而其他数据成员

  • C++带有指针成员的类处理方式详解

    C++带有指针成员的类处理方式详解

    在一个类中,如果类没有指针成员,一切方便,因为默认合成的析构函数会自动处理所有的内存.但是如果一个类带了指针成员,那么需要我们自己来写一个析构函数来管理内存.在<<c++ primer>> 中写到,如果一个类需要我们自己写析构函数,那么这个类,也会需要我们自己写拷贝构造函数和拷贝赋值函数. 析构函数: 我们这里定义一个类HasPtr,这个类中包含一个int 类型的指针.然后定义一个析构函数,这个函数打印一句话. HasPtr.h 类的头文件 #pragma once #ifndef

  • C++获取类的成员函数的函数指针详解及实例代码

    C++获取类的成员函数的函数指针详解 用一个实际代码来说明. class A { public: staticvoid staticmember(){cout<<"static"<<endl;} //static member void nonstatic(){cout<<"nonstatic"<<endl;} //nonstatic member virtualvoid virtualmember(){cout<

  • C++指向类成员函数的指针详细解析

    首先 函数指针是指向一组同类型的函数的指针:而类成员函数我们也可以相似的认为,它是指向同类中同一组类型的成员函数的指针,当然这里的成员函数更准确的讲应该是指非静态的成员函数.前者是直接指向函数地址的,而后者我们从字面上也可以知道 它肯定是跟类和对象有着关系的. 函数指针实例: 复制代码 代码如下: typedef int (*p)(int,int);//定义一个接受两个int型且返回int型变量的函数指针类型int func(int x,int y){ printf("func:x=%d,y=%

  • 指向类成员函数的指针其实并非指针

    1.与常规指针不同,一个指向成员的指针并不指向一个具体的内存位置,它指向的是一个类的特定成员,而不是指向特定对象里的特定成员.通常最清晰的做法,是将指向数据成员的指针看作为一个偏移量. 这个偏移量告诉你,一个特定成员的位置距离对象的起点有多少个字节. 2.给定一个成员在类内的偏移量,为了访问位于那个偏移量的数据成员,我们需要该类的一个对象的地址.这时候就需要 .*和->*的操作.pC->*pimC,请求将pC内的地址加上pimC内的偏移量,为的是访问pC所指向的C对象中适当的数据成员.aC.*

  • C++指向函数的指针实例解析

    通常来说C++函数指针是指指向函数的指针,而非指向对象的指针.就像其他指针一样,函数指针也指向某个特定的类型.函数类型由其返回类型以及形参表确定,而与函数名无关. 定义: char (*fP)(char,int); 赋值: char function(char i,int j) { } fp=function; 调用 (*fp)(10,100); type char (*FUN)(char,int);//类型定义 FUN fp ;//定义fp为指向函数的指针 volatile的用法和作用: co

  • 函数外初始化与函数内初始化详细解析

    关于函数外初始化与函数内初始化之前一直分的不是太清,也不太在意.昨天终于出现了这方面的问题,所以决定好好看下,以下是这次的一些收获,先看测试代码: 复制代码 代码如下: #include "stdafx.h"#include <iostream>using namespace std;bool FillStr(char *&szDst, int nSize){ bool bRet = false; if (nSize > 0) {  szDst = (char

  • C++ 在堆上开辟与释放二维、三维指针详细解析

    学习C++新手通常会对指针的使用比较头疼,其实指针的概念很简单,只要能悟清楚这样一个简单的道理就能对指针有一定的认识了: 例如 int *a = new int[10]; 一维指针其实就相当于一维数组,不用去看书上所说的数组在内存中的首地址这些晦涩的话,以此类推 二维指针就相当于二维数组,新手对一维数组的开辟与释放比较容易熟悉,例如上面的a 释放就是 delete []a; a = NULL; 注意a = NULL; 必须要加上,这样是为了避免这个指针会变成"野指针".写程序时一定要注

  • jquery中常用的函数和属性详细解析

    Dom:Attribute:属性$("p").addClass(css中定义的样式类型); 给某个元素添加样式$("img").attr({src:"test.jpg",title:"test Image"}); 给某个元素添加属性/值,参数是map$("input").attr({"checked", "checked"}); $("img").

  • 指向变量的常指针与指向常变量的指针详细解析

    指向变量的常指针与指向常变量的指针详细解析

    常(量)指针常指针就是我们说的指向常量的指针,顾名思义,它是用来指向常量的. 用常指针指向常变量实际上,C++规定只能用指向常变量的指针指向常变量,普通指针指向它就会报错,原因也很容易理解,我们用普通指针指向常变量之后,有可能就会进行改变常变量数值的操作,这样做是不被允许的. 常指针的定义方法: 复制代码 代码如下: const 类型名  * 常指针名; 下面是它的一个简单的使用示例:程序1.1.1 复制代码 代码如下: #include<iostream>using namespace st

  • C语言基础函数用法示例详细解析

    C语言基础函数用法示例详细解析

    目录 函数 函数定义 函数一般格式 C语言函数分类 库函数 库函数的分类 库函数的学习 自定义函数 函数的参数 实际参数 形式参数 函数的调用 传值调用 传址调用 无参函数调用 函数的声明和定义 函数的声明 函数的定义 函数声明与定义的区别 exit与return介绍 函数 函数定义 百度百科对函数的定义:子程序 在计算机科学中,子程序是一个大型程序中的某部分代码,有一个或者多个语句块组成,它负责完成某项特定的任务,而且相比于其他的代码,具备相对的独立性. 一般来说会有输入参数和返回值,提供对过

  • C字符串操作函数的实现详细解析

    1. strlen(),计算字符串长度   int strlen(const char string) { int i=0; while(string[i]) i++; return i; } 2. strcpy(), 字符串拷贝. char *strcpy(char *destination, const char *source) { while(*destinaton++=*source++); return (destination-1); } 3. strcat(), 字符串的连接.

  • C++ 指向类成员的指针

    前面曾写过一篇恼人的函数指针(一),总结了普通函数指针的声明.定义以及调用,还有函数指针数组,函数指针用作返回值等.但是作为C++的研读,我发现我漏掉了一个最重要的内容,就是指向类成员的指针,这里将做相应补充(相关代码测试环境为vs 2010). 指向类成员的指针总的来讲可以分为两大类四小类(指向数据成员还是成员函数,指向普通成员还是静态成员),下面一一做介绍: 一.指向类的普通成员的指针(非静态) 1.指向类成员函数的指针 简单的讲,指向类成员函数的指针与普通函数指针的区别在于,前者不仅要匹配

随机推荐