Problem with vectors!

Hello there, fellow programmers!

I'm relatively new to programming and while trying to develop my first simple game i've stumbled upon a problem that i have been unable to solve for days. :*(

So before throwing myself off a cliff in frustration i turn to you to see if your magic can solve my problem.

The game involves creating multiple objects of a class ("Enemy") and storing these objects within a vector.

The problem appears to occure during this storing process.

I get the following error:

error C2582: 'operator =' function is unavailable in 'Enemy' .....(directory details)

This is the .h file of the EventHandler, which is the one handling the storing of this object:

Code:

---

#ifndef INCLUDED_EVENTHANDLER
#define INCLUDED_EVENTHANDLER

#include "Enemy.h"
#include <vector>

class EventHandler {
public:
        EventHandler();
        typedef std::vector<Enemy> EnemyVector;
        EnemyVector enemies;
       
        void SpawnEnemy();

};

#endif

---

Here is the .cpp file:

Code:

---

#include "EventHandler.h"


EventHandler::EventHandler():
enemies(){}

void EventHandler::SpawnEnemy(){

        enemies.push_back(Enemy());
}

---

If this is not sufficient to be able to solve the problem i'll post more code.

I'm a biiig noob when it comes to programming (started this summer) so help would be infinitely appriciated!!

Thanks in advance! :D

Considering that the error message is concerned with a member function of the Enemy class, you should post the Enemy class definition.

Ok here is the .h for the Enemy class

Code:

---

#ifndef INCLUDED_ENEMY
#define INCLUDED_ENEMY
#include "GameConsole.h"

using namespace std;

class Enemy {
public:
        Enemy();
        double hast;
        double xPosition;
        double yPosition;
        int    Enemy_width;
        int    Enemy_height;
        const string EnemyImageFilename;
        const int    ENEMYIMAGE_X_FRAME_COUNT;
        const int    ENEMYIMAGE_Y_FRAME_COUNT;
        GCImage    EnemyImage;
        ~Enemy();

        void render();
        void move(double execution_time);

};


#endif

---

And here is the .cpp:

Code:

---


#include "Enemy.h"


Enemy::Enemy():
        hast(200),
        xPosition(500),
        yPosition(0),
        EnemyImageFilename        ("EnemyImage.jpg"),
        ENEMYIMAGE_X_FRAME_COUNT  (1),
        ENEMYIMAGE_Y_FRAME_COUNT  (1)
       
        {
                EnemyImage      =        VGCDisplay::openImage(
                        EnemyImageFilename,
                        ENEMYIMAGE_X_FRAME_COUNT,
                        ENEMYIMAGE_Y_FRAME_COUNT
                );
                Enemy_width = GCDisplay::getWidth(EnemyImage);
                Enemy_height = GCDisplay::getHeight(EnemyImage);

        }

//movement
        void Enemy::move(double execution_time){               
                       
                                        yPosition+=execution_time*hast;
        }

        void Enemy::render(){

                                GCVector                frameIndex                =        GCVector(0,0);
                                GCVector                position                =        GCVector((int)xPosition,(int)yPosition);
                                GCAdjustment        adjustment                =        GCAdjustment(0.5,0.5);
                                GCDisplay::renderImage(EnemyImage,frameIndex,position,adjustment);

        }

        Enemy::~Enemy(){
                GCDisplay::closeImage(EnemyImage);
        }

---

Hope that should help! :D

I don't think it's a good idea to use a vector of this class. Better use a pointer (maybe a shared pointer). Otherwise Enemy will be copied over and over again, and the image would have to be copied over and over again (unless *that* is changed to a shared pointer).

Ah. The problem is probably because the Enemy class has non-static const member variables. The compiler was unable to properly generate a copy assignment operator because such copy assignment would logically involve assigning to those member variables, but that cannot be as they are const.

If they are supposed to be static const member variables, then declare them as such. Otherwise, they probably should be non-const.

Because you have constants in your class, the compiler was unable to generate a default assignment operator. And vector requires an assignment operator.
You should think about how you want copies of Enemy to be made and define such an assignment operator.

Nice!!

Changed the consts to non-consts and it worked :D

Haven't fully figured out the pointer part yet but i guess its a good idea to do so! :P

Anyway thanks for superfast answers!!

:D

Good to hear that. Is there any reason why your member variables are public instead of private?

It looks like your Enemy class does not have well defined copy-construction and assignment functionality. The following code would call closeImage twice on the same image:

Code:

---

{
    Enemy a;
    Enemy b = a;
}

---

As the designer of this class it is your duty to either ensure that these work correctly (however inefficient that may be) or that they are disabled. Otherwise you are likely to run into all kinds of problems later.
To disable these add the following code to your class:

Code:

---

private:
Enemy(const Enemy &);
Enemy& operator=(const Enemy&);

---

Quote:

---

Is there any reason why your member variables are public instead of private?

---

Not really:P
I tend to make things as accessible as possible since I'm not yet confident enough to keep things locked up. Simply proof of my newbieness ^^.

Thank you iMalc!

Surely a nice addition to the code. Made things a little easier for me ^^. Still learning how to do things properly, so it's a big help!

Thanks again guys! :)