Segmentation fault when using vectors in the class and constructor

I tried setting the size of the vector when it was instantiated.

vector<int> pos(2);

But then I get the debug error:

error: expected identifier before numeric constant

That's a compilation error, not a debug error.

You can't initialise members like that. However, you can (and should) initialise them using the parent constructor:

Tile(int x, int y, int value_)
    : pos(2)
{
    pos[0] = x;
    pos[1] = y;
    value = value_;
}

Currently you're just leaving your vector empty then accessing (and writing to!) elements that don't exist.

You really don't want a vector for this, anyway: that's a lot of dynamic allocation. How about a nice array? Or just two ints.

As mentioned in other answers, your vector is empty and your code is attempting to assign non-existent elements.

The solution is to always use initialisers instead of assignment. Rewrite your constructor as follows:

Tile(int x, int y, int value) :
    pos{x, y},
    value{value} {}

Note that the constructor body is now empty. All initialisation happens where it should — in the initialiser list.

Apart from that, your class does not need an explicitly defined destructor; the default destructor works just fine.

There are other issues with this class — for instance, what happens when the user does tile.setPos(3, 4)? A rule of thumb of good API design is to make it impossible to misuse the API.

Here’s how I would write your Tile class instead:

struct Tile {
    int x;
    int y;
    int value;

    Tile(int x, int y, int value) : x{x}, y{y}, value{value} {}
};

The getter and setter in your case wasn’t really doing any meaningful work. There’s an argument to be made to hide all data members behind accessors to future-proof access control. I’m no longer convinced this is actually useful but just in case, here’s a solution with that, too:

class Tile {
    int x_;
    int y_;
    int value_;

public:
    Tile(int x, int y, int value) : x_{x}, y_{y}, value_{value} {}

    int x() const { return x; }
    int& x() { return x; }

    int y() const { return y; }
    int& y() { return y; }

    int value() const { return value; }
};

This makes x and y readable and writable (via assignment: t.x() = 42;), and value only readable. Other APIs are possible, with different sets of trade-offs. The important thing is to be consistent.

Your constructor doesn't set the size, so when you try to access/modify its contents, you are probably getting the exception.

Tile(int x, int y, int value_) : pos(2) {
    pos[0] = x;
    pos[1] = y;
    value = value_;
}

You can use the initialization list of the constructor to call the vector's constructor, as in the code above.