使用“新”时未初始化的 std::complex 构造函数

Question

在分析我的程序时，我意识到 10% 的代码用在了一个愚蠢的 std::complex<double>() 构造函数中，使用了 new std::complex<double>[size_of_array]。

我在网上搜索过，std::complex 的默认构造函数似乎将值 double() 作为实部和虚部。由于 C++ 不初始化双数，我想知道为什么 g++ 会费心用零初始化 std::complex，以及我是否可以通过整个程序以某种方式解决这个问题 (*)

(*) 现在我必须对创建复数数组的函数进行特殊处理，以分配未初始化的双精度数组并将它们重铸为复数。

编辑：如下所述，这是我的疏忽。默认构造函数有实部和虚部的空构造函数 (http://en.cppreference.com/w/cpp/numeric/complex/complex)

 complex( const T& re = T(), const T& im = T() );

但规范随后介绍了双精度的特殊情况

 complex(double re = 0.0, double im = 0.0);

正是这种特殊情况引入了所有开销，因为它绕过了“double”的实际默认构造函数，它什么都不做（与 int、long、float 等相同）。

Answer 1

我想知道为什么 g++ 费心用零初始化 std::complex

因为标准规定必须这样做，所以默认构造函数声明为：

constexpr complex(double re = 0.0, double im = 0.0);

所以它将两个成员都设置为零。

标准库安全地初始化类型是正常的，而不是像 double 和 int* 这样的内置类型，例如 std::vector<double> 也将其元素初始化为零，如果您调整它的大小以便添加新元素。您可以通过不向vector 添加元素来控制vector 的这一点，直到您知道您希望它们具有什么值。

complex 的一种可能解决方法是使用不进行初始化的类型：

struct D
{
  D() noexcept { }; // does not initialize val!
  D(double d) noexcept : val(d) { }
  operator double() const noexcept { return val; }
  D& operator=(double d) noexcept { val = d; return *this; }
  double val;
};

现在，如果您使用std::complex<D>，默认构造函数什么也不做。将explicit 添加到转换构造函数和/或转换运算符以适合您的口味。

Answer 2

有一种简单的方法可以做到这一点。如果您使用 std::vector “保留”内存，它会更快，因为它不会在每个元素上调用构造函数。

即：

std::vector< std::complex< double > > vec;
vec.reserve( 256 );
for( int i = 0; i < 256; i++ )
{
    vec.push_back( std::complex< double >( 1, 1 ) );
}

会比这快得多：

std::complex< double >* arr = new std::complex< double >[256];
for( int i = 0; i < 256; i++ )
{
    arr[i]( std::complex< double >( 1, 1 ) );
}
delete[] arr;

因为在第一个例子中构造函数只被调用一次。

它还有一个额外的优势，即您拥有 RAII，并且 'vec' 将在其超出范围时自动释放。

Answer 3

以下来自我正在开发的代码。

稍后添加：作为 M.M.在 cmets 中指出，该行为在技术上是未定义的。现在我看到，如果一些卑鄙的黄鼠狼要改变 std::complex 的实现，使其不能被简单地构造/破坏，这将是一个裁剪器。另请参阅http://en.cppreference.com/w/cpp/types/aligned_storage 的示例。

#include <complex>
#include <type_traits>

typedef std::complex<double> complex;

// Static array of complex that does not initialize
// with zeros (or anything).

template<unsigned N>
struct carray {
    typedef
      std::aligned_storage<sizeof(complex), alignof(complex)>::type raw;

    raw val[N];

    complex& operator[] (unsigned idx) {
        return reinterpret_cast<complex&> (val[idx]);
    }

    complex* begin() { return &operator[](0); }
    complex* end() { return &operator[](N); }
};