如何加快向量初始化C++

Question

我有一个关于堆栈溢出错误的前一个问题，并切换到我的对象数组向量。如果需要，可以在这里引用这个问题：How to get rid of stack overflow error

但是我现在的问题是如何加速向量的初始化。我目前的方法目前需要〜15秒。使用数组而不是向量它需要第二个数组的大小足够小的数组，而不会引发堆栈溢出错误。

这是怎么了初始化它：

在main.cpp中我初始化我的地牢对象：

dungeon = Dungeon(0, &textureHandler, MIN_X, MAX_Y); 

在我的地牢（...）构造，我初始化房间的我5x5的矢量并调用loadDungeon：

Dungeon::Dungeon(int dungeonID, TextureHandler* textureHandler, int topLeftX, int topLeftY) 
{ 
    currentRoomRow = 0; 
    currentRoomCol = 0; 
    for (int r = 0; r < MAX_RM_ROWS; ++r) 
    { 
     rooms.push_back(vector<Room>()); 
     for (int c = 0; c < MAX_RM_COLS; ++c) 
     { 
      rooms[r].push_back(Room()); 
     } 
    } 
    loadDungeon(dungeonID, textureHandler, topLeftX, topLeftY); 
} 

我的房间构造填充细胞（这样我就可以设置它们在loadDungeon功能）我30×矢量：

Room::Room() 
{ 
    for (int r = 0; r < MAX_ROWS; ++r) 
    { 
     cells.push_back(vector<Cell>()); 
     for (int c = 0; c < MAX_COLS; ++c) 
     { 
      cells[r].push_back(Cell()); 
     } 
    } 
} 

我的默认构造细胞简单，没有做太多，但无论如何，我会张贴：

Cell::Cell() 
{ 
    x = 0; 
    y = 0; 
    width = 16; 
    height = 16; 
    solid = false; 
    texCoords.push_back(0); 
    texCoords.push_back(0); 
    texCoords.push_back(1); 
    texCoords.push_back(0); 
    texCoords.push_back(1); 
    texCoords.push_back(1); 
    texCoords.push_back(0); 
    texCoords.push_back(1); 
} 

而且最后我loadDungeon（）函数将设置细胞。最终这将从一个文件中读取并加载单元格，但现在我想尽可能优化这一点。

void Dungeon::loadDungeon(int dungeonID, TextureHandler* textureHandler, int topLeftX, int topLeftY) 
{ 
    int startX = topLeftX + (textureHandler->getSpriteWidth()/2); 
    int startY = topLeftY - (textureHandler->getSpriteHeight()/2); 
    int xOffset = 0; 
    int yOffset = 0; 
    for (int r = 0; r < MAX_RM_ROWS; ++r) 
    { 
     for (int c = 0; c < MAX_RM_COLS; ++c) 
     { 
      for (int cellRow = 0; cellRow < rooms[r][c].getMaxRows(); ++cellRow) 
      { 
       xOffset = 0; 
       for (int cellCol = 0; cellCol < rooms[r][c].getMaxCols(); ++cellCol) 
       { 
        rooms[r][c].setupCell(cellRow, cellCol, startX + xOffset, startY - yOffset, textureHandler->getSpriteWidth(), textureHandler->getSpriteHeight(), false, textureHandler->getSpriteTexCoords("grass")); 
        xOffset += textureHandler->getSpriteWidth(); 
       } 
       yOffset += textureHandler->getSpriteHeight(); 
      } 
     } 
    } 

    currentDungeon = dungeonID; 
    currentRoomRow = 0; 
    currentRoomCol = 0; 
} 

那么如何加快速度，所以每次加载时间不需要大约15秒钟。我觉得应该不需要15秒来加载一个简单的2D游戏。

SOLUTION 那么我的解决办法是使用std ::矢量::储备调用（rooms.reserve在我的代码，它结束了工作很好，我改变了我的功能地牢:: loadDungeon到地牢:: loadDefaultDungeon因为现在加载关闭保存文件

反正这里是代码（我把它下降到约4-5秒钟〜在调试模式下15 +秒）：

