erreur fatale LNK1169: un ou plusieurs symboles définis par multiplication trouvés dans la programmation du jeu

Question

Je me suis entraîné à utiliser la programmation orientée objet en c ++ mais je reçois toujours cette erreur:

1>main.obj : error LNK2005: "int WIDTH" (?WIDTH@@3HA) already defined in GameObject.obj
1>main.obj : error LNK2005: "int HEIGHT" (?HEIGHT@@3HA) already defined in GameObject.obj
1>Spaceship.obj : error LNK2005: "int WIDTH" (?WIDTH@@3HA) already defined in GameObject.obj
1>Spaceship.obj : error LNK2005: "int HEIGHT" (?HEIGHT@@3HA) already defined in GameObject.obj
1>C:\Users\ted\documents\visual studio 2010\Projects\fullSpace\Debug\fullSpace.exe : fatal error LNK1169: one or more multiply defined symbols found

Cependant, il me semble que le code entier est correctement écrit et que les deux entrées ne sont mentionnées que dans l'en-tête Global et que tous les objets semblent hériter correctement. Cependant, comme je viens de le dire, je suis un débutant en OOP donc j'ai vraiment besoin d'un avis: il convient également de mentionner que j'utilise allegro 5 pour créer un jeu de tir latéral.

Voici le code:

(principale):

#include <allegro5/allegro.h>
#include <allegro5/allegro_image.h>
#include <allegro5/allegro_primitives.h>
#include <allegro5/allegro_font.h>
#include <allegro5\allegro_ttf.h>
#include <allegro5\allegro_audio.h>
#include <allegro5\allegro_acodec.h>

#include <list>


#include "GameObject.h"
#include "Spaceship.h"
#include "Globals.h"



//controls

bool keys[] = {false, false, false, false, false};
enum KEYS{UP, DOWN, LEFT, RIGHT, SPACE};

//globals
Spaceship *ship;

std::list <GameObject *> objects;
std::list <GameObject *>::iterator iter;
std::list <GameObject *>::iterator iter2;



//prototypes



