que - limpiar pantalla dev c++>
¿Cómo borras la pantalla de la consola en C? (12)
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.
¿Hay una forma "adecuada" de borrar la ventana de la consola en C, además de usar el system("cls") ?
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 ));
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");
}
}
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.
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.
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
Una solución probó en Windows (cmd.exe), Linux (Bash y zsh) y OS X (zsh):
#include <stdlib.h>
void clrscr()
{
system("@cls||clear");
}
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
}
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.
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.
#include <conio.h>
y use
clrscr()
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}.