C++ 数组复制函子示例：改进/替代？

问题

实现一个可同时使用标量和数组的复制函子“接口”

CopyFunctor::operator()(T& dest, const T& src);

作为一个例子，我想概括一个排序函数来处理元素数组和“内联”数组

template <typename T, typename CopyFunctor> sort(T array[]);

int array_of_elements[] = {7, 3, 5, 2};
sort(array_of_elements);
// after sorting: {2, 3, 5, 7}

int array_of_arrays[] = {  3, 1,   2, 4,   7, 6,   5, 8};
// inlined arrays are: {3, 1}, {2, 4}, {7, 6}, {5, 8}
// these 'inlined' arrays are fixed-sized
// after sorting using first element as key: { 2, 4,   3, 1,   5, 8,    7, 6}   
// thus, the second element should be moved with the first element

模板排序（T数组[]）；
元素[]={7,3,5,2}的int数组；
排序（元素的数组）；
//排序后：{2,3,5,7}
int array_of_array[]={3,1,2,4,7,6,5,8}；
//内联数组是：{3，1}，{2，4}，{7，6}，{5，8}
//这些“内联”数组的大小是固定的
//使用第一个元素作为键进行排序后：{2,4,3,1,5,8,7,6}
//因此，第二个元素应与第一个元素一起移动

内部排序（T数组[]）， 要将元素（或元素组）从位置i交换到位置j， 无论是元素数组还是“内联数组”，我们都可以以完全相同的方式调用函子：

template <typename T, typename CopyFunctor> sort(T array[], CopyFunctor copy) {

 // ...

   // swap a[i] and a[j]
   copy(b, a[i]);
   copy(a[i], a[j]);
   copy(a[j], b);

 // ...

 }

模板排序（T数组[]，CopyFunctor副本）{
// ...
//互换a[i]和a[j]
副本（b，a[i]）；
副本（a[i]，a[j]）；
副本（a[j]，b）；
// ...
}

这里b是一个标量或数组，其大小足以容纳a中的一个“内联”数组。 （在本例中，我可能需要一个交换函子，但在我更复杂的用例中，我需要一个复制函子。）

假设

一旦内联数组的数组被初始化，它将永远不会被调整大小

示例代码

#include <cstdio>
#include <cstring>
using namespace std;

template <typename T>
struct ScalarSetter {
    void operator()(T& a, const T& b) const {
        a = b;
    }
};

template <typename T>
struct ArraySetter {
    size_t _n;
    ArraySetter(size_t n) : _n(n) {}
    void operator()(T& a, const T& b) const {
        std::memcpy(&a, &b, sizeof(T)*_n);
    }
};

int main(int argc, char* argv[]) {

    {
      ScalarSetter<float> copy;
      float a = 1.0;
      float b = 2.0;
      copy(a, b);
      printf("a = %f\n", a);
      /* output:
       * a = 2.00000
       */
    }

    {
      size_t n = 3;
      ArraySetter<float> copy(n);
      float c[] = {.1, .2, .3, .4};
      float d[] = {.4, .5, .6, .7};
      copy(c[0], d[0]);
      for (size_t i = 0; i < n+1; ++i) {
        printf("c[%d] = %f\n", i, c[i]);
      }
      /* output:
       * c[0] = 0.400000
       * c[1] = 0.500000
       * c[2] = 0.600000
       * c[3] = 0.400000
       */
    }

    return 0;
}

#包括
#包括
使用名称空间std；
模板
结构缩放器{
无效运算符（）（T&a，常数T&b）常数{
a=b；
}
};
模板
结构阵列选择器{
大小;；
阵列选择器（大小）{n（n）}
无效运算符（）（T&a，常数T&b）常数{
标准：：memcpy（&a&b，尺寸（T）*\n）；
}
};
int main（int argc，char*argv[]）{
{
缩放记录副本；
浮点数a=1.0；
浮动b=2.0；
副本（a、b）；
printf（“a=%f\n”，a）；
/*输出：
*a=2.00000
*/
}
{
尺寸n=3；
阵列设置器副本（n）；
浮点数c[]={.1,2,3,4}；
浮点d[]={.4,5,6,7}；
副本（c[0]，d[0]）；
对于（尺寸i=0；i

由于我实际上使用的是Cuda/C++，我或多或少被迫使用内联数组

上面的示例代码编译、运行并通过valgrind内存测试。 但是我觉得在ArraySetter:：operator（）（…）中派生指向输入参数的指针有点不舒服

（编辑：我认为如果内联数组不连续，代码就会中断……是否保证（动态）分配数组的连续性？）

---

是否有另一种方法可以实现同时适用于标量和数组的一致性复制函子“接口”？

您是否只需要一个矩阵类？您可以将它们实现为

内联数组

，并为行交换等提供一个良好的高级接口。将数组实现为：

int-array[2][]={{3,1}，{2,4}…}？内存布局将是相同的，如果传递给排序，它将在<代码> int [2 ] < /代码>（未测试）“函子”通常表示C++中的其他内容。也不清楚你到底需要这个做什么。你的<代码>拷贝<代码>函数似乎完成了赋值操作符的角色——为什么不简单地使用后者呢？@罗德里格兹，这就是我通常在C++中使用数组的方式。但是，由于我是为GPU编程的，我认为出于性能原因，我或多或少地被内联数组所困扰。@pmr这是可行的，尽管我认为客户机函数需要以不同于本机数组的方式处理矩阵类。