C++ 向量*不*初始化其成员？

问题描述 投票：0回答：6

我正在为一段返回大数组的 C 代码制作一个 C++ 包装器，因此我尝试在 

vector<unsigned char>
中返回数据。

现在的问题是，数据的量级为兆字节，并且

vector
不必要地初始化其存储，这实际上使我的速度降低了一半。

如何防止这种情况发生？

或者，如果不可能的话——是否有其他一些 STL 容器可以避免这种不必要的工作？或者我最终必须制作自己的容器吗？

（C++11 之前）

注：

我正在传递向量作为我的输出缓冲区。我不从其他地方复制数据。
类似于：

vector<unsigned char> buf(size);   // Why initialize??
GetMyDataFromC(&buf[0], buf.size());
c++ stl vector
6个回答
58
投票

对于使用用户提供的默认构造函数（不显式初始化任何内容）的结构的默认和值初始化，不会对 unsigned char 成员执行初始化：

struct uninitialized_char {
    unsigned char m;
    uninitialized_char() {}
};

// just to be safe
static_assert(1 == sizeof(uninitialized_char), "");

std::vector<uninitialized_char> v(4 * (1<<20));

GetMyDataFromC(reinterpret_cast<unsigned char*>(&v[0]), v.size());

我认为在严格的别名规则下这甚至是合法的。

当我比较 

v
与 
vector<unsigned char>
的构建时间时，我得到了 ~8 µs 和 ~12 ms。速度快 1000 倍以上。编译器是 clang 3.2，带有 libc++ 和标志：
-std=c++11 -Os -fcatch-undefined-behavior -ftrapv -pedantic -Weverything -Wno-c++98-compat -Wno-c++98-compat-pedantic -Wno-missing-prototypes

C++11 有一个用于未初始化存储的助手 std::aligned_storage。虽然它需要编译时间大小。

这是一个添加的示例，用于比较总使用量（以纳秒为单位的时间）：

版本=1（

vector<unsigned char>
）：

clang++ -std=c++14 -stdlib=libc++ main.cpp -DVERSION=1 -ftrapv -Weverything -Wno-c++98-compat -Wno-sign-conversion -Wno-sign-compare -Os && ./a.out

initialization+first use: 16,425,554
array initialization: 12,228,039
first use: 4,197,515
second use: 4,404,043

版本=2（

vector<uninitialized_char>
）：

clang++ -std=c++14 -stdlib=libc++ main.cpp -DVERSION=2 -ftrapv -Weverything -Wno-c++98-compat -Wno-sign-conversion -Wno-sign-compare -Os && ./a.out

initialization+first use: 7,523,216
array initialization: 12,782
first use: 7,510,434
second use: 4,155,241



#include <iostream>
#include <chrono>
#include <vector>

struct uninitialized_char {
  unsigned char c;
  uninitialized_char() {}
};

void foo(unsigned char *c, int size) {
  for (int i = 0; i < size; ++i) {
    c[i] = '\0';
  }
}

int main() {
  auto start = std::chrono::steady_clock::now();

#if VERSION==1
  using element_type = unsigned char;
#elif VERSION==2
  using element_type = uninitialized_char;
#endif

  std::vector<element_type> v(4 * (1<<20));

  auto end = std::chrono::steady_clock::now();

  foo(reinterpret_cast<unsigned char*>(v.data()), v.size());

  auto end2 = std::chrono::steady_clock::now();

  foo(reinterpret_cast<unsigned char*>(v.data()), v.size());

  auto end3 = std::chrono::steady_clock::now();

  std::cout.imbue(std::locale(""));
  std::cout << "initialization+first use: " << std::chrono::nanoseconds(end2-start).count() << '\n';
  std::cout << "array initialization: " << std::chrono::nanoseconds(end-start).count() << '\n';
  std::cout << "first use: " << std::chrono::nanoseconds(end2-end).count() << '\n';
  std::cout << "second use: " << std::chrono::nanoseconds(end3-end2).count() << '\n';
}

我正在使用 clang svn-3.6.0 r218006

9
投票

抱歉，没有办法避免。

C++11 添加了一个仅需要大小的构造函数，但即使这样也会对数据进行值初始化。

最好的选择是在堆上分配一个数组，将其放入

unique_ptr
（如果可用）中，然后从那里使用它。

如果你愿意，正如你所说，“侵入 STL”，你总是可以获取一份 EASTL 的副本来工作。它是某些 STL 容器的变体，允许更严格的内存条件。您想要做的事情的正确实现是为其构造函数赋予一个特殊值，这意味着“默认初始化成员”，这对于 POD 类型意味着不执行任何初始化内存的操作。当然，这需要使用一些模板元编程来检测它是否是 POD 类型。

4
投票

最佳解决方案是简单地更改分配器，对零参数不执行任何操作

construct
。这意味着底层类型是相同的，可以避免任何类型的讨厌的reinterpret_casting和潜在的别名违规，并且可以非侵入性地取消初始化任何类型。

template<typename T> struct no_initialize : std::allocator<T> {
    void construct(T* p) {}
    template<typename... Args> void construct(T* p, Args&&... args) {
        new (p) T(std::forward<Args>(args)...);
    }
};
3
投票

1 似乎在您的情况下使用

std::vector
既没有必要也不明智。您只需要某个对象来为您管理一些原始内存。这可以通过

轻松实现 
std::unique_ptr<void, void(*)(void*)> p(std::malloc(n), std::free);

2如果你真的想使用

std::vector<>
你可以使用这里描述的技巧。

0
投票

我正在使用我的通用 

ndi<>
-union：

#pragma once

template<typename T>
union ndi
{
    ndi();
    ~ndi();
    ndi &operator =( T const & );
    operator T &();
    operator T const &() const;
    T *operator &();
    T const *operator &() const;
    T *operator ->();
    T const *operator ->() const;
private:
    T m_value;
};

template<typename T>
inline ndi<T>::ndi()
{
}

template<typename T>
inline ndi<T>::~ndi()
{
}

template<typename T>
inline ndi<T> &ndi<T>::operator =( T const &other )
{
    m_value = other;
    return *this;
}

template<typename T>
inline ndi<T>::operator T &()
{
    return m_value;
}

template<typename T>
inline ndi<T>::operator T const &() const
{
    return m_value;
}

template<typename T>
inline T *ndi<T>::operator &()
{
    return &m_value;
}

template<typename T>
inline T const *ndi<T>::operator &() const
{
    return &m_value;
}

template<typename T>
inline T *ndi<T>::operator ->()
{
    return &m_value;
}

template<typename T>
inline T const *ndi<T>::operator ->() const
{
    return &m_value;
}

如果你想声明一个非默认初始化字节的向量，你可以这样做：

vector<ndi<uint8_t>> vec( largeNum );
-2
投票

使用 vector.reserve() 只分配存储而不初始化它怎么样？

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.