This app requiested Runtime to terminate

/*#define INCLUDE_CAPP
#include "globals.h"*/
#include "d:\Programing\LIBRARIES\SDL\Projects\card_game2\card\Card.h"
#include "d:\Programing\LIBRARIES\SDL\Projects\card_game2\deck\Deck.h"
 
const int width = 800;
const int height = 600;
const int fps = 20;
const int bpp = 32;
const int screen_flag = SDL_HWSURFACE | SDL_DOUBLEBUF;
 
const char * const caption = "Example";
 
int main( int argc, char **argv ) {
    /*CApp app( width, height, bpp, fps, screen_flag, caption );
    return app.main_loop();*/
    
    SDL_Init( SDL_INIT_EVERYTHING );
    
    Deck o;
    //o.shuffle_deck();
    
    SDL_Quit();
    
    return SUCCES;
}

//#include "d:\Programing\LIBRARIES\SDL\Projects\Example\globals.h"
#include "d:\Programing\LIBRARIES\SDL\Projects\card_game2\card\Card.h"
#include <SDL/SDL.h>
#include <vector>
 
#ifndef DECK_H
#define DECK_H
 
//----------------CARD_TYPES----------------------------------
enum {
    Two = 1, Three, Four, Five, Six, Seven, Eight, Nine, Ten,
    Jack, Queen, King, Ace, Face
};
//------------------------------------------------------------
        
        
//----------------CARD_SUIT-----------------------------------
enum {
    Hearts = 1, Diamonds, Spades, Clubs
};
//------------------------------------------------------------
 
class Deck
{
    public:
        Deck( Cint = 53 );
        
        void shuffle_deck();
        void deal( Deck*, Cint );
        
        static bool load_cards();
        static void clean_image();
        
        std::vector< Card > cards;
        
    private:
    public: 
        int deck_size;
        //static std::vector< SDL_Surface* > card_image;
        
        void put_card_on_top( const Card& );
        const Card& get_top_card() const;
        void remove_card();
};
 
#endif

#include "Deck.h"
 
//==========================STATIC=====================================
//std::vector< SDL_Surface* > Deck::card_image( 14 );
 
 
//========================CONSTRUCTOR==================================
Deck::Deck( Cint size ) : deck_size( size ), cards( deck_size ) {
}
//====================================================================
 
 
 
