CODEWITHSUNDEEP
c++windowsconsole-application
Thomas B
Thomas B

Reputation: 1339

How can I clear console

As in the title. How can I clear console in C++?

Upvotes: 131

Views: 432981

Answers (20)

Negai
Negai

Reputation: 13

I don't that it is a good practice to use system commands (system("");) for these specific tasks so I made a function for clearing the console screen in C/C++ and it pretty much does the exact same functionality of the system("cls"); but just without calling a system command. (It is for Windows) you can copy this function to your C/C++ code so you can use this function to clear the console screen but check that Windows.h library is included in your code. Here is the code:

void clrscr() {
    DWORD Unused = 0;
    CONSOLE_SCREEN_BUFFER_INFO csbi;
    COORD zerozeroc = {0, 0};
    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
    DWORD Length = csbi.dwSize.X * csbi.dwSize.Y;
    FillConsoleOutputCharacterW(GetStdHandle(STD_OUTPUT_HANDLE), ' ', Length, zerozeroc, &Unused);
    FillConsoleOutputAttribute(GetStdHandle(STD_OUTPUT_HANDLE), csbi.wAttributes, Length, zerozeroc, &Unused);
    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), zerozeroc);
}

Upvotes: 0

Merlyn Morgan-Graham
Merlyn Morgan-Graham

Reputation: 59111

For pure C++

You can't. C++ doesn't even have the concept of a console.

The program could be printing to a printer, outputting straight to a file, or being redirected to the input of another program for all it cares. Even if you could clear the console in C++, it would make those cases significantly messier.

See this entry in the comp.lang.c++ FAQ:

OS-Specific

If it still makes sense to clear the console in your program, and you are interested in operating system specific solutions, those do exist.

For Windows (as in your tag), check out this link:

Edit: This answer previously mentioned using system("cls");, because Microsoft said to do that. However it has been pointed out in the comments that this is not a safe thing to do. I have removed the link to the Microsoft article because of this problem.

Libraries (somewhat portable)

ncurses is a library that supports console manipulation:

Upvotes: 84

ASMCoder
ASMCoder

Reputation: 53

I'm using windows 10 terminal.

std::system("cls"); // cls or clear

Upvotes: 1

user3179329
user3179329

Reputation: 89

To clear the screen you will first need to include the following header:

#include <stdlib.h>

this will import windows commands. Then you can use the 'system' function to run Batch commands (which edit the console). On Windows in C++, the command to clear the screen would be:

system("CLS");

And that would clear the console. The entire code would look like this:

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

using namespace std;

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

And that's all you need! Goodluck :)

Upvotes: 4

Limtis
Limtis

Reputation: 115

Works really well:

#include <windows.h>

void clearscreen()
{
    HANDLE hOut;
    COORD Position;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    Position.X = 0;
    Position.Y = 0;
    SetConsoleCursorPosition(hOut, Position);
}

Upvotes: 1

capthehacker99
capthehacker99

Reputation: 11

If you're on Windows:

HANDLE h;
CHAR_INFO v3;
COORD v4;
SMALL_RECT v5;
CONSOLE_SCREEN_BUFFER_INFO v6;
if ((h = (HANDLE)GetStdHandle(0xFFFFFFF5), (unsigned int)GetConsoleScreenBufferInfo(h, &v6)))
{
    v5.Right = v6.dwSize.X;
    v5.Bottom = v6.dwSize.Y;
    v3.Char.UnicodeChar = 32;
    v4.Y = -v6.dwSize.Y;
    v3.Attributes = v6.wAttributes;
    v4.X = 0;
    *(DWORD *)&v5.Left = 0;
    ScrollConsoleScreenBufferW(h, &v5, 0, v4, &v3);
    v6.dwCursorPosition = { 0 };
    HANDLE v1 = GetStdHandle(0xFFFFFFF5);
    SetConsoleCursorPosition(v1, v6.dwCursorPosition);
}

This is what the system("cls"); does without having to create a process to do it.

Upvotes: 1

Joma
Joma

Reputation: 3859

The easiest way for me without having to reinvent the wheel.

void Clear()
{
#if defined _WIN32
    system("cls");
    //clrscr(); // including header file : conio.h
#elif defined (__LINUX__) || defined(__gnu_linux__) || defined(__linux__)
    system("clear");
    //std::cout<< u8"\033[2J\033[1;1H"; //Using ANSI Escape Sequences 
#elif defined (__APPLE__)
    system("clear");
#endif
}
  • On Windows you can use "conio.h" header and call clrscr function to avoid the use of system funtion.
#include <conio.h>
clrscr();
  • On Linux you can use ANSI Escape sequences to avoid use of system function. Check this reference ANSI Escape Sequences
    std::cout<< u8"\033[2J\033[1;1H";
  • On MacOS Investigating...

Upvotes: 44

Anurag Singh
Anurag Singh

Reputation: 21

In Windows we have multiple options :

  1. clrscr() (Header File : conio.h)

  2. system("cls") (Header File : stdlib.h)

In Linux, use system("clear") (Header File : stdlib.h)

Upvotes: 2

user9758081
user9758081

Reputation:

Here is a simple way to do it:

#include <iostream>

using namespace std;

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

Upvotes: 0

NoAngel
NoAngel

Reputation: 1108

For Linux/Unix and maybe some others but not for Windows before 10 TH2:

printf("\033c");

will reset terminal.

Upvotes: 40

Max Goddard
Max Goddard

Reputation: 77

This is hard for to do on MAC seeing as it doesn't have access to the windows functions that can help clear the screen. My best fix is to loop and add lines until the terminal is clear and then run the program. However this isn't as efficient or memory friendly if you use this primarily and often.

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

Upvotes: 3

jdb_jdb
jdb_jdb

Reputation: 19

#include <cstdlib>

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

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

}

The just call cls() anywhere

Upvotes: -1

Swift - Friday Pie
Swift - Friday Pie

Reputation: 14589

outputting multiple lines to window console is useless..it just adds empty lines to it. sadly, way is windows specific and involves either conio.h (and clrscr() may not exist, that's not a standard header either) or Win API method

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

For POSIX system it's way simpler, you may use ncurses or terminal functions

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

Upvotes: 10

Wesam
Wesam

Reputation: 1060

Use system("cls") to clear the screen:

#include <stdlib.h>

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

Upvotes: 2

LoveToCode
LoveToCode

Reputation: 306

In Windows:

#include <cstdlib>

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

In Linux/Unix:

#include <cstdlib>

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

Upvotes: 4

Firefox_
Firefox_

Reputation: 61

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

Upvotes: 5

vijay
vijay

Reputation: 1

use: clrscr();

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

Upvotes: -4

user3882139
user3882139

Reputation: 7

Use System::Console::Clear();

This will clear (empty) the buffer

Upvotes: -1

graphitemaster
graphitemaster

Reputation: 3723

The easiest way would be to flush the stream multiple times ( ideally larger then any possible console ) 1024*1024 is likely a size no console window could ever be.

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

  return 0;
}

The only problem with this is the software cursor; that blinking thing ( or non blinking thing ) depending on platform / console will be at the end of the console, opposed to the top of it. However this should never induce any trouble hopefully.

Upvotes: -8

Cat Plus Plus
Cat Plus Plus

Reputation: 129764

For Windows, via Console 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);
}

It happily ignores all possible errors, but hey, it's console clearing. Not like system("cls") handles errors any better.

For *nixes, you usually can go with ANSI escape codes, so it'd be:

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

Using system for this is just ugly.

Upvotes: 67

Related Questions