//main function
int main(int argc, char **argv)
{
    //Shell variables
    bool done = false;
    bool render = false;

    float gameTime = 0;
    int frames = 0;
    int gameFPS = 0;

    //project variables

    ship = new Spaceship();


    ALLEGRO_BITMAP *shipImage = NULL;
    ALLEGRO_BITMAP *cometImage= NULL;
    ALLEGRO_BITMAP *explImage = NULL;
    ALLEGRO_BITMAP *bgImage = NULL;
    ALLEGRO_BITMAP *mgImage = NULL;
    ALLEGRO_BITMAP *plImage = NULL;
    ALLEGRO_BITMAP *mgImage2 = NULL;
    ALLEGRO_BITMAP *fgImage = NULL;
    ALLEGRO_BITMAP *titleImage= NULL;
    ALLEGRO_BITMAP *lostImage = NULL;


    //allegro variables
    ALLEGRO_DISPLAY *display = NULL;
    ALLEGRO_EVENT_QUEUE *event_queue = NULL;
    ALLEGRO_TIMER *timer;
    ALLEGRO_FONT *font18;



    //initiate variables
    if(!al_init())
        return -1;

    display = al_create_display(WIDTH, HEIGHT);
    if(!display)
    return -1;

    //addon installation

    al_install_keyboard();
    al_init_image_addon();
    al_init_font_addon();
    al_init_ttf_addon();
    al_init_primitives_addon();
    al_install_audio();
    al_init_acodec_addon();

    //project init

    font18 = al_load_font("arial.ttf", 18, 0);
    al_reserve_samples(15);




    bgImage = al_load_bitmap("layer1.png");
    mgImage = al_load_bitmap("layer2.png");
    plImage = al_load_bitmap("starMG.png");
    mgImage2 = al_load_bitmap("layer3.png");
    fgImage = al_load_bitmap("layer4.png");




    shipImage = al_load_bitmap("spaceship.png");
    al_convert_mask_to_alpha(shipImage, al_map_rgb(255, 0, 255));



    cometImage = al_load_bitmap("asteroid-1-96.png");
    explImage = al_load_bitmap("explosion_3_40_128.png");

    titleImage = al_load_bitmap("Shooter_Title.png");
    lostImage = al_load_bitmap("Shooter_Lose.png");



    //object init
    ship->init(shipImage);


    //iter list
    objects.Push_back(ship);


    srand(time(NULL));

    //timer init and startup

    event_queue = al_create_event_queue();
    timer = al_create_timer(1.0 / 60);

    al_register_event_source(event_queue, al_get_timer_event_source(timer));
    al_register_event_source(event_queue, al_get_keyboard_event_source());

    al_start_timer(timer);
    gameTime = al_current_time();

    while(!done)
    {
        ALLEGRO_EVENT ev;
        al_wait_for_event(event_queue, &ev);

        //input
        if(ev.type == ALLEGRO_EVENT_KEY_DOWN)
        {
            switch(ev.keyboard.keycode)
            {
            case ALLEGRO_KEY_ESCAPE:
                done = true;
                break;
            case ALLEGRO_KEY_LEFT:
                keys[LEFT] = true;
                break;
            case ALLEGRO_KEY_RIGHT:
                keys[RIGHT] = true;
                break;
            case ALLEGRO_KEY_UP:
                keys[UP] = true;
                break;
            case ALLEGRO_KEY_DOWN:
                keys[DOWN] = true;
                break;
            case ALLEGRO_KEY_SPACE:
                keys[SPACE] = true;
                break;


            }
        } else if(ev.type == ALLEGRO_EVENT_KEY_UP)
        {
            switch(ev.keyboard.keycode)
            {
            case ALLEGRO_KEY_ESCAPE:
                done = true;
                break;
            case ALLEGRO_KEY_LEFT:
                keys[LEFT] = false;
                break;
            case ALLEGRO_KEY_RIGHT:
                keys[RIGHT] = false;
                break;
            case ALLEGRO_KEY_UP:
                keys[UP] = false;
                break;
            case ALLEGRO_KEY_DOWN:
                keys[DOWN] = false;
                break;
            case ALLEGRO_KEY_SPACE:
                keys[SPACE] = false;
                break;
            }
        }



        else if (ev.type == ALLEGRO_EVENT_TIMER)
        {
            render = true;

            //fps
            frames++;
            if(al_current_time() - gameTime >= 1)
            {
                gameTime = al_current_time();
                gameFPS = frames;
                frames = 0;
            }

            //shipUpdate

            if(keys[UP])
                ship ->moveUp();
            else if(keys[DOWN])
                ship ->moveDown();
            else
                ship->resetAnim(1);

            if(keys[LEFT])
                ship ->moveLeft();
            else if(keys[RIGHT])
                ship -> moveRight();
            else
                ship ->resetAnim(0);

        }
        //render

            if(render && al_is_event_queue_empty(event_queue))
            {
                render = false;

                //begin render
                for(iter = objects.begin(); iter != objects.end(); ++iter)
                    (*iter)->render();




                //Flip Buffers
                al_flip_display();
                al_clear_to_color(al_map_rgb(0,0,0));
            }
        }

                //destroy objects



        //visual objects
    al_destroy_bitmap(cometImage);
    for(iter = objects.begin(); iter != objects.end(); ++iter)
        (*iter)->destroy(shipImage);
        iter = objects.erase(iter);

    al_destroy_bitmap(explImage);
    al_destroy_bitmap(bgImage);
    al_destroy_bitmap(mgImage);
    al_destroy_bitmap(fgImage);
    al_destroy_bitmap(titleImage);
    al_destroy_bitmap(lostImage);

        //audio objects
    /*
    al_destroy_sample(shot);
    al_destroy_sample(boom);
    al_destroy_sample(song);
    al_destroy_sample_instance(songInstance);
    */


        //Shell objects
    al_destroy_font(font18);
    al_destroy_timer(timer);
    al_destroy_event_queue(event_queue);
    al_destroy_display(display);

    return 0;
}

(Globals.h):

