C++ std:：async参数太多

好的，所以我尝试在项目中使用std:：future，但是我使用的std:：async一直告诉我有太多的参数。我试着看看我是否误解了模板，但我没有发现任何错误。。。这是电话：

QVector<MyMesh::Point> N1;
QVector<MyMesh::Point> N2;
future<QVector<MyMesh::Point>> FN1 = async(launch::async, rangeSearch, &mesh, vit->idx(), diagBoundBox*0.02);
future<QVector<MyMesh::Point>> FN2 = async(launch::async, rangeSearch, &mesh, vit->idx(), diagBoundBox*0.02*2);
N1 = FN1.get();
N2 = FN2.get();

qn1；
qn2；
future FN1=async（launch:：async，rangeSearch，&mesh，vit->idx（），diagbundbox*0.02）；
future FN2=async（launch:：async，rangeSearch，&mesh，vit->idx（），diagbundbox*0.02*2）；
N1=FN1.get（）；
N2=FN2.get（）；

还使用了rangeSearch方法：

QVector<MyMesh::Point> rangeSearch(MyMesh *_mesh, int pid, float range);

QVector rangeSearch（MyMesh*\u mesh，int-pid，浮点范围）；

有什么不对劲吗

编辑：这里有一个最小的可重复的例子，很抱歉第一个

#include <future>

class Class
{
public:

    void A();
    int F(int a, int b, int c);
};

int Class::F(int a, int b, int c){
    return a+b+c;
}

void Class::A(){
    int N1;
    int N2;
    std::future<int> FN1 = std::async(std::launch::async, F, 1, 2, 3);
    std::future<int> FN2 = std::async(std::launch::async, F, 1, 2, 3);
    N1 = FN1.get();
    N2 = FN2.get();
}

int main()
{
    Class O;
    O.A();
}

#包括
班级
{
公众：
使A（）无效；
intf（inta，intb，intc）；
};
int类：：F（int a，int b，int c）{
返回a+b+c；
}
void类：：A（）{
int-N1；
int N2；
std:：future FN1=std:：async（std:：launch:：async，F，1，2，3）；
std:：future FN2=std:：async（std:：launch:：async，F，1，2，3）；
N1=FN1.get（）；
N2=FN2.get（）；
}
int main（）
{
O类；
O.A（）；
}

还有错误：

main.cpp: In member function ‘void Class::A()’:
main.cpp:18:69: error: invalid use of non-static member function ‘int Class::F(int, int, int)’
     std::future<int> FN1 = std::async(std::launch::async, F, 1, 2, 3);
                                                                     ^
