如何加快向量初始化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());