Dungeon::Dungeon() 
{ 
    rooms.reserve(MAX_RM_ROWS * MAX_RM_COLS); 
    currentDungeon = 0; 
    currentRoomRow = 0; 
    currentRoomCol = 0; 
} 
void Dungeon::loadDefaultDungeon(TextureHandler* textureHandler, int topLeftX, int topLeftY) 
{ 
    int startX = topLeftX + (textureHandler->getSpriteWidth()/2); 
    int startY = topLeftY - (textureHandler->getSpriteHeight()/2); 
    int xOffset = 0; 
    int yOffset = 0; 
    cerr << "Loading default dungeon..." << endl; 
    for (int roomRow = 0; roomRow < MAX_RM_ROWS; ++roomRow) 
    { 
     for (int roomCol = 0; roomCol < MAX_RM_COLS; ++roomCol) 
     { 
      rooms.push_back(Room()); 
      int curRoom = roomRow * MAX_RM_COLS + roomCol; 
      for (int cellRow = 0; cellRow < rooms[curRoom].getMaxRows(); ++cellRow) 
      { 
       for (int cellCol = 0; cellCol < rooms[curRoom].getMaxCols(); ++cellCol) 
       { 
        rooms[curRoom].setupCell(cellRow, cellCol, startX + xOffset, startY - yOffset, textureHandler->getSpriteWidth(), textureHandler->getSpriteHeight(), false, textureHandler->getSpriteTexCoords("default"), "default"); 
        xOffset += textureHandler->getSpriteWidth(); 
       } 
       yOffset += textureHandler->getSpriteHeight(); 
       xOffset = 0; 
      } 
      cerr << "  room " << curRoom << " complete" << endl; 
     } 
    } 
    cerr << "default dungeon loaded" << endl; 
} 

Room::Room() 
{ 
    cells.reserve(MAX_ROWS * MAX_COLS); 
    for (int r = 0; r < MAX_ROWS; ++r) 
    { 
     for (int c = 0; c < MAX_COLS; ++c) 
     { 
      cells.push_back(Cell()); 
     } 
    } 
} 
void Room::setupCell(int row, int col, float x, float y, float width, float height, bool solid, /*std::array<float, 8>*/ vector<float> texCoords, string texName) 
{ 
    cells[row * MAX_COLS + col].setup(x, y, width, height, solid, texCoords, texName); 
} 

void Cell::setup(float x, float y, float width, float height, bool solid, /*std::array<float,8>*/ vector<float> t, string texName) 
{ 
    this->x = x; 
    this->y = y; 
    this->width = width; 
    this->height = height; 
    this->solid = solid; 
    for (int i = 0; i < t.size(); ++i) 
     this->texCoords.push_back(t[i]); 
    this->texName = texName; 
} 

Answer 1

似乎浪费，有这么多的动态分配，可以通过做这样的事情来完成。您可以通过压扁了您的载体和进步访问它摆脱单一的分配：

std::vector<Room> rooms; 

rooms.resize(MAX_RM_ROWS * MAX_RM_COLS); 

for (unsigned int i = 0; i != MAX_RM_ROWS; ++i) 
{ 
    for (unsigned int j = 0; j != MAX_RM_COLS; ++j) 
    { 
     Room & r = rooms[i * MAX_RM_COLS + j]; 
     // use `r`  ^^^^^^^^^^^^^^^^^^^-----<< strides! 
    } 
} 

注意如何resize是精确的进行一次，招致只有一个单一的分配，以及默认构造每个元素。如果你想特别构建每个元素，请改为使用rooms.reserve(MAX_RM_ROWS * MAX_RM_COLS);，并在循环中填充该向量。

您可能还希望通过交换行和列来查看哪些更快。

Answer 2

因为它似乎是你的向量的大小在编译时定义，如果你可以使用C++ 11，你可以考虑使用std::array而不是std::vector。 std::array无法调整大小，并且缺少std::vector中的许多操作，但它更轻巧，它看起来非常适合您正在进行的操作。

作为一个例子，可以声明cells为：

#include <array> 

/* ... */ 

std::array<std::array<Cell, MAX_COLS>, MAX_ROWS> cells; 

UPDATE：由于本地定义的std::array分配堆栈在其内阵列中，OP将经历一个堆栈溢出，由于相当大的阵列的大小。尽管如此，通过在堆上分配数组，可以使用std::array（及其优点与使用std::vector相比）。

typedef std::array<std::array<Cell, MAX_COLS>, MAX_ROWS> Map; 
Map* cells; 

/* ... */ 

cells = new Map(); 

更妙的是，智能指针可以使用：

#include <memory>  

/* ... */ 

std::unique_ptr<Map> cells; 
cells = std::unique_ptr(new Map());