CODEWITHSUNDEEP
c++
CoconutDug
CoconutDug

Reputation: 43

Have const variables in an object which is used in a vector container

So I am trying to make snake clone.

I have made a BodyPiece class which has certain variables I would like to be const, as they should not change. This was not a problem when I simply created an instance of Bodypiece to test out. However I want to be able to add pieces as the snake grows so I made a vector body variable. As you can see from the code below:

In BodyPiece.h:

#pragma once
#include "D3DGraphics.h"
#include "Keyboard.h"
#include "Direction.h"

class BodyPiece
{
public:
    BodyPiece(int xPos, int yPos, Direction* dir);
    ~BodyPiece();
    void Draw(D3DGraphics& gfx);
    void UpdateDirection(KeyboardClient& kbd);
    void Move();
private:
    Direction* dir;
    int xPos;
    int yPos;
    int width = 5;
    int height = 5;
    int vx = 5;
    int vy = 5;
};

In Game.h file

BodyPiece vector body declared:

std::vector<BodyPiece> body;

In Game.cpp file

vector initialised in initialiser list.

body({ {400, 300, &d } })

If I make any variables in BodyPiece const, it will generate an error:

error C2582 'operator=' function is unavailable in class BodyPiece.

My questions here are:

What causes that? I have looked online and have a little bit of an idea but it really is only a little bit.

How can I have const variables, use a vector container(or another type of container if that will help, does not have to be vector) and keep the compiler happy? Or should I just completely change my approach?

Thank you in advance.

Upvotes: 0

Views: 104

Answers (1)

Some programmer dude
Some programmer dude

Reputation: 409364

The problem is that if you don't have an assignment operator, then the compiler will generate one for you, that does simple shallow copying of the members. However, if you have actual const member variables (and not only default-initialized like yours) then those can't be copied and the compiler can't create an assignment operator.

The simple solution is to make the constants actual constants and also static so they are members of the class and not part of a single object:

class BodyPiece
{
    ...
    static int const width = 5;
    static int const height = 5;
};

The only drawback with this is that you need to actually define these member variables, in a single source file:

int const BodyPiece::width;
int const BodyPiece::height;

The other solution is to explicitly create an assignment operator that copies the data needed:

class BodyPiece
{
public:
    ...
    BodyPiece& operator=(BodyPiece const& other)
    {
        // Copy data from other to this
        xPos = other.xPos;
        ...
        return *this;
    }
    ...
};

Upvotes: 1

Related Questions