Question

这是一堂课：

#include <thread>
#include <vector>

class A {
  private:
    void render(int, std::vector<std::vector<int>>&) {
        //do stuff
    };

    void renderSegment() {
        int var1 = 1;
        std::vector<std::vector<int>> var2;

        std::thread t(????);
        t.join();
    };
};

以下是一些尝试：

std::thread t([this, var1, &var2] {renderSegment(var1, var2);});
std::thread t(renderSegment, var1, std::ref(var2));
std::thread t(&A::renderSegment, var1, std::ref(var2));
std::thread t(&renderSegment, this, var1, std::ref(var2));

我想在函数render(var1, var2)中调用renderSegment()。我看过几个这样的问题

Start thread with member function

还有这个

C++11 multithreading with class member function

但似乎没有任何效果。即使看起来正常，编译器也会告诉我，我正在尝试引用已删除的函数std::thread::thread(const std::thread &)。

我正在使用C ++ 17和MVSC，这是好是坏。我没有启用任何特殊标志，但是我找不到在程序本身中显式启用多线程的任何标志（多线程编译有一个）。

我如何使其工作？

编辑：这是更长的代码，但实际是这样的：

Renderer.h

#include <glm/vec2.hpp>
#include <glm/vec3.hpp>

#include <complex>
#include <map>
#include <vector>

class State;

class Renderer {
public:
    void renderScene();
    Renderer(State& state);

private:
    State& m_state;

    void renderMandelbrot(int power);
    double mandelbrot(std::complex<double> c, int power);
    void renderSegment(
        int segmentStart,
        int segmentSize,
        int power,
        std::vector<std::vector<glm::vec3>>& colours);
};

Renderer.cpp

#include "Renderer.h"

#include "State.h"

#include <algorithm>
#include <thread>
#include <time.h>

void Renderer::renderScene() {
    renderMandelbrot(m_state.m_power);
}

Renderer::Renderer(State& state) :
    m_state(state) {

    std::srand(time(NULL));
    m_state.m_threadCount = std::thread::hardware_concurrency();
}

void Renderer::renderMandelbrot(int power) {
    std::vector<std::vector<glm::vec3>> colours;
    colours.resize(m_state.m_height);
    for (int i = 0; i < m_state.m_height; ++i) {
        colours[i].resize(m_state.m_width);
    }

    int segmentSize = m_state.m_height / m_state.m_threadCount;
    int segmentStart = 0;

    std::vector<std::thread> threads;

    for (int k = 0; k < m_state.m_threadCount - 1; ++k, segmentStart += segmentSize) {
        std::thread t = std::thread(&Renderer::renderMandelbrot, this,
            segmentStart,
            segmentStart + segmentSize,
            power,
            std::ref(colours));
        threads.push_back(t);
    }
    std::thread t = std::thread(&Renderer::renderMandelbrot, this,
            segmentStart,
            m_state.m_height,
            power,
            std::ref(colours));
        threads.push_back(t);

    for (auto& thread : threads) {
        thread.join();
    }
}

void Renderer::renderSegment(
    int segmentStart,
    int segmentEnd,
    int power,
    std::vector<std::vector<glm::vec3>>& colours) {

    for (int j = segmentStart; j < segmentEnd; ++j) {
        for (int i = 0; i < m_state.m_width; ++i) {
            colours[j][i] = glm::vec3(1.0f, 1.0f, 1.0f);
        }
    }
}

状态几乎只是一堆值，所以我省略了它的代码。

在新线程中调用成员函数

0 个答案: