मैं कंसोल को कैसे साफ कर सकता हूं

Question 1

जैसा कि शीर्षक में है। मैं C ++ में कंसोल को कैसे साफ कर सकता हूं?

Question 2

शुद्ध C ++ के लिए

आप नहीं कर सकते। C ++ में कंसोल की अवधारणा भी नहीं है।

यह प्रोग्राम एक प्रिंटर पर प्रिंट हो सकता है, एक फाइल में सीधे आउटपुट हो सकता है, या सभी प्रोग्राम के लिए दूसरे प्रोग्राम के इनपुट पर रीडायरेक्ट किया जा सकता है। यहां तक कि अगर आप C ++ में कंसोल को साफ कर सकते हैं, तो यह उन मामलों को काफी गड़बड़ कर देगा।

इस प्रविष्टि को COMP.lang.c ++ FAQ में देखें:

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

ओएस विशिष्ट

यदि यह अभी भी आपके प्रोग्राम में कंसोल को स्पष्ट करने के लिए समझ में आता है, और आप ऑपरेटिंग सिस्टम विशिष्ट समाधानों में रुचि रखते हैं, तो वे मौजूद हैं।

विंडोज के लिए (आपके टैग के अनुसार), इस लिंक को देखें:

हम असेंबली में कंसोल को कैसे साफ़ करते हैं?

संपादित करें: इस उत्तर का उपयोग करने से पहले उल्लेख किया गया था system("cls");, क्योंकि Microsoft ने ऐसा करने के लिए कहा था। हालाँकि टिप्पणियों में यह बताया गया है कि यह सुरक्षित काम नहीं है । मैंने इस समस्या के कारण Microsoft लेख के लिंक को हटा दिया है।

पुस्तकालय (कुछ हद तक पोर्टेबल)

ncurses एक पुस्तकालय है जो कंसोल हेरफेर का समर्थन करता है:

http://www.gnu.org/software/ncurses/ (पॉज़िक्स सिस्टम पर रन)
http://gnuwin32.sourceforge.net/packages/ncurses.htm (कुछ पुराना विंडोज पोर्ट)

Question 3

कंसोल 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);
}

यह खुशी से सभी संभावित त्रुटियों को नजरअंदाज करता है, लेकिन हे, यह सांत्वना समाशोधन है। नहीं की तरह system("cls")त्रुटियों को बेहतर ढंग से संभालता है।

* निक्स के लिए, आप आमतौर पर ANSI एस्केप कोड के साथ जा सकते हैं, इसलिए यह होगा:

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

इसके लिए उपयोग systemसिर्फ बदसूरत है।

Question 4

लिनक्स / यूनिक्स और शायद कुछ अन्य लोगों के लिए लेकिन 10 टीएच 2 से पहले विंडोज के लिए नहीं:

printf("\033c");

टर्मिनल रीसेट करेगा।

Question 5

पहिया को सुदृढ़ किए बिना मेरे लिए सबसे आसान तरीका है।

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

Question 6

विंडो कंसोल के लिए कई लाइनों का उत्पादन बेकार है..यह सिर्फ इसमें खाली लाइनें जोड़ता है। दुख की बात है कि, रास्ता विंडोज़ विशिष्ट है और इसमें conio.h (और clrscr () मौजूद नहीं हो सकता है, यह मानक हेडर भी नहीं है) या 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 );
  }

POSIX सिस्टम के लिए यह सरल है, आप ncurses या टर्मिनल फ़ंक्शन का उपयोग कर सकते हैं

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

Question 7

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

Question 8

स्क्रीन को साफ़ करने के लिए आपको पहले एक मॉड्यूल शामिल करना होगा:

#include <stdlib.h>

यह विंडोज़ कमांड आयात करेगा। तब आप बैच कमांड (जो कंसोल को संपादित करते हैं) को चलाने के लिए 'सिस्टम' फ़ंक्शन का उपयोग कर सकते हैं। C ++ में विंडोज पर, स्क्रीन को साफ करने का कमांड होगा:

system("CLS");

और यह कंसोल को साफ करेगा। पूरा कोड इस तरह दिखेगा:

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

using namespace std;

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

और आपको बस इतना ही चाहिए! सौभाग्य :)

Question 9

विंडोज में:

#include <cstdlib>

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

लिनक्स / यूनिक्स में:

#include <cstdlib>

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

Question 10

system("cls")स्क्रीन साफ़ करने के लिए उपयोग करें :

#include <stdlib.h>

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

Question 11

यह मैक पर देखने के लिए कठिन है क्योंकि इसमें विंडोज़ फ़ंक्शन तक पहुंच नहीं है जो स्क्रीन को साफ करने में मदद कर सकता है। मेरा सबसे अच्छा फिक्स लूप है और लाइनों को जोड़ना जब तक कि टर्मिनल स्पष्ट नहीं है और फिर प्रोग्राम चलाएं। हालाँकि यह उतना प्रभावी या मेमोरी फ्रेंडली नहीं है यदि आप इसे मुख्य रूप से और अक्सर उपयोग करते हैं।

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

Question 12

विंडोज में हमारे पास कई विकल्प हैं:

clrscr () (हेडर फ़ाइल: conio.h)
सिस्टम ("cls") (हेडर फ़ाइल: stdlib.h)

लिनक्स में, सिस्टम का उपयोग करें ("स्पष्ट") (हेडर फ़ाइल: stdlib.h)

Question 13

यहाँ यह करने के लिए एक सरल तरीका है:

#include <iostream>

using namespace std;

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

Question 14

सिस्टम का उपयोग करें :: कंसोल :: स्पष्ट ();

यह बफर को खाली (खाली) करेगा

Question 15

#include <cstdlib>

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

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

}

कहीं भी बस कॉल क्ल्स ()

Question 16

आप ऑपरेटिंग सिस्टम की स्पष्ट कंसोल विधि का उपयोग सिस्टम ("") के माध्यम से कर सकते हैं;
खिड़कियों के लिए यह सिस्टम ("cls") होगा; उदाहरण के लिए
और अलग-अलग ऑपरेटिंग सिस्टम के लिए तीन अलग-अलग कोड जारी करने के बजाय। बस एक तरीका है कि ओएस क्या चल रहा है बनाने के लिए।
आप यह पता लगाकर कर सकते हैं कि क्या अद्वितीय सिस्टम चर #ifdef
उदा के साथ मौजूद हैं

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

}

Question 17

संपादित करें: पूरी तरह से प्रश्न फिर से

बस परीक्षण करें कि वे किस सिस्टम पर हैं और सिस्टम के आधार पर सिस्टम कमांड भेजते हैं। हालांकि यह संकलन समय पर सेट किया जाएगा

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

यह पूरी तरह से एक नई विधि है!

Question 18

उपयोग: clrscr ();

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

Question 19

सबसे आसान तरीका कई बार धारा प्रवाहित करना होगा (आदर्श रूप से बड़ा तब किसी भी संभव कंसोल) 1024 * 1024 के आकार की संभावना है कि कोई कंसोल विंडो कभी भी नहीं हो सकती है।

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

  return 0;
}

इसके साथ एकमात्र समस्या सॉफ्टवेयर कर्सर है; प्लेटफ़ॉर्म / कंसोल के आधार पर वह ब्लिंकिंग चीज़ (या नॉन ब्लिंकिंग चीज़) कंसोल के अंत में होगी, जो कि इसके शीर्ष पर होती है। हालांकि यह कभी भी किसी भी परेशानी को प्रेरित नहीं करना चाहिए।