回调函数

特殊函数(const static callback)

/*************************************************************/
//const 函数
/*为了给常对象使用的成员函数
常对象实际上是只能对类中的常成员进行访问,为了防止常对象通过调用普通的成员函数对成员变量修改，才制定常函数*/
class CMyClass1{
public:
	CMyClass1()
	{
	
	}
	~CMyClass1()
	{
	
	}
    void Sub_1() const
    {
        
    }
     void Sub_2() 
    {
        m_1=10;
    }
    static void Sub_3()
    {
        
    }
public:
    int m_1;

}
/*************************************************************/
//static 函数(如果要访问类中的非静态成员必须要进行类对象指针传参)
/*
  1)静态成员函数是为了访问私有静态成员变量，不允许使用类对象进行访问
  2)静态变量是为了解决对象间的数据共享和通信
  若构造函数是私有的 ，普通成员对象难以定义
  1.构造函数没有返回值
  2.类名字与函数名字一致
  3.构造函数可以为私有
  构造函数私有属性利用静态成员进行对象申请
  3)callback通常使用静态成员函数作为接口实现
*/
class CMyClass2{
public:
	CMyClass2()
	{
	 _tprintf(_T("%d\r\n"));
    }
	~CMyClass2()
	{
	
	}
    static void _Sub_1()
    {
        _m_1=10;
        _tprintf(_T("%d\r\n"),_m_1);
    }
      static CMyClass2*MyClass2 _Sub_2() //构造函数为私有
    {
       CMyClass2* MyClass2=new CMyClass2;
        return;
    }
private:
   static int _m_1;  //是为了解决类之间的数据共享 具有读写属性
    int m_2;

}

int CMyClass1::_m_1=0;  //静态成员要进行初始化

void Sub_2();

int _tmain()
{
	const CMyClass1 Object;
    int v1=Object.m_1;
    Object.m_1=10; //error
    Object.Sub_2(); //error
    Object.Sub_1();//Right
    
    Sub_2();
  LPFN_SUB_3 f1;
   f1(10);
}
void Sub_2()
{
   CMyClass2::Sub_1(); //前提静态成员变量为私有的
  // CMyClass2 Object;
    CMyclass2 ::_m_1; //若为公有可以直接作用域访问
    
    CMyClass2*Object=CMyClass2::_Sub_2();
    delete 
   
}

/*************************************************************/
//callback 函数  (回调函数) 

//函数指针
//静态成员函数作为回调函数使用
class CMyClass3
{
public:
	CMyClass3()   
	{
		m_2 = 911;
	}
public:
	~CMyClass3()
	{
	}
public:
	static int _Callback(CMyClass3* MyClass3)    //如果回调被设计为静态成员函数 静态成员函数是不能访问类中的成员函数与成员变量
	{
		_tprintf(_T("_Callback()\r\n"));
		MyClass3->InsertData();//如果要访问类中的非静态成员必须要进行类对象指针传参
		return MyClass3->m_2;
	}
	void Callback()        //如果回调被设计为普通成员函数
	{
		_tprintf(_T("Callback()\r\n"));
		InsertData();
	}
	void InsertData()
	{
		_tprintf(_T("InsertData()\r\n"));
	}
	void DeleteData()
	{

	}
private:
	static int _m_1;       
	int m_2;


};

 //窗口
class CMyClass4   
{
public:
	CMyClass4()
	{
		
	}
public:
	~CMyClass4()
	{
	}
	void Sub_1(int (*_Callback)(CMyClass3* MyClass3), CMyClass3* MyClass3)
	{
		_tprintf(_T("%d\r\n"), _Callback(MyClass3));
		//通过静态成员函数访问它所属类的成员变量
	}
	void Sub_2(void (CMyClass3::*Callback)(), CMyClass3* MyClass3)
	{
		MyClass3->Callback();
	}
private:

};

//函数申明
typedef void (*LPFN_SUB_3)(int ParameterData); //定义一个数据类型
void Sub_3(int ParameterData2);
void Sub_4(LPSN_SUB_3 ParammeterData1,int ParameterData2);

//主函数入口
int _tmain()
{
  LPFN_SUB_3 f1=Sub_3;//通过某种方法获得了Sub_3
   Sub_4(f1);
   Sub_5();
   return 0;
}

//函数名本质上就是指针 函数指针
void Sub_3(int ParameterData)  
{
    _tprintf(_T("Sub_3()\r\n"));
  //如何定义一个函数指针(函数的返回值、函数的参数列表、函数的调用约定)	    
}

 //Sub_3中的参数也必须放入Sub_4中   
 void Sub_4(LPSN_SUB_3 ParammeterData1,int ParameterData2)
 {
     ParameterData1(ParameterData2);
 }

void Sub_5()
{
    CMyClass3 Object3;
    CMyClass4 Object4;
    Object4.Sub_1(CMyClass3::_Callback,&Object3);
    Object4.Sub_2(&CMyClass3::Callback(),&Object3);  //记住就行
}

小结：静态成员出现必须在初始化列表中初始化

静态成员函数的作用：

1.访问静态成员

2.实现类之间数据的共享

3.作为callback的接口，但必须传入对象指针访问成员变量