C como limpar a tela do programa em c

Edinei Almeida · 6 de junho de 2022

gente o primeiro comentário o o que o exercício pede e o código enorme e o que eu fiz kkk coloquei bastante coisa e com isso a tela ficou bastante poluída gostaria de saber como posso esta limpando a tela do programa após uma mensagem ou bloco de execução. não estou conseguindo usar o comando "cls" e também me falaram que não é uma boa prática.

//1. Faça um programa que receba 10 notas de uma turma e imprima as 5 primeiras notas digitas.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main()
{
	float notas[6]={0};
	int i = 0, retorno, cont;
	char vet1[4]={"sim"}, vet2[4]={"não"}, vet3[4];

	do{

		do{

			for (int j = 0; j < 4; j++)
			{
				printf("Digite a %d nota: \n", j+1);
				scanf("%f", &notas[j]);

				if (notas[j] < 0)
				{
					while (notas[j]<0 || notas[j]>10)
					{
					 	if (notas[j]<0)
					 	{
					 		printf(" voce digitou uma valor invalido menor que 0!\n");
					 		printf(" Digite novamente a nota %d: \n", j+1);
							scanf("%f", &notas[j]);	
					 	}
					 	if (notas[j]>10)
					 	{
					 		printf(" voce digitou uma valor invalido maior que 10!\n");
					 		printf(" Digite novamente a nota %d: \n", j+1);
							scanf("%f", &notas[j]);	
					 	}
						 	
					}
						
				}
				else
					if (notas[j]>10)
					{
						while (notas[j]<0 || notas[j]>10)
						{
						 	if (notas[j]>10)
						 	{
						 		printf(" voce digitou uma valor invalido maior que 10!\n");
						 		printf(" Digite novamente a nota %d: \n", j+1);
								scanf("%f", &notas[j]);	
						 	}
						 	if (notas[j]<0)
						 	{
						 		printf(" voce digitou uma valor invalido menor que 0!\n");
						 		printf(" Digite novamente a nota %d: \n", j+1);
								scanf("%f", &notas[j]);	
						 	}
							 	
						}
					}

				i++;
			}

		} while (i<4);

		for (int j = 0; j < 4; j++)
		{
			printf("a %d nota e: %.1f\n", j+1, notas[j]);
		}

		for (int j = 3; j >= 0; j--)
		{
			notas[4] = notas[4] + notas[j];
		}

		notas[5] = notas[4]/4;
		printf("a media e: %.1f\n", notas[5]);

		printf("deseja realizar a operaçao novamente? [sim-não]: \n");
		scanf("%s", vet3);

		if ( strcmp(vet3,vet1) == 0)
		{
			retorno = 1;

		}
		else if (strcmp(vet3,vet2) == 0)
		{
			retorno = 0;
		}
		else 
		{
			retorno = -1;

			
			do{

				printf("palavra invalida!\ndigite novamente, [sim-não]: \n");
				scanf("%s", vet3);

				if ( strcmp(vet3,vet1) == 0)
				{
					retorno = 1;
				}
				else if (strcmp(vet3,vet2) == 0)
				{
					retorno = 0;
				}
				else
				{
					retorno = -1;
				}

			}while(retorno == -1);
			
		}

	} while (retorno == 1);
		
	printf("fim\n");

	return 0;
}

Flávio Pedroza · 6 de junho de 2022

Se seu terminal suporta, uma maneira de colocar cores, mudar a posição do cursor, limpar a tela e etc. é usar Código escape ANSI

https://pt.wikipedia.org/wiki/Código_escape_ANSI#:~:text=Os códigos de escape ANSI,cor ou movendo o cursor.

https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797

veja se isso funciona:

printf("\e[1;1H\e[2J");//move o cursor para a linha 1, coluna 1 e depois limpa a tela

Edinei Almeida · 6 de junho de 2022

Citação
17 minutos atrás, Flávio Pedroza disse:
Se seu terminal suporta, uma maneira de colocar cores, mudar a posição do cursor, limpar a tela e etc. é usar Código escape ANSI

https://pt.wikipedia.org/wiki/Código_escape_ANSI#:~:text=Os códigos de escape ANSI,cor ou movendo o cursor.

https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797

veja se isso funciona:
printf("\e[1;1H\e[2J");//move o cursor para a linha 1, coluna 1 e depois limpa a tela
não entendi, como eu posso estar utilizando isso no meu codigo ?

