C++ 在函数中使用附加数据字段的最佳方法是什么？

在

推力

算法（如

推力：：变换

）中使用的函子中使用某些常量数据的正确（或最佳）方法是什么？我使用的简单方法是在functor的

operator（）

方法中分配所需的数组，如下所示：

struct my_functor {

    __host__ __device__
    float operator()(thrust::tuple<float, float> args) {

        float A[2][10] = {
            { 4.0, 1.0, 8.0, 6.0, 3.0, 2.0, 5.0, 8.0, 6.0, 7.0 },
            { 4.0, 1.0, 8.0, 6.0, 7.0, 9.0, 5.0, 1.0, 2.0, 3.6 }};

        float x1 = thrust::get<0>(args);
        float x2 = thrust::get<1>(args);

        float result = 0.0;
        for (int i = 0; i < 10; ++i)
            result += x1 * A[0][i] + x2 * A[1][i];

        return result;
    }
}

struct my_函子{
__主机设备__
浮点运算符（）（推力：：元组参数）{
浮动A[2][10]={
{ 4.0, 1.0, 8.0, 6.0, 3.0, 2.0, 5.0, 8.0, 6.0, 7.0 },
{ 4.0, 1.0, 8.0, 6.0, 7.0, 9.0, 5.0, 1.0, 2.0, 3.6 }};
浮点x1=推力：：获取（args）；
浮动x2=推力：：获取（args）；
浮动结果=0.0；
对于（int i=0；i<10；++i）
结果+=x1*A[0][i]+x2*A[1][i]；
返回结果；
}
}

---

但这似乎不是很优雅或有效的方式。现在，我必须开发相对复杂的函子，其中包含一些矩阵（常数，如上面的示例）和函子的

操作符（）

方法中使用的其他方法。解决这个问题的最佳方法是什么？谢谢。

从您上次的评论中可以清楚地看出，您真正想问的是函子参数的初始化。CUDA使用C++对象模型，因此结构具有类语义和行为。所以你的例子函子

struct my_functor {
    __host__ __device__
    float operator()(thrust::tuple<float, float> args) const {
        float A[2] = {50., 55.6};

        float x1 = thrust::get<0>(args);
        float x2 = thrust::get<1>(args);

        return x1 * A[0]+ x2 * A[1];
    }
}

struct my_函子{
__主机设备__
浮点运算符（）（推力：：元组参数）常量{
浮点数A[2]={50,55.6}；
浮点x1=推力：：获取（args）；
浮动x2=推力：：获取（args）；
返回x1*A[0]+x2*A[1]；
}
}

可以使用带有初始化列表的空构造函数重新编写，以将函子中的硬编码常量转换为运行时可分配的值：

struct my_functor {
    float A0, A1;

    __host__ __device__
    my_functor(float _a0, _a1) : A0(_a0), A1(_a1) { }

    __host__ __device__
    float operator()(thrust::tuple<float, float> args) const {
        float x1 = thrust::get<0>(args);
        float x2 = thrust::get<1>(args);

        return x1 * A0 + x2 * A1;
    }
}

struct my_函子{
浮球A0，A1；
__主机设备__
my_函子（float_a0，_a1）：a0（_a0），a1（_a1）{
__主机设备__
浮点运算符（）（推力：：元组参数）常量{
浮点x1=推力：：获取（args）；
浮动x2=推力：：获取（args）；
返回x1*A0+x2*A1；
}
}

---

您可以实例化任意多个版本的函子，每个版本都有不同的常量值，以执行与推力库一起使用函子的任何操作

哪种方式是“最优的”？你有没有一个不那么琐碎的例子来说明你正在尝试做什么？。上面的代码可以大大简化，去掉循环并用2个常量替换数组中的20个常量，减少到

result=x1*AA0+x2*AA1

…我学会了几种方法，比如：（1）使用

device\u向量和置换迭代器（2）提前在设备内存中为数组分配内存（但我不知道在我的代码中应该如何使用这种技术…）并在函子中使用
device_ptr
和其他工具（3）在
操作符（）中分配数组
…可能还有其他方法。现在我选择了第三种方法，但我不清楚如何在functor中的几个方法之间共享这些数组…可能我应该将这些数组作为结构的字段，但代码不会compile@talonmies是的，它可以这样简化，你当然是对的……但是如果我不能预先硬编码这些常量，需要从functor外部填充这些数组？我如何实现这样的数组，以便它们可以在functor内部的几个私有方法之间共享？谢谢。您还可以传递设备指针（对于在设备上操作的functor）作为对函子的初始化参数，类似于@Talonmes给出的答案中所示。这将允许您从函子外部填充/修改数组。当然，这也允许共享。答案中有一个例子。这个方法有效，我还不能给出更复杂的代码，可能当我遇到问题时我会变得更清楚的。谢谢。