輸入處理程序功能中的分段錯誤

Question

每當我移動操縱桿時，我都會遇到段錯誤。 我認為這與std :: vector> m_joystickValues;有關； 是真的，這是否應該有垃圾回收器，如果在書中有錯，我該用什么來代替它，是否是因為Vector2d.h中的某些函數是const並且某些值正在更改？ 這是內存泄漏嗎？ 我需要改變什么？

Gdb輸出：

Thread 1 "a.out" received signal SIGSEGV, Segmentation fault.
0x0000555555557bb3 in InputHandler::update (this=0x555556fae710)
    at InputHandler.cpp:81
81              m_joystickValues[whichOne].first->setX(0);
(gdb) frame 81
#0  0x0000000000000000 in ?? ()
(gdb) bt
#0  0x0000555555557bb3 in InputHandler::update (this=0x555556fae710)
    at InputHandler.cpp:81 
#1  0x0000555555556851 in Game::handleEvents (this=0x5555557732b0)
    at Game.cpp:107
#2  0x000055555555980f in main (argc=1, argv=0x7fffffffded8) at main.cpp:35

(gdb) frame 0
#0  0x0000555555557bb3 in InputHandler::update (this=0x555556fae710)
    at InputHandler.cpp:81
81              m_joystickValues[whichOne].first->setX(0);

(gdb) frame 1
#1  0x0000555555556851 in Game::handleEvents (this=0x5555557732b0)
    at Game.cpp:107
107     TheInputHandler::Instance()->update();

(gdb) frame 2
#2  0x000055555555980f in main (argc=1, argv=0x7fffffffded8) at main.cpp:35
35          TheGame::Instance()->handleEvents();

(gdb) where
#0  0x0000555555557bb3 in InputHandler::update (this=0x555556fae710)
    at InputHandler.cpp:81
#1  0x0000555555556851 in Game::handleEvents (this=0x5555557732b0)
    at Game.cpp:107
#2  0x000055555555980f in main (argc=1, argv=0x7fffffffded8) at main.cpp:35

main.cpp

// the basic functions of a game engine

#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include "Enemy.h"
#include "Game.h"
#include "GameObject.h"
#include "InputHandler.h"
#include "Player.h"
#include "LoaderParams.h"
#include "TextureManager.h"
#include "SDLGameObject.h"
#include "Vector2d.h"

//our game object

Game* g_game = 0;

const int FPS = 60;
const int DELAY_TIME = 1000.0f / FPS;

int main(int argc, char* argv[])
{
    Uint32 frameStart, frameTime;

    std::cout <<"game init attempt";
    if(TheGame::Instance()->init("Chapter 1", 100, 100, 640, 480,
    false))
    {
        frameStart = SDL_GetTicks();

         std::cout <<"game init success!\n";
        while(TheGame::Instance()->running())
        {
        TheGame::Instance()->handleEvents();
        TheGame::Instance()->update();
        TheGame::Instance()->render();

        frameTime = SDL_GetTicks() - frameStart;

        if(frameTime< DELAY_TIME)
        {
            SDL_Delay((int) (DELAY_TIME - frameTime));      
        }
    }
}
    else
    {
        std::cout<<"game init failure - " << SDL_GetError() << "\n";
        return -1;
    }
    std::cout<<"game closing";
    TheGame::Instance()->clean();

    return 0;
}

InputHandler.h

#ifndef __InputHandler__
#define __InputHandler__

#include <iostream>
#include <vector>
#include <utility>
#include <SDL2/SDL.h>
#include "Game.h"
#include "Vector2d.h"

class InputHandler
{
    public:

     static InputHandler* Instance()
     {
         if(s_pInstance == 0)
        {
            s_pInstance = new InputHandler();
        }
        return s_pInstance;
    }

    void update();
    void clean();

    void initialiseJoysticks();
    bool joysticksInitialised() {
         return m_bjoysticksInitialised; }

        int xvalue(int joy, int stick);
        int yvalue(int joy, int stick);

    private:

    InputHandler() {}

    static InputHandler* s_pInstance;

    const int m_joystickDeadZone = 1000;

     std::vector<SDL_Joystick*> m_joysticks;

     std::vector<std::pair<Vector2d*, Vector2d*>> m_joystickValues;

     bool m_bjoysticksInitialised;

};

 typedef InputHandler TheInputHandler;

 #endif /*defined (InputHandler) */

InputHandler.cpp

#include "InputHandler.h"

InputHandler* InputHandler::s_pInstance= 0;

void InputHandler::initialiseJoysticks()
{

     if(SDL_WasInit(SDL_INIT_JOYSTICK) == 0)
     {
        SDL_InitSubSystem(SDL_INIT_JOYSTICK);
     }

         if(SDL_NumJoysticks() > 0)
         {
            for(int i = 0; i < SDL_NumJoysticks(); i++)
            {
             SDL_Joystick* joy = SDL_JoystickOpen(i);
                 if(SDL_JoystickOpen(i) == 1)
                 {
                     m_joysticks.push_back(joy);
                     m_joystickValues.push_back(std::make_pair(new
                     Vector2d(0,0),new Vector2d(0,0))); //add our pair
                 }
                else
                {
                     std::cout << SDL_GetError();
                 }
             }


         SDL_JoystickEventState(SDL_ENABLE);
         m_bjoysticksInitialised = true;

        std::cout<< "Initialised " << m_joysticks.size() << 
        "joystick(s)";
         }
              else
            {
                 m_bjoysticksInitialised = false;
            }
}


