Comment puis-je effacer la console

Comme dans le titre. Comment puis-je effacer la console en C ++?

Pour du C ++ pur

Vous ne pouvez pas. C ++ n'a même pas le concept de console.

Le programme peut être en train d'imprimer sur une imprimante, de sortir directement dans un fichier ou d'être redirigé vers l'entrée d'un autre programme pour tout ce qu'il veut. Même si vous pouviez effacer la console en C ++, cela rendrait ces cas beaucoup plus compliqués.

Voir cette entrée dans la FAQ comp.lang.c ++:

• http://www.parashift.com/c++-faq-lite/input-output.html#faq-15.20

Spécifique au système d'exploitation

S'il est toujours judicieux de vider la console de votre programme et que vous êtes intéressé par des solutions spécifiques au système d'exploitation, celles-ci existent.

Pour Windows (comme dans votre balise), consultez ce lien:

• Comment effacer la console en assemblage?

Edit: Cette réponse précédemment mentionnée en utilisant system("cls");, car Microsoft a dit de le faire. Cependant, il a été souligné dans les commentaires que ce n'est pas une chose sûre à faire . J'ai supprimé le lien vers l'article Microsoft à cause de ce problème.

Bibliothèques (quelque peu portables)

ncurses est une bibliothèque qui prend en charge la manipulation de la console:

• http://www.gnu.org/software/ncurses/ (fonctionne sur les systèmes Posix)
• http://gnuwin32.sourceforge.net/packages/ncurses.htm (port Windows quelque peu ancien)

Pour Windows, via l'API de la console:

void clear() {
    COORD topLeft  = { 0, 0 };
    HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_SCREEN_BUFFER_INFO screen;
    DWORD written;

    GetConsoleScreenBufferInfo(console, &screen);
    FillConsoleOutputCharacterA(
        console, ' ', screen.dwSize.X * screen.dwSize.Y, topLeft, &written
    );
    FillConsoleOutputAttribute(
        console, FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE,
        screen.dwSize.X * screen.dwSize.Y, topLeft, &written
    );
    SetConsoleCursorPosition(console, topLeft);
}

Il ignore heureusement toutes les erreurs possibles, mais bon, c'est l'effacement de la console. Pas comme system("cls")gère mieux les erreurs.

Pour les * nixes, vous pouvez généralement utiliser des codes d'échappement ANSI, donc ce serait:

void clear() {
    // CSI[2J clears screen, CSI[H moves the cursor to top-left corner
    std::cout << "\x1B[2J\x1B[H";
}

Utiliser systempour cela est juste moche.

Pour Linux / Unix et peut-être quelques autres mais pas pour Windows avant 10 TH2:

printf("\033c");

réinitialise le terminal.

Le moyen le plus simple pour moi sans avoir à réinventer la roue.

void Clear()
{
#if defined _WIN32
    system("cls");
#elif defined (__LINUX__) || defined(__gnu_linux__) || defined(__linux__)
    system("clear");
#elif defined (__APPLE__)
    system("clear");
#endif
}

