在初始化列表中从 float* 设置 double[]

Question

我有一个大致如下所示的类：

template<std::size_t dim>
class Foo {
public:
    Foo(void const * const data);
private: 
    double vals[dim];
}

对于构造函数，我知道 void* data 指向一个 float 值数组（维度为 dim）。现在我想在该构造函数的初始化列表中初始化 vals 数组（最好）。

更糟糕的是，所指向的浮点数不一定必须正确地进行内存对齐。

我怎样才能有效地做到这一点？

---

编辑 1

关于下面进行的讨论，也许让我先说明我的设计优先事项。这可能会帮助您专注于对我来说最重要的问题。

1. 应对不良的内存对齐
2. 在性能方面尽可能少地执行操作。

老实说，如果我们需要构造函数主体来使算法快速运行，这对我来说也很好。重点是原始功率。

Answer 1

如果您担心传递的指针未与 float 边界对齐（例如，文件映射等），那么您可以编写类似的内容

template<std::size_t dim>
class Foo {
public:
    Foo(void const * const data)
    {
        float temp[dim];
        memcpy( &temp, data, dim * sizeof( float ) );
        std::copy( temp, temp + dim, vals );
    }
private: 
    double vals[dim];
}

可能是一个过于热心且不太可移植的解决方案：

template<std::size_t dim>
class Foo {
public:
    Foo(void const * const data)
    {
        if( static_cast<long>( data ) % sizeof( float ) == 0 ) {
            const float *temp = data;
            std::copy( temp, temp + dim, vals );
        } else {
            float temp[dim];
            memcpy( &temp, data, dim * sizeof( float ) );
            std::copy( temp, temp + dim, vals );
        }
    }
private: 
    double vals[dim];
}

在初始化列表不会使您的代码更快，它只是在可能的情况下提供便利。

如果您非常关心性能，我会将这个 if 包装在一个宏中，并且仅在需要正确对齐访问的体系结构上使用 if（x86 不是一个，只是在 x86 上速度较慢）。

编辑

评论中提出的另一个解决方案，感谢
史蒂夫·杰索普。它的重点是减少临时变量的大小。

double *dest = vals;
float tmp;
void const *first = data;
void const *last = data + dim * sizeof(float);
while( first != last ) {
    memcpy( &tmp, first, sizeof(float) );
    first += sizeof(float);
    *dest++ = tmp;
}

可能需要一些微基准测试/反汇编。

Answer 2

由于 float 的大小与 double 不同，我认为唯一的方法是从一个数组到另一个数组的手动分配。

是否可以将 vals 更改为 float 数组？这将允许您使用 memcpy 将 data 数组复制到其中。因为将 float 存储在 double 数组中时无法获得精度，除非稍后更改 vals 以使用 float 的高精度code>double，你不会从使用 double 中获得任何东西。

Answer 3

在当前 C++ 标准中，您无法初始化初始值设定项列表中的数组。您可以利用提前知道大小的事实来使用 std::vector ；

template<std::size_t dim>
class Foo {
public:
  Foo(float const * const data) : vals(dim) // fix the vector size
  {
    for(std::size_t i=0; i<dim; i++)
      vals[i] = data[i];  // assignment
  }
private: 
  std::vector<double> vals;
};

我不能说向量与原始数据一样高效；但它们经过了很好的优化并且异常安全。

Answer 4

为什么要隐藏类型？

这是什么问题：

template<std::size_t dim>
class Foo {
public:
    Foo(float const * const data);
private: 
    double vals[dim]
}

template<std::size_t dim>
Foo< dim >::Foo(float const * const data) : vals()
{
  std::copy( data, data+dim, &vals[0] );
}

编辑

如果你切换到std::vector，你可以像这样初始化：

class Foo {
public:
    Foo(float const * const dataBegin,float const * const dataEnd);
private: 
    std::vector< double > vals;
}

Foo::Foo(float const * const dataBegin,float const * const dataEnd) : vals( dataBegin, dataEnd )
{
}