C++ 如何在C+中检索与线程相关的对象实例+；？

在java中，我生成了以下代码：

public class B {
    public void exec(){
        X x = (X) Thread.currentThread();
        System.out.println(x.value);
    }
}

public class X extends Thread{
    public int value;

    public X(int x){
        value = x;
    }
    public void run(){
        B b = new B();
        b.exec();
    }
}

new X(4).start();

方法的作用是：检索与当前线程（也是类X的实例）对应的字段值

有没有一种方法可以模拟C++中的相同行为？注意：我不想将x作为参数传递给B实例，因为代码是生成的

class B {
public:
    void exec();
};

class X {
public:
    int value;
    X(int x) {
        value = x;
    }
    void run() {
        B * b = new B();
        b->exec();
    }    
};

void B::exec() {
    std::cout << ??? << std::endl;
}

int main() {
    X * x = new X(3);
    boost::thread thr(boost::bind(&X::run, x));
    thr.join();
}

B类{
公众：
void exec（）；
};
X类{
公众：
int值；
X（int X）{
值=x；
}
无效运行（）{
B*B=新的B（）；
b->exec（）；
}    
};
void B:：exec（）{
std：：cout确实，您不能（或不应该）子类
boost：：thread
。不过，您可以使用它来放置自己的特定于线程的东西

可以说，您应该对Java代码使用相同的技术。Java为此目的提供了一种方法。
确实，您不能（或不应该）子类
boost:：thread
。不过，您可以使用它来放置自己的特定于线程的东西

可以论证的是，您应该对Java代码使用相同的技术。Java已经为此目的使用了。
如果您不想将参数传递给B（这将是最干净的解决方案），您可以使用线程本地存储

一般来说，看看你的代码，你可能会尝试从java到C++的严格的1-to-1映射。
<>在C++中，你几乎不应该调用<代码>新< /C>。尽可能在堆栈上分配。<代码>新< /Cord>在C++中明显容易出错（没有垃圾收集），但它也与java等的管理语言相比非常慢。
函子可以用作函数指针的更强大的替代品（例如，在创建线程时），或者只是用来替换泛型的
exec（）
或
run（）
函数。将它们命名为
operator（）
，然后该类可以用作函子

在构造函数中，您应该尽可能多地使用初始值设定项列表

下面将上述建议应用于您的代码。当然，我向B构造函数传递了一个参数。如果这不是一个选项，请改用

如果不想将参数传递给B（这将是最干净的解决方案），可以使用线程本地存储

一般来说，看看你的代码，你可能会尝试从java到C++的严格的1-to-1映射。
<>在C++中，你几乎不应该调用<代码>新< /C>。尽可能在堆栈上分配。<代码>新< /Cord>在C++中明显容易出错（没有垃圾收集），但它也与java等的管理语言相比非常慢。
函子可以用作函数指针的更强大的替代品（例如，在创建线程时），或者只是用来替换泛型的
exec（）
或
run（）
函数。将它们命名为
operator（）
，然后该类可以用作函子

在构造函数中，您应该尽可能多地使用初始值设定项列表

下面将上述建议应用于您的代码。当然，我向B构造函数传递了一个参数。如果这不是一个选项，请改用

class B {
public:
    explicit B(int value) : value(value)
    void operator()();

private:
    int value;
};

class X {
public:
    int value;
    X(int x) :value(x) { }// use the initializer list to initialize members

    void operator()() {
        B b(value); // allocate B on the stack if possible
        b();
    }    
};

void B::operator()() {
    std::cout << value << std::endl;
}

int main() {
    boost::thread thr(X(3));
    thr.join();
}

class B {
public:
    explicit B(int value) : value(value)
    void operator()();

private:
    int value;
};

void B::operator()() {
    std::cout << value << std::endl;
}

int main() {
    boost::thread thr(B(3));
    thr.join();
}