The code compiles and builds fine, but it immediately segfaults. I've looked at this for a while and have no idea why. Any help is appreciated. Thank you! Here's the code:

main.cpp

#include "SDL/SDL.h"
#include "Globals.h"
#include "Core.h"
#include "GameStates.h"
#include "Introduction.h"

int main(int argc, char** args)
{
 if(core.Initilize() == false)
{
    SDL_Quit();
}

while(core.desiredstate != core.Quit)
{
    currentstate->EventHandling();
    currentstate->Logic();
    core.ChangeState();
    currentstate->Render();
    currentstate->Update();
}
SDL_Quit();
}

Core.h

#ifndef CORE_H
#define CORE_H
#include "SDL/SDL.h"
#include <string>

class Core
{
public:
    SDL_Surface* Load(std::string filename);

    void ApplySurface(int X, int Y, SDL_Surface* source, SDL_Surface* destination);
    void SetState(int newstate);
    void ChangeState();

    enum state { Intro, STATES_NULL, Quit };

    int desiredstate, stateID;

    bool Initilize();

};

#endif

Core.cpp

#include "Core.h"
#include "SDL/SDL.h"
#include "Globals.h"
#include "Introduction.h"
#include <string>

/* Initilizes SDL subsystems */
bool Core::Initilize()
{
//Inits subsystems, reutrns false upon error
if(SDL_Init(SDL_INIT_EVERYTHING) == -1)
{
    return false;
}

SDL_WM_SetCaption("Game", NULL);

return true;
}

/* Loads surfaces and optimizes them */
SDL_Surface* Core::Load(std::string filename)
{
//The surface to be optimized
SDL_Surface* original = SDL_LoadBMP(filename.c_str());
//The optimized surface
SDL_Surface* optimized = NULL;

//Optimizes the image if it loaded properly
if(original != NULL)
{
    optimized = SDL_DisplayFormat(original);

    SDL_FreeSurface(original);

} else {
    //returns NULL upon error
    return NULL;
}

return optimized;
}

/* Blits surfaces */
void Core::ApplySurface(int X, int Y, SDL_Surface* source, SDL_Surface* destination)
{
//Stores the coordinates of the surface
SDL_Rect offsets;
offsets.x = X;
offsets.y = Y;

//Bits the surface if both surfaces are present
if(source != NULL && destination != NULL)
{
    SDL_BlitSurface(source, NULL, destination, &offsets);
}
}

/* Sets desiredstate to newstate */
void Core::SetState(int newstate)
{
if(desiredstate != Quit)
{
    desiredstate = newstate;
}
} 

/* Changes the game state */
void Core::ChangeState()
{
if(desiredstate != STATES_NULL && desiredstate != Quit)
{
    delete currentstate;

    switch(desiredstate)
    {
        case Intro:
            currentstate = new Introduction();
        break;
    }

    stateID = desiredstate;
    desiredstate = core.STATES_NULL;
}
}

Globals.h

#ifndef GLOBALS_H
#define GLOBALS_H
#include "SDL/SDL.h"
#include "Core.h"
#include "GameStates.h"

extern SDL_Surface* screen;

extern Core core;

extern GameStates* currentstate;

#endif

Globals.cpp

#include "Globals.h"
#include "SDL/SDL.h"
#include "GameStates.h"

SDL_Surface* screen = SDL_SetVideoMode(640, 480, 32, SDL_SWSURFACE);

Core core;

GameStates* currentstate = NULL;

GameStates.h

#ifndef GAMESTATES_H
#define GAMESTATES_H

class GameStates 
{
public:
    virtual void EventHandling() = 0;
    virtual void Logic() = 0;
    virtual void Render() = 0;
    virtual void Update() = 0;
};

#endif

Introduction.h

#ifndef INTRODUCTION_H
#define INTRODUCTION_H
#include "GameStates.h"
#include "Globals.h"

class Introduction : public GameStates
{
public:
    Introduction();

private:
    void EventHandling();
    void Logic();
    void Render();
    void Update();
    ~Introduction();

    SDL_Surface* test;
};

#endif

Introduction.cpp

#include "SDL/SDL.h"
#include "Core.h"
#include "Globals.h"
#include "Introduction.h"

/* Loads all the assets */
Introduction::Introduction()
{
test = core.Load("test.bmp");
}

void Introduction::EventHandling()
{
SDL_Event event;
while(SDL_PollEvent(&event))
{
    switch(event.type)
    {
        case SDL_QUIT:
            core.SetState(core.Quit);
        break;
    }
}
}

void Introduction::Logic()
{
//to be coded
} 

void Introduction::Render()
{
core.ApplySurface(30, 30, test, screen);
}

void Introduction::Update()
{
SDL_Flip(screen);
}

Introduction::~Introduction()
{
SDL_FreeSurface(test);
}

Sorry if the formatting is a bit off... Having to put four spaces for it to be put into a code block offset it a bit.

I ran it through gdb and this is what I got:

Program received signal SIGSEGV, Segmentation fault.
0x0000000000400e46 in main ()

Which isn't incredibly useful... Any help is appreciated. Thank you!