compte à rebours en c++ et +

#include <iostream>
#include <time.h>

int main()
{
    clock_t chrono;
    double temps = 0;
    int secondes_restantes;
    int TEMPS_BONUS = 10;

    while (secondes_restantes > 0)
    {

        secondes_restantes = TEMPS_BONUS - temps;

        //...Jeu
        temps = (int(clock() - temps) / 1000);

        system("cls");
        std::cout << "Temps restant : " << secondes_restantes << "\n";

    }

}

#include <iostream>
#include <time.h>

bool Pause (int);

int main (int argc, char **argv)
{

    bool continuer = true;
    bool pause = false;

    int temps_bonus = 15;
    int temps_restant = temps_bonus;

    int temps_compte = 0;
    double temps_ecoule = 0;
    int temps_total = 0;
    double t1 = 0;
    double t2 = 0;


    while (continuer)
    {


        t1 = t2;
        t2 = clock();
        temps_ecoule += t2 - t1;

        if (temps_ecoule >= 1000)
        {
            temps_ecoule = 0;
            temps_total ++;

            if (!pause)
            {

                temps_compte ++;

                temps_restant = temps_bonus - temps_compte;

                if (temps_restant <= 0)
                {
                    continuer = false;
                }
            }

        }


        pause = Pause (temps_total);

        system ("cls");
        std::cout << "temps total : " << temps_total
        << "\n temps compte : " << temps_compte
        << "\n temps restant : " << temps_restant;


    }

    system ("cls");
    std::cout << "temps total : " << temps_total
    << "\n temps compte : " << temps_compte
    << "\n temps restant : " << temps_restant;
    std::cout << "\n\n";

    system ("PAUSE");
    return 0;
}

bool Pause (int t)
{
    bool retour = false;
    // simule une	Pause de 3 secondes: t = 5, t =  6 , t =  7
    if (t > 4 && t < 8)
    {
        retour = true;
    }
    return retour;
}

if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_SPACE)
{
(pause % 2) ? pause == false : pause = true;
} 

if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_SPACE)
{
(pause % 2) ? pause = false : pause = true; // J'avais mis == à la place de =
} 

      (T2 = clock())
T1 .......T2  
      (T2 devient T1)       (T2 = clock())
           ....................T2
                         (T2 devient T1)             (T2 = clock())
                                 .......................T2 
                                                      (T2 devient T1)

               (1) (2) (3) (4) (5) (6) (7) (8) (9) (10)(11)(12)(13)(14)
___________________________|  PAUSE    |_______________________________|FIN
temps_total :  +++.+++.+++.|+++.+++.+++|.+++.+++.+++.+++.+++.+++.+++.+++.
temps_compte : +++.+++.+++.|           |.+++.+++.+++.+++.+++.+++.+++.+++.

Tours:   Temps:
1         0.33s (temps_ecoule = 0 + 0.33)
2         0.77s (temps_ecoule = 0.33 + 0.77 = 1s, donc temps_total++,
                 et temps_ecoule remis à 0)
3         0.25s (temps_ecoule = 0 + 0.25)
4         0.60s (temps_ecoule = 0.25 + 0.60 = 0.85)
5         0.15s (temps_ecoule = 0.85 + 0.15 = 1s, donc temps_total++,
                et temps_ecoule remis à 0)
...
et ainsi de suite

if (event.key==SDLK_SPACE)
{
(pause % 2) ? pause = false : pause = true;
/* pause % 2 = 1 donc vrai si l'utilisateur appui pour pause
 pause % 2 = 0 donc faux si il appui un nombre pair de fois,
donc pour enlever la pause, en fonction du résultat,
on enlève ou met la pause avec pause = false ou pause = true */
}

#include <SDL.h>
#include <time.h>
#include <iostream>
#include <SDL_ttf.h>

int main(int argc, char *argv[])
{
    //***********SDL**************//
    SDL_Surface *ecran = NULL, *texte = NULL;
    SDL_Init(SDL_INIT_VIDEO);
    ecran = SDL_SetVideoMode(1024, 768, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
    SDL_Flip(ecran);
    SDL_Event event;
    SDL_Rect posText;
    char ch_compt[20] = "";
    bool continuer = true;

    //***********Variable pour pause *************//
    bool pause = false;

    int temps_bonus = 15;
    int temps_restant = temps_bonus;

    int temps_compte = 0;
    double temps_ecoule = 0;
    double t1 = 0;
    double t2 = 0;

    //*************Variable Texte ********//
    if (TTF_Init() == -1)
    {
        fprintf(stderr, "Erreur d'initialisation de Arial.ttf : %s\n", TTF_GetError());
        exit(EXIT_FAILURE);
    }
    TTF_Font *police = NULL;
    police = TTF_OpenFont("arial.ttf", 25);
    SDL_Color couleurRouge = {255, 0, 0};
    posText.x = 150;
    posText.y = 150;

    SDL_BlitSurface(texte, NULL, ecran, &posText);



    //************Boucle******************//

    while (continuer)
    {

        SDL_PollEvent(&event);

        t1 = t2;
        t2 = clock();
        temps_ecoule += t2 - t1;

        if (temps_ecoule >= 1000) // Si on passe une seconde,
        {
            temps_ecoule = 0;      // On remet temps_ecoule a 0.

            if (!pause)                  // Et si on n'est pas sur pause :
            {

                temps_compte ++;
                temps_restant = temps_bonus - temps_compte; // On descend le temps restant.


                sprintf(ch_compt, "Temps restant : %d", temps_restant);
                texte = TTF_RenderText_Blended(police, ch_compt, couleurRouge);

                if (temps_restant <= 0)
                {
                    continuer = false;     // Si le temps restant est inferieur à 0, on stoppe le jeu
                }
            }


        }



        if (event.type == SDL_KEYDOWN)
        {
            if (event.key.keysym.sym == SDLK_UP)  // Flèche du haut pour stopper la pause
            {
                pause = false;
            }
            if (event.key.keysym.sym == SDLK_DOWN)  // Flèche du bas pour l'activer
            {
                pause = true;
            }
            if (event.key.keysym.sym == SDLK_ESCAPE)  // Echap pour fermer la fenetre
            {
                continuer = false;
            }
        }

        if (!pause)     // Si il n'y a pas la pause :
        {

                    // Les variables de la matrice peuvent-être modifiées ici

        }




        SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
        SDL_BlitSurface(texte, NULL, ecran, &posText);
        SDL_Flip(ecran);
    }


    SDL_FreeSurface(ecran);

    SDL_Quit();
    return EXIT_SUCCESS;

}