#pragma once

int WIDTH = 1024;
int HEIGHT = 800;

enum ID{PLAYER, ENEMY, BULLET, BORDER, MISC};
enum STATES{TITLE, PLAYING, LOST};

(GameObject.h):

#pragma once


#include "Globals.h"
#include <iostream>

#include <allegro5/allegro5.h>

#include <allegro5/allegro_primitives.h>



class GameObject
{
private:
    int ID;
    bool alive;
    bool collidable;

protected:
    float x;
    float y;

    float velX;
    float velY;

    int dirX;
    int dirY;

    int boundX;
    int boundY;

    int maxFrame;
    int curFrame;
    int frameCount;
    int frameDelay;
    int frameWidth;
    int frameHeight;
    int animationColumns;
    int animationDirection;

    ALLEGRO_BITMAP *image;

public:
    GameObject();
    void virtual destroy(ALLEGRO_BITMAP *image);

    void init(float x, float y, float velX, float velY, int dirX, int dirY, int boundX, int boundY);
    void virtual update();
    void virtual render();

    float getX() {return x;}
    float getY() {return y;}

    void setX(float x) {GameObject::x = x;}
    void setY(float y) {GameObject::y = y;}

    int getBoundX() {return boundX;}
    int getBoundY() {return boundY;}

    int getID() {return ID;}
    void setID(int ID) {GameObject::ID = ID;}

    bool getAlive() {return alive;}
    void setAlive(bool alive) {GameObject::alive = alive;}

    bool getCollidable() {return collidable;}
    void setCollidable(bool collidable) {GameObject::collidable = collidable;}

    bool checkCollisions(GameObject *otherObject);
    void virtual collided(int objectID);
    bool collidableCheck();
};

(GameObject.cpp):

#include "GameObject.h"

GameObject::GameObject()
{
    x = 0;
    y = 0;

    velX = 0;
    velY = 0;

    dirX = 0;
    dirY = 0;

    boundX = 0;
    boundY = 0;

    maxFrame = 0;
    curFrame = 0;
    frameCount = 0;
    frameDelay = 0;
    frameWidth = 0;
    frameHeight = 0;
    animationColumns = 0;
    animationDirection = 0;

    image = NULL;

    alive = true;
    collidable = true;

}

void GameObject::destroy(ALLEGRO_BITMAP *image)
{
    if(image != NULL)
        al_destroy_bitmap(image);

}
void GameObject::init(float x, float y, float velX, float velY, int dirX, int dirY, int boundX, int boundY)
{
    GameObject::x = x;
    GameObject::y = y;

    GameObject::velX = velX;
    GameObject::velY = velY;

    GameObject::dirX = dirX;
    GameObject::dirY = dirY;

    GameObject::boundX = boundX;
    GameObject::boundY = boundY;

}

void GameObject::update()
{
    x += velX*dirX;
    y += velY*dirY;
}

void GameObject::render()
{

}

bool GameObject::checkCollisions(GameObject *otherObject)
{
    float oX = otherObject->getX();
    float oY = otherObject->getY();

    int obX = otherObject->getBoundX();
    int obY = otherObject->getBoundY();

    if(x + boundX > oX - obX &&
       x - boundX < oX + obX &&
       y + boundY > oY - obY &&
       y - boundY < oY + obY
       )
       return true;
    else
       return false;
}

void GameObject::collided(int objectID)
{

}
bool GameObject::collidableCheck()
{
    return alive && collidable;
}

(SpaceShip.h):

#pragma once

#include "GameObject.h"

class Spaceship : public GameObject
{
private :
    int lives;
    int score;
    int animationRow;

public :
    Spaceship();

    void destroy(ALLEGRO_BITMAP *image);

    void init(ALLEGRO_BITMAP *image = NULL);

    void update();
    void render();

    void moveUp();
    void moveDown();
    void moveLeft();
    void moveRight();

    void resetAnim(int pos);

    int getLives(){return lives;}

    int getScore() {return score;}

    void looseLife() {lives--;}
    void addPoint() {score++;}