la sortie de plusieurs lignes sur la console de la fenêtre est inutile..il y ajoute simplement des lignes vides. malheureusement, la manière est spécifique à Windows et implique soit conio.h (et clrscr () peut ne pas exister, ce n'est pas non plus un en-tête standard) ou la méthode API Win

#include <windows.h>

void ClearScreen()
  {
  HANDLE                     hStdOut;
  CONSOLE_SCREEN_BUFFER_INFO csbi;
  DWORD                      count;
  DWORD                      cellCount;
  COORD                      homeCoords = { 0, 0 };

  hStdOut = GetStdHandle( STD_OUTPUT_HANDLE );
  if (hStdOut == INVALID_HANDLE_VALUE) return;

  /* Get the number of cells in the current buffer */
  if (!GetConsoleScreenBufferInfo( hStdOut, &csbi )) return;
  cellCount = csbi.dwSize.X *csbi.dwSize.Y;

  /* Fill the entire buffer with spaces */
  if (!FillConsoleOutputCharacter(
    hStdOut,
    (TCHAR) ' ',
    cellCount,
    homeCoords,
    &count
    )) return;

  /* Fill the entire buffer with the current colors and attributes */
  if (!FillConsoleOutputAttribute(
    hStdOut,
    csbi.wAttributes,
    cellCount,
    homeCoords,
    &count
    )) return;

  /* Move the cursor home */
  SetConsoleCursorPosition( hStdOut, homeCoords );
  }

Pour le système POSIX, c'est beaucoup plus simple, vous pouvez utiliser ncurses ou des fonctions de terminal

#include <unistd.h>
#include <term.h>

void ClearScreen()
  {
  if (!cur_term)
    {
    int result;
    setupterm( NULL, STDOUT_FILENO, &result );
    if (result <= 0) return;
    }

  putp( tigetstr( "clear" ) );
  }

// #define _WIN32_WINNT 0x0500     // windows >= 2000 
#include <windows.h> 
#include <iostream>

using namespace std; 

void pos(short C, short R)
{
    COORD xy ;
    xy.X = C ;
    xy.Y = R ;
    SetConsoleCursorPosition( 
    GetStdHandle(STD_OUTPUT_HANDLE), xy);
}
void cls( )
{
    pos(0,0);
    for(int j=0;j<100;j++)
    cout << string(100, ' ');
    pos(0,0);
} 

int main( void )
{
    // write somthing and wait 
    for(int j=0;j<100;j++)
    cout << string(10, 'a');
    cout << "\n\npress any key to cls... ";
    cin.get();

    // clean the screen
    cls();

    return 0;
}

Pour effacer l'écran, vous devrez d'abord inclure un module:

#include <stdlib.h>

cela importera les commandes Windows. Ensuite, vous pouvez utiliser la fonction «système» pour exécuter des commandes Batch (qui éditent la console). Sous Windows en C ++, la commande pour effacer l'écran serait:

system("CLS");

Et cela effacerait la console. Le code entier ressemblerait à ceci:

#include <iostream>
#include <stdlib.h>

using namespace std;

int main()
{
system("CLS");
}

Et c'est tout ce dont vous avez besoin! Bonne chance :)

Sous Windows:

#include <cstdlib>

int main() { 
    std::system("cls");
    return 0;
}

Sous Linux / Unix:

#include <cstdlib>

int main() { 
    std::system("clear");
    return 0;
}

Utilisez system("cls")pour effacer l'écran:

#include <stdlib.h>

int main(void)
{
    system("cls");
    return 0;
}

C'est difficile à faire sur MAC car il n'a pas accès aux fonctions Windows qui peuvent aider à effacer l'écran. Ma meilleure solution est de boucler et d'ajouter des lignes jusqu'à ce que le terminal soit clair, puis d'exécuter le programme. Cependant, ce n'est pas aussi efficace ou convivial pour la mémoire si vous l'utilisez principalement et souvent.

void clearScreen(){
    int clear = 5;
    do {
        cout << endl;
        clear -= 1;
    } while (clear !=0);
}

Sous Windows, nous avons plusieurs options:

1. clrscr () (Fichier d'en-tête: conio.h)

2. system ("cls") (Fichier d'en-tête: stdlib.h)

Sous Linux, utilisez system ("clear") (Header File: stdlib.h)

Voici un moyen simple de le faire:

#include <iostream>

using namespace std;

int main()
{
    cout.flush(); // Flush the output stream
    system("clear"); // Clear the console with the "system" function
}

Utilisez System :: Console :: Clear ();

Cela effacera (videra) le tampon

#include <cstdlib>

void cls(){
#if defined(_WIN32) //if windows
    system("cls");

#else
    system("clear");    //if other
#endif  //finish

}

L'appel juste cls () n'importe où

Vous pouvez utiliser la méthode de la console claire du système d'exploitation via system ("");
pour Windows, ce serait system ("cls"); par exemple
et au lieu de publier trois codes différents pour différents systèmes d'exploitation. il suffit de créer une méthode pour obtenir ce que OS est en cours d'exécution.
vous pouvez le faire en détectant si des variables système uniques existent avec #ifdef
par exemple

enum OPERATINGSYSTEM = {windows = 0, mac = 1, linux = 2 /*etc you get the point*/};

void getOs(){
    #ifdef _WIN32
        return OPERATINGSYSTEM.windows
    #elif __APPLE__ //etc you get the point

    #endif
}

int main(){
    int id = getOs();
    if(id == OPERATINGSYSTEM.windows){
        system("CLS");
    }else if (id == OPERATINGSYSTEM.mac){
        system("CLEAR");
    } //etc you get the point

}

edit: question complètement refaite

Testez simplement le système sur lequel ils se trouvent et envoyez une commande système en fonction du système. bien que cela soit défini au moment de la compilation

#ifdef __WIN32
    system("cls");
#else
    system("clear"); // most other systems use this
#endif

C'est une méthode complètement nouvelle!

utilisez: clrscr ();

#include <iostream>
using namespace std;
int main()
      {           
         clrscr();
         cout << "Hello World!" << endl;
         return 0;
      }

Le moyen le plus simple serait de vider le flux plusieurs fois (idéalement plus grand que n'importe quelle console possible) 1024 * 1024 est probablement une taille qu'aucune fenêtre de console ne pourrait jamais être.

int main(int argc, char *argv)
{
  for(int i = 0; i <1024*1024; i++)
      std::cout << ' ' << std::endl;

  return 0;
}

Le seul problème avec ceci est le curseur logiciel; cette chose clignotante (ou non clignotante) en fonction de la plate-forme / de la console sera à la fin de la console, opposée au dessus de celle-ci. Cependant, cela ne devrait jamais causer de problèmes, espérons-le.