que - limpiar pantalla dev c++>

¿Cómo borras la pantalla de la consola en C?

Question

¿Hay una forma "adecuada" de borrar la ventana de la consola en C, además de usar el system("cls") ?

Answer 1

Bueno, C no entiende el concepto de pantalla. Entonces, cualquier código no sería portátil. Tal vez eche un vistazo a conio.h o curses , de acuerdo a sus necesidades?

La portabilidad es un problema, sin importar qué biblioteca se use.

Answer 2

Como mencionas cls , parece que te refieres a Windows. Si es así, este elemento KB tiene el código que lo hará. Lo intenté y funcionó cuando lo llamé con el siguiente código:

cls( GetStdHandle( STD_OUTPUT_HANDLE ));

Answer 3

Esto debería funcionar. Entonces simplemente llame a cls (); cada vez que quiera borrar la pantalla.

(utilizando el método sugerido anteriormente)

#include <stdio.h>
void cls()
{
    int x;
    for ( x = 0; x < 10; x++ ) 
    {
        printf("/n/n/n/n/n/n/n/n/n/n/n/n/n/n/n/n");
    }
}

Answer 4

La forma correcta de hacerlo es mediante el uso de las funciones tput o terminfo para obtener propiedades de terminal y luego insertar nuevas líneas de acuerdo con las dimensiones.

Answer 5

No hay una forma portátil C para hacer esto. Aunque varias bibliotecas de manipulación del cursor como las maldiciones son relativamente portátiles. conio.h es portátil entre OS / 2 DOS y Windows, pero no para las variantes * nix.

La noción completa de una "consola" es un concepto fuera del alcance del estándar C.

Si está buscando una solución de API de Win32 pura, no hay una sola llamada en la API de consola de Windows para hacer esto. Una forma es FillConsoleOutputCharacter de un número suficientemente grande de caracteres. O WriteConsoleOutput Puede usar GetConsoleScreenBufferInfo para averiguar cuántos caracteres serán suficientes.

También puede crear un Buffer de pantalla de consola completamente nuevo y hacer el actual.

Answer 6

Para la portabilidad, intente esto:

#ifdef _WIN32
#include <conio.h>
#else
#include <stdio.h>
#define clrscr() printf("/e[1;1H/e[2J")
#endif

Entonces simplemente llame a clrscr() . En Windows, usará conio.h clrscr() , y en Linux, utilizará códigos de escape ANSI.

Si realmente quiere hacerlo "correctamente", puede eliminar a los intermediarios ( conio , printf , etc.) y hacerlo solo con las herramientas del sistema de bajo nivel (prepararse para un volcado de código masivo):

#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#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 );
}

#else // !_WIN32
#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" ) );
}
#endif

Answer 7

Una solución probó en Windows (cmd.exe), Linux (Bash y zsh) y OS X (zsh):

#include <stdlib.h>

void clrscr()
{
    system("@cls||clear");
}

Answer 8

Usando macros puedes verificar si estás en Windows, Linux, Mac o Unix, y llamar a la función respectiva dependiendo de la plataforma actual. Algo de la siguiente manera:

void clear(){
    #if defined(__linux__) || defined(__unix__) || defined(__APPLE__)
        system("clear");
    #endif

    #if defined(_WIN32) || defined(_WIN64)
        system("cls");
    #endif
}

Answer 9

Windows:

system("cls");

Unix:

system("clear");

En su lugar, podría insertar caracteres nuevos en la línea hasta que todo se dispare, eche un vistazo here .

Con eso, logras portabilidad fácilmente.

Answer 10

solo escriba clrscr (); función en el vacío principal ().

como ejemplo:

void main()
{
clrscr();
printf("Hello m fresher in programming c.");
getch();
}

clrscr();

función fácil de borrar la pantalla.

Answer 11

#include <conio.h>

y use

clrscr()

Answer 12

printf("/e[1;1H/e[2J");

Esta función funcionará en terminales ANSI, exige POSIX. Supongo que hay una versión que también podría funcionar en la consola de Windows, ya que también admite secuencias de escape ANSI.

#include <unistd.h>

void clearScreen()
{
  const char *CLEAR_SCREEN_ANSI = "/e[1;1H/e[2J";
  write(STDOUT_FILENO, CLEAR_SCREEN_ANSI, 12);
}

Hay algunas otras alternatives , algunas de las cuales no mueven el cursor a {1,1}.