类成员变量与函数指针

类成员变量与函数指针

 

这几天用到类中的指针，作个笔记，以免忘记。

 

测试代码：

 

// OffSetOf.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#define OFFSET(s, m) \
 ((size_t)&((s*)0)->m)

typedef struct _Test
{
 char a;
 double b;
 int c;
}TEST;

class TEST_T
{
public:
 int MAX(int one, int two)
 {
  return (one >= two)?one:two;
 }

 virtual int MIN(int one, int two)
 {
  return (one < two)?one:two;
 }

 static int add(int one, int two)
 {
  return (one + two);
 }

 int obj;     //公共成员
 static int obj_static;

private:
 int obj_private;   //私有成员
};

int TEST_T::obj_static = 10;

int _tmain(int argc, _TCHAR* argv[])
{
 /*offset测试*/
 printf("\n变量a的偏移为：%d", OFFSET(TEST, a));
 printf("\n变量b的偏移为：%d", OFFSET(TEST, b));
 printf("\n变量c的偏移为：%d", OFFSET(TEST, c));

 /*类的函数指针测试*/

 //1. 类中普通对象指针的使用
 typedef int *pObj;               //声明类成员变量的指针类型

 TEST_T test_obj;

 pObj pTest_Obj = &test_obj.obj;  //将成员变量的地址付给指针pTest_Obj

 *pTest_Obj = 10;

 printf("\n\n*pTest_Obj = %d", *pTest_Obj);

 //2. 类中static对象指针的使用
 pObj pTest_Static = &TEST_T::obj_static;   //静态成员属于类而不是对象，所以用::的方式去取得对象

 *pTest_Static = 100;

 printf("\n\n*pTest_Static = %d", *pTest_Static);

 //3. 类中的静态函数指针的测试
 typedef int (*pStatic)(int, int);

 TEST_T test_static;

 pStatic pAdd1 = test_static.add;
 pStatic pAdd2 = TEST_T::add;

 printf("\n\npAdd1(10, 10) =  %d", pAdd1(10, 10));
 printf("\npAdd2(10, 10) =  %d", pAdd2(10, 20)); //可以看出，和普通的使用方式也一样

 //4. 类中的普通成员指针的测试
 typedef int (TEST_T::*pMAX)(int, int);  //声明类成员函数的指针类型

 TEST_T test_normal;

 pMAX pNormalMAX = &TEST_T::MAX;  //声明成员函数指针变量并 初始化

 //pMAX pNormalMAX2 = test_normal.MAX;  //错误的使用方式
 //pMAX pNormalMAX3 = &test_normal.MAX; //错误的使用方式
 //pMAX pNormalMAX4 = TEST_T::MAX;      //错误的使用方式

 pMAX pVirtualMIN = &TEST_T::MIN;  //声明成员函数指针变量并 初始化

 //pMAX pVirtualMIN2 = test_normal.MIN;   //错误的使用方式
 //pMAX pVirtualMIN3 = &test_normal.MIN;  //错误的使用方式
 //pMAX pVirtualMIN4 = TEST_T::MIN;       //错误的使用方式

 //pMAX pStaticADD = TEST_T::add;  //错误的使用方式，静态函数属于全局函数，应该使用普通作用域的函数指针

 //printf("\npNormalMAX(10, 40) =  %d", pNormalMAX(10, 40));  //错误的使用方式
 //printf("\npVirtualMIN(10, 20) =  %d", pVirtualMIN(10, 20));//错误的使用方式
 //printf("\npStaticADD(10, 20) =  %d", pStaticADD(10, 20));  //错误的使用方式

 printf("\n\n(test_normal.*pNormalMAX)(10, 40) =  %d", (test_normal.*pNormalMAX)(10, 40));  //正确的使用方式[使用对象和成员函数指针调用成员函数]
 printf("\n(test_normal.*pVirtualMIN)(10, 20) =  %d", (test_normal.*pVirtualMIN)(10, 20));//正确的使用方式

 //5. 使用指针
 TEST_T *pTest_normal = &test_normal;
 printf("\n\n(pTest_normal->*pNormalMAX)(10, 40) =  %d", (pTest_normal->*pNormalMAX)(10, 40));  //正确的使用方式[使用对象和成员函数指针调用成员函数]
 printf("\n(pTest_normal->*pVirtualMIN)(10, 20) =  %d", (pTest_normal->*pVirtualMIN)(10, 20));//正确的使用方式

 /*总结：
   在类中的静态成员函数指针和类成员变量的指针，和普通的全局函数和普通对象指针的使用方式一样。
   在类中的非静态成员函数，只能使用[&Class_Name::Function_Name，即&类名::函数名]的方式去取的其函数地址，
   因为函数是属于类，而不是某个对象，所以不能用[对象名.函数名]的方式去取的其函数地址。
    */
 getchar();

 return 0;
}

 运行结果截图：