Wie kann ich die Konsole löschen?

Wie im Titel. Wie kann ich die Konsole in C ++ löschen?

Für reines C ++

Das kannst du nicht. C ++ hat nicht einmal das Konzept einer Konsole.

Das Programm kann auf einem Drucker gedruckt, direkt in eine Datei ausgegeben oder für alles, was es interessiert, auf die Eingabe eines anderen Programms umgeleitet werden. Selbst wenn Sie die Konsole in C ++ löschen könnten, würden diese Fälle erheblich unübersichtlicher.

Siehe diesen Eintrag in den comp.lang.c ++ FAQ:

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

Betriebssystemspezifisch

Wenn es immer noch sinnvoll ist, die Konsole in Ihrem Programm zu löschen, und Sie an betriebssystemspezifischen Lösungen interessiert sind, gibt es diese.

Überprüfen Sie für Windows (wie in Ihrem Tag) diesen Link:

• Wie löschen wir die Konsole in der Montage?

Bearbeiten: Diese Antwort wurde bereits mit verwendet system("cls");, da Microsoft dies angekündigt hat. In den Kommentaren wurde jedoch darauf hingewiesen, dass dies keine sichere Sache ist . Ich habe den Link zum Microsoft-Artikel aufgrund dieses Problems entfernt.

Bibliotheken (etwas tragbar)

ncurses ist eine Bibliothek, die die Manipulation von Konsolen unterstützt:

• http://www.gnu.org/software/ncurses/ (läuft auf Posix-Systemen)
• http://gnuwin32.sourceforge.net/packages/ncurses.htm (etwas alter Windows-Port)

Für Windows über die Konsolen-API:

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);
}

Es ignoriert glücklich alle möglichen Fehler, aber hey, es ist das Löschen der Konsole. Nicht wie system("cls")behandelt Fehler besser.

Für * nixes können Sie normalerweise ANSI-Escape-Codes verwenden.

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

Die Verwendung systemdafür ist einfach hässlich.

Für Linux / Unix und vielleicht einige andere, aber nicht für Windows vor 10 TH2:

printf("\033c");

wird das Terminal zurücksetzen.

Der einfachste Weg für mich, ohne das Rad neu erfinden zu müssen.

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

Das Ausgeben mehrerer Zeilen an die Fensterkonsole ist nutzlos. Es werden nur leere Zeilen hinzugefügt. Leider ist der Weg Windows-spezifisch und beinhaltet entweder conio.h (und clrscr () ist möglicherweise nicht vorhanden, das ist auch kein Standard-Header) oder die Win-API-Methode

#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 );
  }

Für POSIX-Systeme ist es viel einfacher, Sie können ncurses oder Terminalfunktionen verwenden

#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;
}

Um den Bildschirm zu löschen, müssen Sie zuerst ein Modul hinzufügen:

#include <stdlib.h>

Dadurch werden Windows-Befehle importiert. Anschließend können Sie mit der Funktion 'System' Stapelbefehle ausführen (mit denen die Konsole bearbeitet wird). Unter Windows in C ++ lautet der Befehl zum Löschen des Bildschirms:

system("CLS");

Und das würde die Konsole löschen. Der gesamte Code würde folgendermaßen aussehen:

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

using namespace std;

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

Und das ist alles was Sie brauchen! Viel Glück :)

In Windows:

#include <cstdlib>

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

Unter Linux / Unix:

#include <cstdlib>

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

Verwenden Sie system("cls"), um den Bildschirm zu löschen:

#include <stdlib.h>

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

Dies ist unter MAC schwierig, da es keinen Zugriff auf die Windows-Funktionen hat, die zum Löschen des Bildschirms beitragen können. Meine beste Lösung besteht darin, Zeilen zu schleifen und hinzuzufügen, bis das Terminal frei ist, und dann das Programm auszuführen. Dies ist jedoch nicht so effizient oder speicherfreundlich, wenn Sie dies hauptsächlich und häufig verwenden.

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

In Windows haben wir mehrere Optionen:

1. clrscr () (Header-Datei: conio.h)

2. system ("cls") (Header-Datei: stdlib.h)

Verwenden Sie unter Linux das System ("clear") (Header-Datei: stdlib.h)

Hier ist eine einfache Möglichkeit, dies zu tun:

#include <iostream>

using namespace std;

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

Verwenden Sie System :: Console :: Clear ();

Dadurch wird der Puffer gelöscht (geleert)

#include <cstdlib>

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

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

}}

Rufen Sie einfach überall cls () auf

Sie können die Clear Console-Methode des Betriebssystems über das System ("") verwenden.
für Windows wäre es System ("cls"); Zum Beispiel
und anstatt drei verschiedene Codes für verschiedene Betriebssysteme freizugeben. Machen Sie einfach eine Methode, um herauszufinden, was os läuft.
Sie können dies tun, indem Sie feststellen, ob mit #ifdef eindeutige Systemvariablen vorhanden sind,
z

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

}

Bearbeiten: Frage komplett überarbeitet

Testen Sie einfach, auf welchem ​​System sie sich befinden, und senden Sie je nach System einen Systembefehl. Dies wird jedoch zur Kompilierungszeit festgelegt

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

Dies ist eine völlig neue Methode!

benutze: clrscr ();

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

Der einfachste Weg wäre, den Stream mehrmals zu leeren (idealerweise größer als jede mögliche Konsole). 1024 * 1024 ist wahrscheinlich eine Größe, die kein Konsolenfenster jemals haben könnte.

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

  return 0;
}

Das einzige Problem dabei ist der Software-Cursor. Das blinkende (oder nicht blinkende) Ding befindet sich je nach Plattform / Konsole am Ende der Konsole und nicht oben. Dies sollte jedoch hoffentlich niemals zu Problemen führen.