dynamical initialization of std::vector<unique_ptr<class T>> - c++11

Question

I have a class Grid declared as follows:
Grid.h
#ifndef DATATEST_GRID_H
#define DATATEST_GRID_H
#include <memory>
#include <vector>
#include "Position.h"
class Grid
{
public:
Grid(int length_x, int length_y);
~Grid();
Position *at(int x, int y);
void printGrid();
private:
int length_x, length_y;
std::vector<std::unique_ptr<Position>> grid;
};
#endif
Its most important member variable is the vector<unique_ptr<Position>>, which I'm using to simulate a 2-dimensional array whose size is determined at runtime. The class declaration for the Position is as follows:
Position.h
#ifndef DATATEST_POSITION_H
#define DATATEST_POSITION_H
#include <memory>
#include <string>
class Position {
public:
Position(int x, int y);
~Position();
std::string toString();
int getX() { return x; };
int getY() { return y; };
private:
int x, y;
};
#endif
In the Grid's constructor, I want to create the desired number of Positions and add them to the vector<unique_ptr<Position>>.
Grid.cpp
#include "Grid.h"
#include <iostream>
#include <memory>
#include <vector>
#include "Position.h"
Grid::Grid(int length_x, int length_y)
: length_x(length_x), length_y(length_y)
{
grid.resize(length_x * length_y);
for (int x = 0; x < length_x; x++) {
for (int y = 0; y < length_y; y++) {
/* Option 1 */
std::unique_ptr<Position> temp = std::make_unique<Position>(x, y);
grid.push_back(std::move(temp));
/* Option 2 */
// std::unique_ptr<Position> temp = std::make_unique<Position>(x, y);
// grid.emplace_back(std::move(temp));
/* Option 3 */
// grid.push_back(std::make_unique<Position>(x, y));
/* Option 4 */
// grid.emplace_back(std::make_unique<Position>(x, y));
}
}
}
Grid::~Grid()
{
grid.clear();
}
Position *Grid::at(int x, int y)
{
if (x < 0 || x >= length_x || y < 0 || y >= length_y) {
return nullptr;
}
else {
return grid.at(x * (length_y) + y).get();
}
}
void Grid::printGrid()
{
for (int i = 0; i < grid.size(); i++) {
std::cout << grid.at(i)->toString() << std::endl;
}
}
I'm testing access by calling Position::toString for each unique_ptr<Position> and printing the result to the console.
Position.cpp
#include "Position.h"
#include <string>
Position::Position(int x, int y)
: x(x), y(y)
{
}
Position::~Position()
{
}
std::string Position::toString()
{
return "Position(" + std::to_string(x) + ", " + std::to_string(y) + ")";
}
And finally, the main function:
Main.cpp
#include "Grid.h"
#include "Position.h"
int main()
{
Grid g(2, 2);
g.printGrid();
return 0;
}
No matter which way I populate the vector<unique_ptr<Position>>, I always get the following error:
First-chance exception at 0x0087D8A3 in CombatSim.exe: 0xC0000005: Access violation reading location 0x00000000.
Unhandled exception at 0x0087D8A3 in CombatSim.exe: 0xC0000005: Access violation reading location 0x00000000.
As far as I know, I could have one of four problems:
1) I'm adding the unique_ptr to the created Position object to the vector incorrectly
2) I'm using the wrong method to dynamically create Position objects.
3) All of the above.
4) Something I don't know about.

Answer 1

Use std::vector::reserve(n) instead of std::vector::resize(n) if you are going to push_back those n elements afterwards.
resize will fill the vector with initialized objects, so the vector.size() will be n after that.
reserve will just reserve enough space for all n element, but will not insert any objects.

Answer 2

It seems that resizing the grid will first insert length_x * length_y unique pointers that all point to 0. Your push_back should be fine but your real elements start at position length_x * length_y in the vector. I think removing the line
grid.resize(length_x * length_y);
should solve the problem. Maybe someone else can explain why this happens.