//=====================STATIC_FUNC_TO_FREE_MEMORY====================
void Deck::clean_image() {
    /*for( int i = 0; i < card_image.size(); i++ )
        SDL_FreeSurface( card_image[i] );*/
}
//====================================================================
 
 
 
 
//====================================================================
void Deck::shuffle_deck() {
    
    /*//-------SHUFFLE_CARD_SUIT-----------------------------------------
    int count = 0;
    for( int i = 0; i < deck_size; i++ ) {
        cards[i].set_suit( ( count == 0 ? Hearts :
                          ( count == 1 ? Clubs  :
                          ( count == 2 ? Spades :
                          ( count == 3 ? Diamonds : count = count )))));
        count = ( count == 3 ? 0 : count + 1 );
    }
    //----------------------------------------------------------------
    
    //-------SHUFFLE_CARD_TYPES---------------------------------------
    count = 2;
    for( int i = 0; i < deck_size; i++ ) {
        cards[i].set_face( ( count == 2 ? Two :
                          ( count == 3 ? Three :
                          ( count == 4 ? Four :
                          ( count == 5 ? Five :
                          ( count == 6 ? Six :
                          ( count == 7 ? Seven :
                          ( count == 8 ? Eight :
                          ( count == 9 ? Nine :
                          ( count == 10 ? Ten :
                          ( count == 11 ? Jack :
                          ( count == 12 ? Queen :
                          ( count == 13 ? King :
                          ( count == 14 ? Ace : 
                            count = count ))))))))))))));
        count = ( count == 14 ? 2 : count + 1 ); 
    }
    //----------------------------------------------------------------
    
    
    for( int i = 0; i < deck_size * 100; i++ ) {
        std::swap( cards[0 + rand() % deck_size], cards[0 + rand() %
                                                deck_size] );
    }
    
    int j;
        
    for( int i = 0; i < deck_size; i++ ) {
        LOG( "\ni = " );
        LOG( i );
        LOG( "\t" );
        
        j = cards[i].get_face();
        std::string tmp;
        
        switch( j ) {
            case Two:
                tmp = "Two";
                break;
            
            case Three:
                tmp = "Three";
                break;
                
            case Four:
                tmp = "Four";
                break;
            
            case Five:
                tmp = "Five";
                break;
                
            case Six:
                tmp = "Six";
                break;
                
            case Seven:
                tmp = "Seven";
                break;
                
            case Eight:
                tmp = "Eight";
                break;
                
            case Nine:
                tmp = "Nine";
                break;
                
            case Ten:
                tmp = "Ten";
                break;
                
            case Jack:
                tmp = "Jack";
                break;
                
            case Queen:
                tmp = "Queen";
                break;
                
            case King:
                tmp = "King";
                break;
                
            case Ace:
                tmp = "Ace";
                break;
        }
        
        LOG( tmp );
        LOG( " of " );
        
        j = cards[i].get_suit();
        LOG( ( j == Hearts ? "Hearts" : 
             ( j == Diamonds ? "Diamonds" :
             ( j == Spades ? "Spades" :
             ( j == Clubs ? "Clubs" : "NULL" ) ) ) ) );     
    }*/
}
//====================================================================
 
 
 
 
//=================STATIC_FUNC_TO_LOAD_CARD_IMAGES====================
bool Deck::load_cards() {
    
    /*for( int i = 0; i < card_image.size(); i++ )
        card_image[i] = NULL;
        
    card_image[0] = CSurface::Load_image( "gfx/Two.png" );
    card_image[1] = CSurface::Load_image( "gfx/Three.png" );
    card_image[2] = CSurface::Load_image( "gfx/Four.png" );
    card_image[3] = CSurface::Load_image( "gfx/Five.png" );
    card_image[4] = CSurface::Load_image( "gfx/Six.png" );
    card_image[5] = CSurface::Load_image( "gfx/Seven.png" );
    card_image[6] = CSurface::Load_image( "gfx/Eight.png" );
    card_image[7] = CSurface::Load_image( "gfx/Nine.png" );
    card_image[8] = CSurface::Load_image( "gfx/Ten.png" );
    card_image[9] = CSurface::Load_image( "gfx/Jack.png" );
    card_image[10] = CSurface::Load_image( "gfx/Queen.png" );
    card_image[11] = CSurface::Load_image( "gfx/King.png" );
    card_image[12] = CSurface::Load_image( "gfx/Ace.png" );
    card_image[13] = CSurface::Load_image( "gfx/Face.bmp" );
    
    
    for( int i = 0; i < card_image.size(); i++ ) {
        if( card_image[i] == NULL ) {
            LOG( "\nLoad error, image ID = " );
            LOG( i );
            return ERROR;
        }
    }*/
    
    return SUCCES;
}
//====================================================================
 
 
 
 
//====================================================================
void Deck::deal( Deck *dealer, Cint n_cards ) {
    
    if( n_cards > cards.size() )
        return;
        
    for( int i = 0; i < n_cards; i++ ) {
        dealer->put_card_on_top( get_top_card() );
        remove_card();
    }
    
}
//====================================================================
 
 
 
 
//====================================================================
void Deck::put_card_on_top( const Card &card ) {    
    cards[deck_size++] = card;
}
//====================================================================
 
 
 
 
//====================================================================
const Card& Deck::get_top_card() const {
    return cards[deck_size];    
}
//====================================================================
 
 
 
//====================================================================
void Deck::remove_card() {
    deck_size--;
}
//====================================================================

#include "d:\Programing\LIBRARIES\SDL\Projects\Example\typedefs.h"
 
#ifndef CARD_H
#define CARD_H
 
class Card
{
    public:
        Card();
        
        void set_suit( Cint );
        void set_face( Cint );
        
        int get_suit() const;
        int get_face() const;
        
    private:
        int suit;
        int face;
};
 
#endif

#include "Card.h"
 
Card::Card() : suit( 0 ), face( 0 ) {}
 
void Card::set_suit( Cint s ) {
    suit = s;
}
 
void Card::set_face( Cint f ) {
    face = f;
}
 
int Card::get_suit() const {
    return suit;
}
 
int Card::get_face() const {
    return face;
}