main.cpp:11:5: note: declared here
 int Class::F(int a, int b, int c){
     ^~~~~
main.cpp:19:69: error: invalid use of non-static member function ‘int Class::F(int, int, int)’
     std::future<int> FN2 = std::async(std::launch::async, F, 1, 2, 3);
                                                                     ^
main.cpp:11:5: note: declared here
 int Class::F(int a, int b, int c){
     ^~~~~

main.cpp:在成员函数“void Class:：A（）”中：
main.cpp:18:69:错误：非静态成员函数“int Class:：F（int，int，int）”的使用无效
std:：future FN1=std:：async（std:：launch:：async，F，1，2，3）；
^
main.cpp:11:5：注：此处声明
int类：：F（int a，int b，int c）{
^~~~~
main.cpp:19:69:错误：非静态成员函数“int Class:：F（int，int，int）”的使用无效
std:：future FN2=std:：async（std:：launch:：async，F，1，2，3）；
^
main.cpp:11:5：注：此处声明
int类：：F（int a，int b，int c）{
^~~~~

这里的问题不是你传递的参数的数量，而是参数的性质——特别是，试图将成员函数直接传递给

std:：async

处理此问题的最简单方法几乎肯定是通过lambda表达式调用成员函数：

#include <future>

class Class
{
public:
    void A();
    int F(int a, int b, int c);
};

int Class::F(int a, int b, int c)
{
    return a + b + c;
}

void Class::A()
{
    int N1;
    int N2;
    std::future<int> FN1 = std::async(std::launch::async, [&](int a, int b, int c) {
        return F(a, b, c); }, 1, 2, 3);
    std::future<int> FN2 = std::async(std::launch::async, [&](int a, int b, int c) {
        return F(a, b, c);}, 1, 2, 3);

    N1 = FN1.get();
    N2 = FN2.get();
}

int main()
{
    Class O;
    O.A();
}

#包括
班级
{
公众：
使A（）无效；
intf（inta，intb，intc）；
};
int类：：F（int a，int b，int c）
{
返回a+b+c；
}
void类：：A（）
{
int-N1；
int N2；
std:：future FN1=std:：async（std:：launch:：async，[&]（inta，intb，intc）{
返回F（a，b，c）；}，1，2，3）；
std:：future FN2=std:：async（std:：launch:：async，[&]（inta，intb，intc）{
返回F（a，b，c）；}，1，2，3）；
N1=FN1.get（）；
N2=FN2.get（）；
}
int main（）
{
O类；
O.A（）；
}

这里的问题不是你传递的参数的数量，而是参数的性质——特别是，试图将成员函数直接传递给

std:：async

处理此问题的最简单方法几乎肯定是通过lambda表达式调用成员函数：

#include <future>

class Class
{
public:
    void A();
    int F(int a, int b, int c);
};

int Class::F(int a, int b, int c)
{
    return a + b + c;
}

void Class::A()
{
    int N1;
    int N2;
    std::future<int> FN1 = std::async(std::launch::async, [&](int a, int b, int c) {
        return F(a, b, c); }, 1, 2, 3);
    std::future<int> FN2 = std::async(std::launch::async, [&](int a, int b, int c) {
        return F(a, b, c);}, 1, 2, 3);

    N1 = FN1.get();
    N2 = FN2.get();
}

int main()
{
    Class O;
    O.A();
}

#包括
班级
{
公众：
使A（）无效；
intf（inta，intb，intc）；
};
int类：：F（int a，int b，int c）
{
返回a+b+c；
}
void类：：A（）
{
int-N1；
int N2；
std:：future FN1=std:：async（std:：launch:：async，[&]（inta，intb，intc）{
返回F（a，b，c）；}，1，2，3）；
std:：future FN2=std:：async（std:：launch:：async，[&]（inta，intb，intc）{
返回F（a，b，c）；}，1，2，3）；
N1=FN1.get（）；
N2=FN2.get（）；
}
int main（）
{
O类；
O.A（）；
}

代码中有两个问题。首先，要创建指向成员函数的指针，语法是

&Class:：F

。其次，当使用指向成员函数的指针时，需要将其应用到一个对象。因此正确的调用（在成员函数

Class:：a

中）是正确的

std:：未来的FN1=
std:：async（std:：launch:：async，&Class:：F，this，1，2，3）；

---

std:：async

假设在其参数列表中指向成员函数的指针后面会跟有指向该成员函数应应用于的对象的指针或引用。

代码中存在两个问题。首先，要创建指向成员函数的指针，语法是

&Class:：F

。其次，当使用指向需要将其应用到的成员函数的指针。因此，正确的调用（在成员函数

类：：A

中）是

std:：未来的FN1=
std:：async（std:：launch:：async，&Class:：F，this，1，2，3）；

---

std:：async

假设在其参数列表中，指向成员函数的指针后面会跟一个指向该成员函数应应用于的对象的指针或引用。

如果将其设置为a并删除不相关的

QT

类，则会更容易提供帮助。编辑了此帖子，对此表示抱歉。我不是100%确定我会说它应该使用它自己的实例（虽然它的功能并不重要，但我想它可以使用任何类：：F）如果你把它做成一个，并删除不相关的

QT

类，它会更容易提供帮助。编辑了这篇文章，对此感到抱歉。我不是100%确定你在问什么，所以我会说它应该使用它自己的实例（虽然它的功能并不重要，但它可以使用任何类：：F我猜）我看到了类似的东西，它似乎确实起作用（虽然它给出了另一个错误，而且很长，但我想是完全无关的）。编辑OG帖子我看到了类似的东西，它确实起作用（虽然它给出了另一个错误，很长，但我想是完全无关的）。编辑OG帖子