void InputHandler::clean()
{
     if(m_bjoysticksInitialised)
     {
        for(unsigned int i = 0; i < SDL_NumJoysticks(); i++)
        {
             SDL_JoystickClose(m_joysticks[i]);
        }
    }
}

 void InputHandler::update()
 {
     SDL_Event event;
     while(SDL_PollEvent(&event))
     {
          if(event.type == SDL_QUIT)
         {
             TheGame::Instance()->quit();
         }
     if(event.type == SDL_JOYAXISMOTION)
     {
         int whichOne = event.jaxis.which;

         //left stick move left or right
         if(event.jaxis.axis == 0)
         {
             if(event.jaxis.value > m_joystickDeadZone)
             {
                 m_joystickValues[whichOne].first->setX(1);
             }
         else if(event.jaxis.value < -m_joystickDeadZone)
         {
               m_joystickValues[whichOne].first->setX(-1);
         }
         else
         {
             m_joystickValues[whichOne].first->setX(0);
         }

 }

// left stick move up or down
if(event.jaxis.axis == 1)
{
     if(event.jaxis.value > m_joystickDeadZone)
     {
         m_joystickValues[whichOne].first->setY(1);
     }
     else if(event.jaxis.value < -m_joystickDeadZone)
     {
         m_joystickValues[whichOne].first->setY(-1);
     }
     else
    {
         m_joystickValues[whichOne].first->setY(0);
    }
}

//right stick move left or right
if(event.jaxis.axis == 3)
 {
     if(event.jaxis.value > m_joystickDeadZone)
     {
         m_joystickValues[whichOne].second->setX(1);
     }
     else if(event.jaxis.value < -m_joystickDeadZone)
    {
         m_joystickValues[whichOne].second->setX(-1);
    }
    else
     {
         m_joystickValues[whichOne].second->setX(0);
     }
 }

  //right stick move up or down
 if(event.jaxis.axis == 4)
 {
     if(event.jaxis.value > m_joystickDeadZone)
      {
        m_joystickValues[whichOne].second->setY(1);
    }
      else if(event.jaxis.value < -m_joystickDeadZone)
     {
        m_joystickValues[whichOne].second->setY(-1);
    }
     else
     {
    ``m_joystickValues[whichOne].second->setY(0);
    }
}
}
 }
}   

int InputHandler::xvalue(int joy, int stick)
 {
     if(m_joystickValues.size() > 0)
     {
         if(stick == 1)
         {
            return m_joystickValues[joy].first->getX();
         }
         else if(stick == 2)
            {
                 return m_joystickValues[joy].second->getX();
            }
    }
     return 0;
}

 int InputHandler::yvalue(int joy, int stick)
 {
     if(m_joystickValues.size() > 0)
     {
        if(stick == 1)
         {
             return m_joystickValues[joy].first->getY();
        }
         else if(stick == 2)
         {
              return m_joystickValues[joy].second->getY();
         }
     }
     return 0;
 }

Vector2d.h

#ifndef __Vector2d__
#define __Vector2d__

#include <math.h>
#include <iostream>
#include <vector>
#include <utility>

class Vector2d
{
    public:
    Vector2d(float x, float y) : m_x(x), m_y(y) {}

     float getX() { return m_x; }
     float getY() { return m_y; }

    void setX(float x) { m_x = x; }
    void setY(float y) { m_y = y; }

     float length() { return sqrt(m_x * m_x + m_y * m_y) ; }

    Vector2d operator+ (const Vector2d& v2) const
    {
    return Vector2d (m_x + v2.m_x, m_y + v2.m_y);
    }

    friend Vector2d& operator +=(Vector2d& v1, const Vector2d& v2)
    {
        v1.m_x += v2.m_x;
        v1.m_y += v2.m_y;

        return v1;
    }

     Vector2d operator* (float scalar)
     {
         return Vector2d(m_x * scalar, m_y * scalar);
     }

     Vector2d& operator*= (float scalar)
     {
         m_x *= scalar;
         m_y *= scalar;

        return *this;
    }

     Vector2d operator- (const Vector2d& v2) const
    {
         return Vector2d(m_x - v2.m_x, m_y - v2.m_y);
    }

    friend Vector2d& operator-=(Vector2d& v1, const Vector2d& v2)
    {
        v1.m_x -= v2.m_x;
        v1.m_y -= v2.m_y;

        return v1;

    }

     Vector2d operator/(float scalar)
    {
         return Vector2d(m_x / scalar, m_y / scalar);
    }

    Vector2d& operator/=(float scalar)
     {
         m_x /= scalar;
         m_y /= scalar;

        return *this;
     }

    void normalize()
     {
         float l = length();
         if ( l > 0 )
         {
            (*this) *= l/1;
         }  
     }

     private:

    float m_x;
    float m_y;
 };

 #endif /*defined (Vector2D) */

Answer 1

功能SDL_Joystick* SDL_JoystickOpen(int device_index)返回一個指向SDL_Joystick*所以你可能需要更換線路if(SDL_JoystickOpen(i) == 1)在input_handler.cpp由if(SDL_JoystickOpen(i))或只是if(joy)