在Java中同类中的静态方法不可以调用类成员变量以及静态方法。

因为因为java中静态的东西是类级别的，也就是说用类名就可访问，也可以用任何对象名访问。

<?xml version="1.0" encoding="UTF-8"?>


1. 首先到官网下载

http://threadpool.sourceforge.net/

2. 包含头文件

#include "../boost/threadpool.hpp"



3. 声明threadpool对象， 

boost::threadpool::fifo_pool m_poolCmdProcess;

上面声明了一个FIFO线程池， 即先进先出

4. 声明一个Runnable适配类 来包装你的类及成员函数

                class Runnable
                {
                                typedef boost::function<void (/*CCommunicationMap*, */ICommandContextEx*)> function;

                private:
                                function _f;
                                CCommunicationMap* _target;
                                ICommandContextEx* _data;

                public:
                                template<class F>
                                Runnable(CCommunicationMap* target, F f, ICommandContextEx* data)
                                {
                                                _f = f;
                                                _target = target;
                                                _data = data;
                                }

                                ~Runnable(){}

                                void run()
                                {
                                                //_target->TestCommand(_data);
                                                _f(/*_target, */_data);
                                }
                };
  

上面 function 声明了一个函数模板， 此模板应该和你要关联的类成员函数类型一致。

5. 调用threadpool的schedule方法 启动线程



                               boost::function<void (/*CCommunicationMap*, */ICommandContextEx*)>     fun;
                                fun =  boost::bind(&CCommunicationMap::TestCommand, &m_communication, _1);

                                Runnable* run = new Runnable(&m_communication,  fun, pContext);

                                 boost::threadpool::schedule(m_poolCmdProcess, boost::shared_ptr<Runnable>(run));


注意： 
threadpool库中的pool_adaptors.hpp头文件有错误， 需要我们改动源码（注释的为原来代码，下面的为改动后的代码）， 具体为：
    template<typename Pool, typename Runnable>
    bool schedule(Pool& pool, shared_ptr<Runnable> const & obj)
    {          
                                //return pool->schedule(bind(&Runnable::run, obj));
                                return pool.schedule(bind(&Runnable::run, obj));
    }          

      在编写C++程序时，有时候我们想在一个类中调用另一个类中的成员变量或方法，比如：两个类 A和B ,A包含B,一般A中调用B中的方法比较简单，重点是子类B如何调用父类A中的成员变量或方法呢？
      如果你选择在A.h和B.h中互相包含头文件，那么肯定会报错，因为检测的时候会出现循环检测引用，所以这个方法是不可取的。
      正确的方式是：
      1、在A.h头文件中包含B.h
      2、在A.h头文件A类中声明一个B类的对象，可以是指针，也可以不是指针
      3、在B.h头文件中用extern声明类A，然后在类B中声明一个A类的指针对象（必须是指针型）
      4、在A.cpp和B.cpp中都只需要包含A.h，B.cpp不需要包含B.h
      5、然后在A.cpp和B.cpp中分别定义A类的对象和B类的对象
      6、将它们的指针分别传给对方的对象。如果是在不同的文件，也可以是this传值，比如在A.cpp中，给B.cpp中的A类对象传递A的当前对象，b->a=this;然后B类中的a就可以调用A类的成员方法了。
      7、最后就可以互相调用彼此的对象了。
注意：在头文件中最好使用#ifndef #define #endif  ,防止多重定义错误。
     上代码：
A.h      
#ifndef _A
#define _A
#include "B.h"//A的头文件导入了B的头文件

class A
{
public:
	int a;
	B* objectb;//A的头文件导入了B的头文件，在调用B的时候就可以不用指针，也可以用指针

public:
	A();
	int geta();
	void handle();
	void hello();
};

#endif _A


B.h


#ifndef _B
#define _B

extern class A;//注意1：需要用extern声明A

class B
{
public:
	int b;
	A* objecta;//注意2：调用A的时候需要用指针
public:
	B();
	int getb();
	void handle();
};

#endif _B


A.cpp


#include <iostream>
#include "A.h"
using namespace std;

A::A()
{
    this->a=100;
}

int A::geta()
{
    return a;
}
void A::hello(){
    this->a=500;
    printf("%d\n",a);
}

void A::handle()
{
    
    cout<<"in A , objectb.b="<<objectb->getb()<<endl;
}


B.cpp


#include <iostream>
#include "A.h"//注意3：在B.cpp里面导入A的头文件 ，而不是B的头文件

using namespace std;

B::B()
{
	this->b=200;
}

int B::getb()
{
	return b;
}

void B::handle()
{

	cout<<"in B , objecta->a="<<objecta->geta()<<endl;
}


main.cpp
#include <iostream>
#include <cstdlib>
#include "A.h"
using namespace std;

void main()
{
	A a;
	B b;

	a.objectb = &b;
	b.objecta = &a;
	
	a.hello();
	a.handle();

	b.handle();
	system("pause");
}


最后附上代码可以下载，我使用的vs2012。点击打开链接



有问题和建议希望留言提出或者发邮箱给我，虚心倾听学习！ 邮箱：1203782828@qq.com





    

     

成员方法中调用成员变量语法格式 :

…self .变量名

例:


成员方法中调用成员方法格式 :

…self . 方法名(实参1 , 实参2, …)

例 :


self : 仅出现在成员方法中 , 指代执行该方法的对象