Неинициализированный std :: complex constructor при использовании 'new'

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

Интересно, почему г ++ надоедает инициализировать станд :: комплекс с нулями

Поскольку стандарт говорит, что он должен сделать так, конструктор по умолчанию объявляется как:

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. отмечается в комментариях, поведение технически не определено. Теперь я вижу, что если какая-то неряшливая ласка должна была изменить реализацию 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); } 
};