Pour C++ pur
Tu ne peux pas. C++ n'a même pas le concept de console.
Le programme peut imprimer sur une imprimante, sortir directement dans un fichier ou être redirigé vers l’entrée d’un autre programme pour tous les soucis. 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 ++:
Spécifique à l'OS
S'il est toujours judicieux d'effacer la console de votre programme et que des solutions spécifiques au système d'exploitation vous intéressent, elles existent.
Pour Windows (comme dans votre tag), consultez ce lien:
Éditer: Cette réponse mentionnait précédemment l’utilisation de system("cls");, car Microsoft avait 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 de Microsoft à cause de ce problème.
Bibliothèques (quelque peu portables)
ncurses est une bibliothèque qui supporte la manipulation de console:
- http://www.gnu.org/software/ncurses/ (fonctionne sur les systèmes Posix)
- http://gnuwin32.sourceforge.net/packages/ncurses.htm (port Windows un 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, ça efface la console. Pas comme system("cls") gère mieux les erreurs.
Pour * nixes, vous pouvez généralement utiliser des codes d'échappement ANSI. Ce serait donc:
void clear() {
// CSI[2J clears screen, CSI[H moves the cursor to top-left corner
std::cout << "\x1B[2J\x1B[H";
}
Utiliser system pour cela est simplement moche.
Pour Linux/Unix et peut-être quelques autres mais pas pour Windows avant le 10 TH2:
printf("\033c");
va réinitialiser le terminal.
la sortie de plusieurs lignes sur la console de fenêtre est inutile .. elle ne fait qu'ajouter des lignes vides . Malheureusement, le chemin est spécifique à Windows et implique soit conio.h (et clrscr () peut ne pas exister, ce n'est pas un entête standard) 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 les systèmes POSIX, c'est 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;
}
Ceci est vraiment agité mais essayez:
void cls() {
for (int i = 0; i < 250; ++i) {
std::cout << endl;
}
}
Utilisez system("cls") pour effacer l'écran:
#include <stdlib.h>
int main(void)
{
system("cls");
return 0;
}
Pour effacer l'écran, vous devez d'abord inclure un module:
#include <stdlib.h>
cela importera des commandes Windows. Vous pouvez ensuite utiliser la fonction 'système' pour exécuter les commandes Batch (qui permettent d’éditer 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;
}
C'est difficile à faire sur MAC, vu qu'il n'a pas accès aux fonctions de Windows qui peuvent aider à effacer l'écran. Ma meilleure solution est de boucler et d’ajouter des lignes jusqu’à ce que le terminal soit vide, puis d’exécuter le programme. Toutefois, cela n’est pas aussi efficace ni plus 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);
}
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
}
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
}
Sous Windows, nous avons plusieurs options:
clrscr () (Fichier d'en-tête: conio.h)
system ("cls") (Fichier d'en-tête: stdlib.h)
Sous Linux, utilisez system ("clear") (Fichier d'en-tête: stdlib.h)