    void collide(int objectID);



};

(SpaceShip.cpp):

#include "Spaceship.h"

    Spaceship::Spaceship()
    {}

    void Spaceship::destroy(ALLEGRO_BITMAP *image)
    {
        GameObject::destroy(image);
    }
    void Spaceship::init(ALLEGRO_BITMAP *image)
    {
        GameObject::init(20, 200, 6, 6, 0, 0, 10, 12);

        setID(PLAYER);
        setAlive(true);

        lives = 3;
        score = 0;

        maxFrame = 3;
        curFrame = 0;
        frameWidth = 46;
        frameHeight = 41;
        animationColumns = 3;
        animationDirection = 1;

        animationRow = 1;

        if(image != NULL)
        {
            Spaceship::image = image;
        }
    }

    void Spaceship::update()
    {
        GameObject::update();
        if(x < 0)
            x=0;
        else if ( x > WIDTH)
            x = WIDTH;
        if(y < 0)
            y = 0;
        else if (y > HEIGHT)
            y = HEIGHT;
    }
    void Spaceship::render()
    {
        GameObject::render();

        int fx = (curFrame % animationColumns) *frameWidth;
        int fy = animationRow *frameHeight;

        al_draw_bitmap_region(image, fx, fy, frameWidth, frameHeight,
            x - frameWidth /2, y - frameHeight /2, 0);

    }

    void Spaceship::moveUp()
    {
        animationRow = 0;
        dirY = -1;

    }
    void Spaceship::moveDown()
    {
        animationRow = 2;
        dirY = 1;
    }
    void Spaceship::moveLeft()
    {
        curFrame = 2;
        dirX = -1;
    }
    void Spaceship::moveRight()
    {
        curFrame = 1;
        dirX = 1;
    }

    void Spaceship::resetAnim(int pos)
    {
        if(pos == 1)
        {
            animationRow = 1;
            dirY = 0;
        }
        else
        {
            curFrame = 0;
            dirX = 0;
        }
    }

    void Spaceship::collide(int objectID)
    {
        if(objectID == ENEMY)
            lives--;

    }

Answer 1

Les deux variables int sont définies dans le fichier d'en-tête. Cela signifie que chaque fichier source qui inclut l'en-tête contiendra sa définition (l'inclusion d'en-tête est purement textuelle). Bien sûr, cela entraîne de multiples erreurs de définition.

Vous avez plusieurs options pour résoudre ce problème.

1. Faites les variables static (static int WIDTH = 1024;). Ils existeront toujours dans chaque fichier source, mais leurs définitions ne seront pas visibles en dehors du fichier source.

2. Transformez leurs définitions en déclarations en utilisant extern (extern int WIDTH;) et mettez la définition dans n fichier source: int WIDTH = 1024;.

3. Probablement la meilleure option: faites les variables const (const int WIDTH = 1024;). Cela les rend static implicitement, et leur permet également d'être utilisées comme constantes de compilation, permettant au compilateur d'utiliser directement leur valeur au lieu d'émettre du code pour la lire à partir de la variable, etc.

Answer 2

Vous ne pouvez pas mettre de définitions de variable dans les fichiers d'en-tête, car ceux-ci feront alors partie de tous les fichiers source dans lesquels vous incluez l'en-tête.

Le #pragma once est juste pour se protéger contre plusieurs inclusions dans le même fichier source, pas contre plusieurs inclusions dans plusieurs fichiers source.

Vous pouvez déclarer les variables sous la forme extern dans le fichier d'en-tête, puis définir les dans un seul fichier source. O vous pourriez déclarer les variables comme const dans le fichier d'en-tête et ensuite le compilateur et l'éditeur de liens le géreront.

Answer 3

const int WIDTH = 1024;
const int HEIGHT = 800;

Answer 4

ajoutez simplement/FORCE comme drapeau de l'éditeur de liens et vous êtes prêt.

par exemple, si vous travaillez sur CMakeLists.txt. Ajoutez ensuite la ligne suivante:

SET(CMAKE_EXE_LINKER_FLAGS  "/FORCE")