Jak mogę wyczyścić konsolę

Jak w tytule. Jak wyczyścić konsolę w C ++?

Dla czystego C ++

Nie możesz. C ++ nie ma nawet koncepcji konsoli.

Program może drukować na drukarce, wysyłać bezpośrednio do pliku lub być przekierowywany do wejścia innego programu na wszystko, na czym mu zależy. Nawet gdybyś mógł wyczyścić konsolę w C ++, spowodowałoby to znacznie większy bałagan.

Zobacz ten wpis w FAQ comp.lang.c ++:

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

Specyficzne dla systemu operacyjnego

Jeśli wyczyszczenie konsoli w programie nadal ma sens, a interesują Cię rozwiązania specyficzne dla systemu operacyjnego, takie istnieją.

W przypadku systemu Windows (jak w tagu) sprawdź ten link:

• Jak wyczyścić konsolę podczas montażu?

Edycja: ta odpowiedź wcześniej wspomniała o użyciu system("cls");, ponieważ Microsoft powiedział, że to zrobi. Jednak w komentarzach wskazano, że nie jest to bezpieczne . Usunąłem łącze do artykułu firmy Microsoft z powodu tego problemu.

Biblioteki (nieco przenośne)

ncurses to biblioteka obsługująca manipulowanie konsolą:

• http://www.gnu.org/software/ncurses/ (działa w systemach Posix)
• http://gnuwin32.sourceforge.net/packages/ncurses.htm (nieco stary port Windows)

W przypadku systemu Windows za pośrednictwem konsoli 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);
}

Na szczęście ignoruje wszystkie możliwe błędy, ale hej, to czyszczenie konsoli. Nie system("cls")lepiej radzi sobie z błędami.

W przypadku * nixes zwykle można użyć kodów ucieczki ANSI, więc będzie to:

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

Używanie systemdo tego jest po prostu brzydkie.

Dla systemu Linux / Unix i może innych, ale nie dla systemu Windows przed 10 TH2:

printf("\033c");

zresetuje terminal.

Najłatwiejszy sposób bez konieczności odkrywania na nowo koła.

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

wysyłanie wielu wierszy do konsoli okna jest bezużyteczne… po prostu dodaje do niego puste wiersze. niestety metoda way jest specyficzna dla systemu Windows i obejmuje conio.h (a clrscr () może nie istnieć, to też nie jest standardowy nagłówek) lub metodę Win API

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

W przypadku systemu POSIX jest to znacznie prostsze, możesz użyć ncurses lub funkcji terminala

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

Aby wyczyścić ekran, musisz najpierw dołączyć moduł:

#include <stdlib.h>

spowoduje to zaimportowanie poleceń systemu Windows. Następnie możesz użyć funkcji „system” do uruchamiania poleceń wsadowych (edytujących konsolę). W systemie Windows w C ++ polecenie wyczyszczenia ekranu wyglądałoby tak:

system("CLS");

A to wyczyściłoby konsolę. Cały kod wyglądałby tak:

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

using namespace std;

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

I to wszystko, czego potrzebujesz! Powodzenia :)

W systemie Windows:

#include <cstdlib>

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

W systemie Linux / Unix:

#include <cstdlib>

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

Użyj, system("cls")aby wyczyścić ekran:

#include <stdlib.h>

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

Jest to trudne do zrobienia na komputerze MAC, ponieważ nie ma on dostępu do funkcji systemu Windows, które mogą pomóc w wyczyszczeniu ekranu. Moim najlepszym rozwiązaniem jest zapętlenie i dodawanie wierszy, aż terminal będzie czysty, a następnie uruchom program. Jednak nie jest to tak wydajne ani przyjazne dla pamięci, jeśli używasz tego głównie i często.

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

W systemie Windows mamy wiele opcji:

1. clrscr () (Plik nagłówkowy: conio.h)

2. system ("cls") (Plik nagłówkowy: stdlib.h)

W Linuksie użyj system („wyczyść”) (plik nagłówkowy: stdlib.h)

Oto prosty sposób na zrobienie tego:

#include <iostream>

using namespace std;

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

Użyj System :: Console :: Clear ();

Spowoduje to wyczyszczenie (opróżnienie) bufora

#include <cstdlib>

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

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

}

Wystarczy wywołać cls () w dowolnym miejscu

Możesz użyć przejrzystej metody konsoli systemu operacyjnego za pośrednictwem systemu („”);
dla Windows byłby to system ("cls"); na przykład
i zamiast wydawać trzy różne kody dla różnych systemów operacyjnych. po prostu utwórz metodę, aby uzyskać działający system operacyjny.
możesz to zrobić, wykrywając, czy istnieją unikalne zmienne systemowe z #ifdef,
np

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

}

edycja: całkowicie przerobione pytanie

Po prostu sprawdź, w jakim systemie są włączone i wyślij polecenie systemowe w zależności od systemu. chociaż zostanie to ustawione w czasie kompilacji

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

To zupełnie nowa metoda!

użyj: clrscr ();

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

Najłatwiejszym sposobem byłoby wielokrotne opróżnianie strumienia (najlepiej większe niż jakakolwiek możliwa konsola) 1024 * 1024 to rozmiar, którego nie mogłoby nigdy mieć okno konsoli.

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

  return 0;
}

Jedynym problemem jest kursor programowy; ta migająca rzecz (lub niemigająca rzecz) w zależności od platformy / konsoli będzie na końcu konsoli, a nie na jej górnej części. Jednak, miejmy nadzieję, nie powinno to nigdy powodować żadnych problemów.