Flávio Pedroza · 6 de junho de 2022

Por exemplo, logo no começo do do:

do{
		printf("\e[1;1H\e[2J");//move o cursor para a linha 1, coluna 1 e depois limpa a tela

		do{
			
			for (int j = 0; j < 4; j++)
			{

Em qualquer local que precise limpar a tela é só chamar esse printf

Pode ser que não funcione, caso seu terminal não tenha suporte.

arfneto · 6 de junho de 2022

Você usa Windows ou Linux? Como vai rodar seu programa? no terminal, na linha de comando? Só dentro de algum IDE? O que usa para programar?

Edinei Almeida · 6 de junho de 2022

20 minutos atrás, arfneto disse:

Você usa Windows ou Linux? Como vai rodar seu programa? no terminal, na linha de comando? Só dentro de algum IDE? O que usa para programar?

eu uso o sublime text 3, uso windows 10, quero rodar no terminal.

arfneto · 6 de junho de 2022

O windows 10 tem um Terminal, que você instala da loja, e a console. São ambientes diferentes. O terminal tem aceleração gráfica e roda Unicode. A console é o de sempre, a tela do cmd. Claro que é melhor usar o Terminal.

As sequências de escape --- como a que @Flávio Pedrozate mostrou --- são do ambiente Linux, clonado do Unix dos anos 80. E eram parte do software de antigos terminais da marca Digital, como os VT100 e VT240. Em geral são aceitas no Terminal, a "nova console do Windows" (nova em 2018).

Isso tudo é um inferno. No geral no Windows se usa outra coisa desde os 90 e que ainda funciona. Já postei isso aqui muitas vezes, e é algo assim:

int		cls()
{	// limpa a tela no windows, do jeito oficial
	CONSOLE_SCREEN_BUFFER_INFO		info;
	HANDLE		H = GetStdHandle(STD_OUTPUT_HANDLE);
	COORD		origem = { 0,0 };
	int			total = 0;
	if (H == INVALID_HANDLE_VALUE) return -1;
	GetConsoleScreenBufferInfo(H, &info);
	int r = FillConsoleOutputCharacter(H, (TCHAR)' ',
		info.dwSize.X * info.dwSize.Y,
		origem, &total);
	int s = FillConsoleOutputAttribute(
		H, info.wAttributes,
		info.dwSize.X * info.dwSize.Y,
		origem, &total);
	SetConsoleCursorPosition(H, origem);
	return 0;
};	// end cls()

E limpa a tela escrevendo espaços em tudo. A tela padrão tem 9001 linhas no Windows.

No Terminal as sequências "ESC[ coisas" devem funcionar de cara. Na console pode ter um caminho aí. Esta tudo muito bem explicado na documentação.

Ao lado as 2 opções no Windows 10

O terminal também abre sessões na nuvem e no Linux embutido no Windows

Marcos FRM · 6 de junho de 2022

A partir do Windows 10 1511, o veterano cmd.exe passou a suportar sequências de escape ANSI:

https://superuser.com/a/1050078

https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences

https://docs.microsoft.com/en-us/windows/console/setconsolemode

\e[1;1H e \e[2J citadas pelo @Flávio Pedroza estão na lista das suportadas. Precisa configurar ENABLE_VIRTUAL_TERMINAL_PROCESSING via SetConsoleMode(). Exemplo considerando a versão 1607 (Anniversary Update) ou superior:

https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences#example-of-select-anniversary-update-features

Marcos FRM · 7 de junho de 2022

Em 06/06/2022 às 16:25, Marcos FRM disse:

https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences#example-of-select-anniversary-update-features

Hoje testei e funciona direito no cmd.exe (o tradicional "Prompt de Comando"). Copie a função EnableVTMode() do link acima e chame-a no início de main(). Algo assim:

#include <windows.h>
#include <stdbool.h>
#include <stdio.h>

#define ANSI_BOLD_YELLOW  "\033[1;33m"
#define ANSI_BOLD_GREEN   "\033[1;32m"
#define ANSI_BOLD_RED     "\033[1;31m"
#define ANSI_RESET        "\033[0m"

#define ANSI_CLR_SCR      "\033[1;1H\033[2J"

bool EnableVTMode(void)
{
    // Set output mode to handle virtual terminal sequences
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    if (hOut == INVALID_HANDLE_VALUE)
    {
        return false;
    }

    DWORD dwMode = 0;
    if (!GetConsoleMode(hOut, &dwMode))
    {
        return false;
    }

    dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
    if (!SetConsoleMode(hOut, dwMode))
    {
        return false;
    }
    return true;
}

int main(void)
{
    bool fSuccess = EnableVTMode();
    if (!fSuccess)
    {
        printf("EnableVTMode() falhou, adeus\n");
        return -1;
    }

    printf(ANSI_CLR_SCR);
    printf(ANSI_BOLD_YELLOW "amarelo..." ANSI_RESET "\n");
    printf(ANSI_BOLD_GREEN "verde...." ANSI_RESET "\n");
    printf(ANSI_BOLD_RED "vermelho..." ANSI_RESET "\n");

    return 0;
}

arfneto · 7 de junho de 2022

1 hora atrás, Marcos FRM disse:

Hoje testei e funciona direito no cmd.exe (o tradicional "Prompt de Comando")

Desde que esteja rodando uma versão de Windows não mais antiga do que a que diz na documentação vai sempre funcionar. Isso seria build 18298, versão 19H1 oficialmente.

A documentação em português (quase tudo) está aqui

O exemplo do fabricante:

// System headers
#include <windows.h>

// Standard library C-style
#include <wchar.h>
#include <stdlib.h>
#include <stdio.h>

#define ESC "\x1b"
#define CSI "\x1b["

bool EnableVTMode()
{
    // Set output mode to handle virtual terminal sequences
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    if (hOut == INVALID_HANDLE_VALUE)
    {
        return false;
    }

    DWORD dwMode = 0;
    if (!GetConsoleMode(hOut, &dwMode))
    {
        return false;
    }

    dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
    if (!SetConsoleMode(hOut, dwMode))
    {
        return false;
    }
    return true;
}

void PrintVerticalBorder()
{
    printf(ESC "(0"); // Enter Line drawing mode
    printf(CSI "104;93m"); // bright yellow on bright blue
    printf("x"); // in line drawing mode, \x78 -> \u2502 "Vertical Bar"
    printf(CSI "0m"); // restore color
    printf(ESC "(B"); // exit line drawing mode
}

void PrintHorizontalBorder(COORD const Size, bool fIsTop)
{
    printf(ESC "(0"); // Enter Line drawing mode
    printf(CSI "104;93m"); // Make the border bright yellow on bright blue
    printf(fIsTop ? "l" : "m"); // print left corner 

    for (int i = 1; i < Size.X - 1; i++)
        printf("q"); // in line drawing mode, \x71 -> \u2500 "HORIZONTAL SCAN LINE-5"

    printf(fIsTop ? "k" : "j"); // print right corner
    printf(CSI "0m");
    printf(ESC "(B"); // exit line drawing mode
}

void PrintStatusLine(const char* const pszMessage, COORD const Size)
{
    printf(CSI "%d;1H", Size.Y);
    printf(CSI "K"); // clear the line
    printf(pszMessage);
}

int __cdecl wmain(int argc, WCHAR* argv[])
{
    argc; // unused
    argv; // unused
    //First, enable VT mode
    bool fSuccess = EnableVTMode();
    if (!fSuccess)
    {
        printf("Unable to enter VT processing mode. Quitting.\n");
        return -1;
    }
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    if (hOut == INVALID_HANDLE_VALUE)
    {
        printf("Couldn't get the console handle. Quitting.\n");
        return -1;
    }

    CONSOLE_SCREEN_BUFFER_INFO ScreenBufferInfo;
    GetConsoleScreenBufferInfo(hOut, &ScreenBufferInfo);
    COORD Size;
    Size.X = ScreenBufferInfo.srWindow.Right - ScreenBufferInfo.srWindow.Left + 1;
    Size.Y = ScreenBufferInfo.srWindow.Bottom - ScreenBufferInfo.srWindow.Top + 1;

    // Enter the alternate buffer
    printf(CSI "?1049h");

    // Clear screen, tab stops, set, stop at columns 16, 32
    printf(CSI "1;1H");
    printf(CSI "2J"); // Clear screen

    int iNumTabStops = 4; // (0, 20, 40, width)
    printf(CSI "3g"); // clear all tab stops
    printf(CSI "1;20H"); // Move to column 20
    printf(ESC "H"); // set a tab stop

    printf(CSI "1;40H"); // Move to column 40
    printf(ESC "H"); // set a tab stop

    // Set scrolling margins to 3, h-2
    printf(CSI "3;%dr", Size.Y - 2);
    int iNumLines = Size.Y - 4;

    printf(CSI "1;1H");
    printf(CSI "102;30m");
    printf("Windows 10 Anniversary Update - VT Example");
    printf(CSI "0m");

    // Print a top border - Yellow
    printf(CSI "2;1H");
    PrintHorizontalBorder(Size, true);

    // // Print a bottom border
    printf(CSI "%d;1H", Size.Y - 1);
    PrintHorizontalBorder(Size, false);

    wchar_t wch;

    // draw columns
    printf(CSI "3;1H");
    int line = 0;
    for (line = 0; line < iNumLines * iNumTabStops; line++)
    {
        PrintVerticalBorder();
        if (line + 1 != iNumLines * iNumTabStops) // don't advance to next line if this is the last line
            printf("\t"); // advance to next tab stop

    }

    PrintStatusLine("Press any key to see text printed between tab stops.", Size);
    wch = _getwch();

    // Fill columns with output
    printf(CSI "3;1H");
    for (line = 0; line < iNumLines; line++)
    {
        int tab = 0;
        for (tab = 0; tab < iNumTabStops - 1; tab++)
        {
            PrintVerticalBorder();
            printf("line=%d", line);
            printf("\t"); // advance to next tab stop
        }
        PrintVerticalBorder();// print border at right side
        if (line + 1 != iNumLines)
            printf("\t"); // advance to next tab stop, (on the next line)
    }

    PrintStatusLine("Press any key to demonstrate scroll margins", Size);
    wch = _getwch();

    printf(CSI "3;1H");
    for (line = 0; line < iNumLines * 2; line++)
    {
        printf(CSI "K"); // clear the line
        int tab = 0;
        for (tab = 0; tab < iNumTabStops - 1; tab++)
        {
            PrintVerticalBorder();
            printf("line=%d", line);
            printf("\t"); // advance to next tab stop
        }
        PrintVerticalBorder(); // print border at right side
        if (line + 1 != iNumLines * 2)
        {
            printf("\n"); //Advance to next line. If we're at the bottom of the margins, the text will scroll.
            printf("\r"); //return to first col in buffer
        }
    }

    PrintStatusLine("Press any key to exit", Size);
    wch = _getwch();

    // Exit the alternate buffer
    printf(CSI "?1049l");

}

Onde tem a mesma EnableVTMode()

Sobre o exemplo da Microsoft / @Marcos FRM

O essencial é essa definição de dwMode, ligando o tal Virtual Terminal Processing

    dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;

E essa linha

    if (!SetConsoleMode(hOut, dwMode)) { return false; }
    return true;

provavelmente estaria melhor assim

    return SetConsoleMode(hOut, dwMode);

Já que é exatamente isso que vai fazer: retornar o que vier de SetConsoleMode.

Os números mágicos: sequências como "\033[;H\033[2J"

Para algum idoso ou alguém que saiba disso por outro modo que não a lenta passagem do tempo isso não será novidade, mas essas sequências são as dos terminais da marca Digital como os VT100 dos tempos do Unix, dos anos 70/80.

\033 é uma constante octal, o conhecido 27, o 0x1B e é o código do ESCAPE na tabela ASCII. Enviar essa tecla faz o terminal entrar em modo de programação.

ESC[ é o prefixo de muitos comandos.

H é o comando de posicionamento do cursor, ep ; separa linha e coluna. Assim ESC [ 1 ; 1 H leva o cursor para a primeira linha e coluna da tela. Pode ser ESC[0;0H também. Ou mesmo ESC[;H também serve.

ESC[2J

Esse comando apaga a tela toda. Mas não move o cursor. Por isso a sequência do exemplo usa o H primeiro: coloca o cursor no início da tela e depois apaga tudo.

Claro que podia ser ao contrário:

#define ANSI_CLR_SCR "\033[2J\033[;H"

Essas linhas

    printf(ANSI_CLR_SCR);
    printf(ANSI_BOLD_YELLOW "amarelo..." ANSI_RESET "\n");
    printf(ANSI_BOLD_GREEN "verde...." ANSI_RESET "\n");
    printf(ANSI_BOLD_RED "vermelho..." ANSI_RESET "\n");

provavelmente estariam melhor assim

    printf(
ANSI_CLR_SCR "\n"
ANSI_BOLD_YELLOW "amarelo...\n"
ANSI_BOLD_GREEN  "verde....\n"
ANSI_BOLD_RED    "vermelho...\n"
ANSI_RESET
    );

Que é mais fácil de ler e entender o que está sendo enviado para o terminal, além de ser dezenas de vezes mais rápido porque vai chamar só uma vez printf().

@Marcos FRM qual a razão desses ANSI_RESET no meio das sequências? Não precisa nesse caso. Acho que só se tivesse algum atributo em uso para as letras, tipo piscante ou sublinhado.

\033c

Pois é: não precisa de tudo aquilo: ESCAPE c limpa a tela.

Note que se inclui windows.h pode usar EXIT_SUCCESS e EXIT_FAILURE as constantes padrão, ao invés de retornar true ou false em C e ter que incluir o folclórico header stdbool em C.

OUTRO EXEMPLO

Esse outro exemplo inclui as coisas que eu disse

E mostra

O código

#include <stdio.h>
#include <windows.h>

#define ANSI_BOLD_YELLOW "\033[1;33m"
#define ANSI_BOLD_GREEN "\033[1;32m"
#define ANSI_BOLD_RED "\033[1;31m"
#define ANSI_RESET "\033[0m"

#define LIMPA_A_TELA "\033c"

int EnableVTMode(void)
{
    // Set output mode to handle virtual terminal sequences
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    if (hOut == INVALID_HANDLE_VALUE) { return EXIT_FAILURE; }

    DWORD dwMode = 0;
    if (!GetConsoleMode(hOut, &dwMode))
    {
        return EXIT_FAILURE;
    }

    dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
    return SetConsoleMode(hOut, dwMode);
}

int main(void)
{
    int fSuccess = EnableVTMode();
    if (!fSuccess)
    {
        printf("EnableVTMode() falhou, adeus\n");
        return EXIT_FAILURE;
    }

    for (int i = 0; i < 12; i += 1) printf("Umas linhas\n");
    //printf(ANSI_CLR_SCR);
//clang-format-off
    printf("\n"
ANSI_BOLD_YELLOW "amarelo...\n"
ANSI_BOLD_GREEN  "verde....\n"
ANSI_BOLD_RED    "vermelho...\n"
ANSI_RESET
    );
    // clang-format-on
    printf("\nTecle algo para LIMPAR a tela...");
    fgetc(stdin);
    printf(LIMPA_A_TELA);
    printf("\nTecle algo para ENCERRAR o programa...");
    fgetc(stdin);
    return EXIT_SUCCESS;
}

Marcos FRM · 7 de junho de 2022

53 minutos atrás, arfneto disse:

Desde que esteja rodando uma versão de Windows não mais antiga do que a que diz na documentação vai sempre funcionar. Isso seria build 18298, versão 19H1 oficialmente.

Fala em "Anniversary Update", que é a versão 1607 (compilação 14393), não? A versão mais antiga do Windows 10 que ainda recebe atualizações de segurança é a 20H2 (Education, Enterprise), bem posterior. No canal LTSC, a Microsoft suporta, no momento, a 1507 (lançamento inicial!), 1607 e 1809. A esta altura do campeonato, acredito que a maioria das instalações LTSC já está pelo menos na 1607 (sendo que, do que vi em produção, estavam todas na 1809), de forma que podemos garantir que ENABLE_VIRTUAL_TERMINAL_PROCESSING vai funcionar em praticamente todas as versões do Windows 10 suportadas atualmente.

Resta o Windows 8.1, mas quem se importa com ele?

53 minutos atrás, arfneto disse:

@Marcos FRM qual a razão desses ANSI_RESET no meio das sequências? Não precisa nesse caso. Acho que só se tivesse algum atributo em uso para as letras, tipo piscante ou sublinhado.

Possivelmente. Foi um código feito em 5 min...

53 minutos atrás, arfneto disse:

Note que se inclui windows.h pode usar EXIT_SUCCESS e EXIT_FAILURE as constantes padrão, ao invés de retornar true ou false em C e ter que incluir o folclórico header stdbool em C.

Gostava dessas constantes, porém, depois de tanto tempo lendo códigos do mundo GNU/Linux, em que geralmente o pessoal não é adepto, perdi o hábito.

Enfim, importante é que o cmd.exe ficou menos burro a partir do Windows 10!

arfneto · 8 de junho de 2022

4 horas atrás, Marcos FRM disse:

"Anniversary Update", que é a versão 1607 (compilação 14393), não?

Sim. Mas essa 18298 foi a que trouxe a aba Terminal para o cmd e deixou a convergência mais explícita para o que tem no aplicativo Terminal. Esse post de Rich Turner o gerente disso na Microsoft fala melhor ad cronologia dessas coisas. E ele descreveu isso em uma conferência na época também, mas não tenho um link para isso.

4 horas atrás, Marcos FRM disse:

podemos garantir que ENABLE_VIRTUAL_TERMINAL_PROCESSING vai funcionar em praticamente todas as versões do Windows 10 suportadas atualmente.

Sim, mas não. O é que esse não é o padrão na console. Não é simples dizer que o cara precisa configurar console mode para fazer isso. Tem 2 casos:

o cara está aprendendo e nem imagina o que é isso e tem que incluir windows.h e não bastam os printf()
o cara sabe mas só quer portar um programa do Linux e então tem que mexer no fonte para ligar o processamento dessas sequências

Os dois casos são um inferno.

Para quem não está nem em um nem em outro não importa.

A razão disso tudo

Essa mudança é meio que um retrocesso. A console do Windows dos anos 90 é mais poderosa que os comandos do terminal dos anos 80. Sabe como os caras nos anos 80 limpavam a tela rapidinho? Desligavam e ligavam o terminal. Muitos tinham uma tecla logo na frente. A bem da verdade os terminais dos mainframes, os computadores sérios da época, tinham uma tecla em vermelho logo ao lado da tela desde sempre.

Imagino que saiba que esses terminais tinham teclado e eram assim dispositivos de entrada e saída. E não havia imagem da tela para limpar. Por isso era só segurar o ENTER na console e ver a tela limpinha com 24 ou quem sabe 32 linhas de prompt, porque esses terminais eram orientados a linha, como a console.

Porque isso agora no século XXI

Um trecho do post de Rich Turner dá uma pista para o que estava acontecendo

Citação

with the steady growth in adoption of *NIX-first open-source tools, many of which emit VT sequences to color and draw text-based UI’s, it was increasingly imperative that the Windows Console be able to support VT sequences.

This was made even more important and urgent due to the arrival of Windows Subsystem for Linux which allowed unmodified Linux binaries to run natively on Windows, allowing Windows users to easily run most of the *NIX tools they’d previously had to fire-up in a separate VM

Não vou traduzir, mas um TL;DR seria:

muitas ferramentas de código aberto (vindas do Linux) usam interface de texto e essas sequências VT para controlar cores e o cursor.
O Windows agora tem um subsistema Linux, nativo, incluído e grátis. Em princípio não tem interface gráfica, e a compatibilidade passa a ser muito mais conveniente.
Os servidores na nuvem, para onde tudo está indo (voltando, se considerar o que era nos anos 80 com os mainframes) não tem inferface gráfica e adivinhe de onde vem as ferramentas de configuração, para o Windows sem gráficos e o Linux sem gráfico? Desses programas que usam essas tais sequências.

4 horas atrás, Marcos FRM disse:

Enfim, importante é que o cmd.exe ficou menos burro a partir do Windows 10!

essa é uma opinião curiosa. Imagino que já tenha lido a expressão dumb terminal, como a microsoft e todo mundo se refere aos terminais burros do Unix. Imagino que um cara que escrevia programas nos 80 tendo que salvar cursores e telas usando curses em C no Unix (e já era um progresso enorme) tenha achado esperto um sistema ter consoles com buffers e scroll e capacidade de coisas como voltar a tela e trazer de volta linhas que já tinham sumido... Mágico. E curses mudou de nome para ncurses, igualzinho, e foi até portada para o Windows.

E ao incorporar as sequências dos terminais dos anos 80 a console do século seguinte ficou menos burra, você diz. Acho que entendo seu ponto. mas é algo curioso.