正在用重复模式初始化 std::vector

Question

我目前正在使用 OpenGL，创建一个 'texture cache' 来处理加载图像并使用 OpenGL 缓冲它们。如果无法加载图像文件，则需要回退到我在构造函数中硬编码的默认纹理。

我基本上需要做的是创建一个颜色统一的纹理。这并不太难，它只是一个大小为像素 * 颜色通道的数组。

我目前正在使用 std::vector 在上传 OpenGL 之前保存初始数据。我遇到的问题是我找不到任何关于用重复模式初始化向量的最佳方法的信息。

我想到的第一个方法是使用循环。

std::vector<unsigned char> blue_texture;
for (int iii = 0; iii < width * height; iii++)
{
    blue_texture.push_back(0);
    blue_texture.push_back(0);
    blue_texture.push_back(255);
    blue_texture.push_back(255);
}

但是，这似乎效率不高，因为矢量必须多次调整自身大小。即使我先保留 space 并执行循环，它仍然效率不高，因为内容将在循环之前归零，这意味着每个无符号字符有两次写入。

目前我正在使用以下方法：

struct colour {unsigned char r; unsigned char g; unsigned char b; unsigned char a;};
colour blue = {0, 0, 255, 255};
std::vector<colour> texture((width * height), blue);

然后我使用以下方法提取数据：

reinterpret_cast<unsigned char*>(texture.data());

还有比这更好的方法吗？我是 C/C++ 的新手，老实说，铸造指针让我害怕。

Answer 1

我认为您的循环解决方案是正确的方法。要通过删除重复的 realloc 调用来提高效率，请使用 blue_texture.reserve(width * height * 4)

reserve 调用将增加分配，也就是在不进行零填充的情况下增加该大小的容量。（请注意，操作系统可能仍将其归零，例如，如果它从 mmap 中提取内存。）它不会改变向量的大小，因此 push_back 和朋友们仍然以相同的方式工作。

Answer 2

可以使用reserve预分配向量；这将避免重新分配。您还可以定义一个小序列（可能是 C 风格的向量：

char const init[] = { 0, 0, 255, 255 };

并循环将其插入向量的末尾：

for ( int i = 0; i < pixelCount; ++ i ) {
    v.insert( v.end(), std::begin( init ), std::end( init ) );
}

这只比在循环中使用四个 push_back 效率稍高，但更简洁，并且可能使你在做什么更清楚，尽管只是一点点：最大的优势可能是能够为初始化序列命名（例如 defaultBackground）。

Answer 3

我会保留您需要的整个大小，然后使用插入功能将图案重复添加到向量中。

std::array<unsigned char, 4> pattern{0, 0, 255, 255};
std::vector<unsigned char> blue_texture;
blue_texture.reserve(width * height * 4);

for (int i = 0; i < (width * height); ++i)
{
    blue_texture.insert(blue_texture.end(), pattern.begin(), pattern.end());
}

Answer 4

最有效的方法是工作最少的方法。

不幸的是，push_back()、insert() 等函数在工作时必须保持向量的 size()，这在紧密循环中执行时是冗余操作。

因此，最有效的方法是分配一次内存，然后直接将数据复制到其中，而不维护任何其他变量。

是这样完成的：

#include <iostream>
#include <array>
#include <vector>

using colour_fill = std::array<uint8_t, 4>;
using pixel_map = std::vector<uint8_t>;

pixel_map make_colour_texture(size_t width, size_t height, colour_fill colour)
{
    // allocate the buffer
    std::vector<uint8_t> pixels(width * height * sizeof(colour_fill));

    auto current = pixels.data();
    auto last = current + pixels.size();

    while (current != last) {
        current = std::copy(begin(colour), end(colour), current);
    }

    return pixels;
}

auto main() -> int
{
    colour_fill blue { 0, 0, 255, 255 };
    auto blue_bits = make_colour_texture(100, 100, blue);

    return 0;
}

Answer 5

我制作了这个模板函数，它将修改其输入容器以包含 count 倍它已经包含的内容。

#include <iostream>
#include <vector>
#include <algorithm>

template<typename Container>
void repeat_pattern(Container& data, std::size_t count) {
  auto pattern_size = data.size();
  if(count == 0 or pattern_size == 0) {
    return;
  }
  data.resize(pattern_size * count);
  const auto pbeg = data.begin();
  const auto pend = std::next(pbeg, pattern_size);
  auto it = std::next(data.begin(), pattern_size);
  for(std::size_t k = 1; k < count; ++k) {
    std::copy(pbeg, pend, it);
    std::advance(it, pattern_size);
  }
}

template<typename Container>
void show(const Container& data) {
  for(const auto & item : data) {
    std::cout << item << " ";
  }
  std::cout << std::endl;
}

int main() {
  std::vector<int> v{1, 2, 3, 4};
  repeat_pattern(v, 3);
  // should show three repetitions of times 1, 2, 3, 4
  show(v);
}

输出（编译为g++ example.cpp -std=c++14 -Wall -Wextra）：

1 2 3 4 1 2 3 4 1 2 3 4

正在用重复模式初始化 std::vector

Initializing std::vector with a repeating pattern

c++

vector

stdvector

c++11