Como faço para imprimir texto colorido em um terminal Linux?

300

Como imprimo caracteres coloridos em um terminal Linux compatível?

Como sei se o terminal suporta códigos de cores?

Macha
fonte
9
Para determinar do que o terminal é capaz, verifique o banco de dados de recursos do terminal. veja termcap(5).
Jrockway
1
Sinta-se livre para dar uma olhada em um trecho de código que eu coloquei aqui . É uma pequena ferramenta que colore sua saída com a ajuda de algumas macros.
epatel
7
"O banco de dados termcap é um recurso obsoleto para descrever os recursos dos terminais e impressoras de células de caracteres. Ele é mantido apenas para recursos nos programas antigos; os novos devem usar o terminfo(5)banco de dados e as bibliotecas associadas". -termcap(5)
OrangeDog
Você pode facilmente você termcolor
Rudy Jessop
1
Se você quiser fazer algumas coisas avançadas com impressão em cores, sugiro que você leia este artigo. Achei muito útil
submetralhadoras

Respostas:

408

Você precisa gerar códigos de cores ANSI . Observe que nem todos os terminais suportam isso; se as seqüências de cores não forem suportadas, o lixo será exibido.

Exemplo:

 cout << "\033[1;31mbold red text\033[0m\n";

Aqui, \033está o caractere ESC, ASCII 27. Ele é seguido por [zero ou mais números separados por ;e, finalmente, a letra m. Os números descrevem a cor e o formato para alternar a partir desse ponto em diante.

Os códigos para as cores de primeiro e segundo plano são:

         foreground background
black        30         40
red          31         41
green        32         42
yellow       33         43
blue         34         44
magenta      35         45
cyan         36         46
white        37         47

Além disso, você pode usar estes:

reset             0  (everything back to normal)
bold/bright       1  (often a brighter shade of the same colour)
underline         4
inverse           7  (swap foreground and background colours)
bold/bright off  21
underline off    24
inverse off      27

Veja a tabela na Wikipedia para outros códigos menos suportados.


Para determinar se o seu terminal suporta sequências de cores, leia o valor da TERMvariável de ambiente. Ele deve especificar o tipo de terminal particular usado (por exemplo vt100, gnome-terminal, xterm, screen, ...). Em seguida, procure isso no banco de dados terminfo ; verifique a colorscapacidade.

Thomas
fonte
15
Este foi joelhos da abelha na BBS ...
Potatoswatter
11
O que msignifica / representa?
Nipponese
4
@ nipponese \033[e mmarque o início e o fim da sequência de escape dos códigos de cores ANSI. Ref: pt.wikipedia.org/wiki/ANSI_escape_code#CSI_codes
thameera
20
Eu o uso definindo "manipuladores", como const std::string red("\033[0;31m");ou const std::string reset("\033[0m");. Então, eu posso escrever simplesmente cout << red << "red text" << reset << endl;.
Daniel Langr
4
Eu olhar para isso por uma visualização das cores: misc.flogisoft.com/bash/tip_colors_and_formatting
Liran Funaro
97

Fundamentos

Eu escrevi uma classe C ++ que pode ser usada para definir a cor de primeiro e segundo plano da saída. Este programa de exemplo serve como um exemplo de impressão This ->word<- is red.e formatação para que a cor do primeiro plano wordseja vermelha.

#include "colormod.h" // namespace Color
#include <iostream>
using namespace std;
int main() {
    Color::Modifier red(Color::FG_RED);
    Color::Modifier def(Color::FG_DEFAULT);
    cout << "This ->" << red << "word" << def << "<- is red." << endl;
}

Fonte

#include <ostream>
namespace Color {
    enum Code {
        FG_RED      = 31,
        FG_GREEN    = 32,
        FG_BLUE     = 34,
        FG_DEFAULT  = 39,
        BG_RED      = 41,
        BG_GREEN    = 42,
        BG_BLUE     = 44,
        BG_DEFAULT  = 49
    };
    class Modifier {
        Code code;
    public:
        Modifier(Code pCode) : code(pCode) {}
        friend std::ostream&
        operator<<(std::ostream& os, const Modifier& mod) {
            return os << "\033[" << mod.code << "m";
        }
    };
}

Avançado

Você pode adicionar recursos adicionais à turma. É possível, por exemplo, adicionar a cor magenta e até estilos como negrito . Para fazer isso, apenas mais uma entrada para a Codeenumeração. Esta é uma boa referência.

Joel Sjögren
fonte
Ótimo. Pode ser útil se você pode adicionar outras cores e também cores de fundo.
Nano
7
um pouco mais: `FG_DEFAULT = 39, FG_BLACK = 30, FG_RED = 31, FG_GREEN = 32, FG_YELLOW = 33, FG_BLUE = 34, FG_MAGENTA = 35, FG_CYAN = 36, FG_LIGHT_GRAY = 37, FG_DARK_GRAY = 90, FG_LIGHT_RED = 91, FG_LIGHT_RED = 91 92, FG_LIGHT_YELLOW = 93, FG_LIGHT_BLUE = 94, FG_LIGHT_MAGENTA = 95, FG_LIGHT_CYAN = 96, FG_WHITE = 97, BG_RED = 41, BG_GREEN = 42, BG_BLUE = 44, BG_DEFAULT = 49`
Phantrast
6
Se você definir operator<<para Code, poderá escrever diretamente em std::cout << Color::FG_RED;vez de std::cout << Modifier(Color::FG_RED);. Ou seja, Modifiernão seria necessário.
Nawaz
2
@Nawaz Boa ideia. Aqui está uma implementação como essa: pastebin.com/zWC3t9hC . No entanto, manterei minha implementação original na resposta porque sinto que é mais extensível.
Joel Sjögren
1
Na verdade, eu gosto mais da primeira implementação, pois você pode adicionar um sinalizador para ativar ou desativar as cores: Adicione bool sh;à classe e altere o construtor para Modifier (Code pCode, bool show = true) : code(pCode), sh(show) {}. Finalmente, no corpo do <<operador, retorne a linha atual if (sh)e return << os;caso contrário. Isso permite escrever seu código Color::Modifier red(Color::FG_RED, BoolVar);onde você pode definir BoolVarcomo verdadeiro ou falso como uma inicialização do programa. Você pode ativá-lo para vê-lo na tela e desativar para redirecionar para um arquivo.
Rpsml #
42

Antes de imprimir qualquer cor, verifique se você está em um terminal:

[ -t 1 ] && echo 'Yes I am in a terminal'  # isatty(3) call in C

Então você precisa verificar a capacidade do terminal se ele suporta cores

em sistemas com terminfo (Linux), você pode obter a quantidade de cores suportadas conforme

Number_Of_colors_Supported=$(tput colors)

em sistemas com termcap (baseado em BSD), é possível obter a quantidade de cores suportadas conforme

Number_Of_colors_Supported=$(tput Co)

Então tome sua decisão:

[ ${Number_Of_colors_Supported} -ge 8 ] && {
    echo 'You are fine and can print colors'
} || {
    echo 'Terminal does not support color'
}

Entre, não use cores como sugerido anteriormente com caracteres ESC. Use o recurso padrão de chamada para terminal que atribuirá a você cores CORRETAS que suporte específico ao terminal.

Baseado em BSD
fg_black="$(tput AF 0)"
fg_red="$(tput AF 1)"
fg_green="$(tput AF 2)"
fg_yellow="$(tput AF 3)"
fg_blue="$(tput AF 4)"
fg_magenta="$(tput AF 5)"
fg_cyan="$(tput AF 6)"
fg_white="$(tput AF 7)"
reset="$(tput me)"
Baseado em Linux
fg_black="$(tput setaf 0)"
fg_red="$(tput setaf 1)"
fg_green="$(tput setaf 2)"
fg_yellow="$(tput setaf 3)"
fg_blue="$(tput setaf 4)"
fg_magenta="$(tput setaf 5)"
fg_cyan="$(tput setaf 6)"
fg_white="$(tput setaf 7)"
reset="$(tput sgr0)"
Usar como
echo -e "${fg_red}  Red  ${fg_green} Bull ${reset}"
Alex
fonte
3
Este bash não é específico? -t 1 obviamente não funcionará em C ++, e chamar esse programa de tput tornará muito indireto quando em um programa C ++.
Macha
2
@Macha, sim, [ -t 1 ]é sh / bash específico, mas no lado direito após o #(comment)sinal há uma função C que faz o mesmo. man 3 isattydeve ajudar nisso;) Exemplo mostrado como comandos do shell para simplificar a explicação do ponto principal. Quanto ao tputseu utilitário de origem OPEN, para consultar a interface de capacidade do terminal padrão.
Alex12:
1
Não sei por que as pessoas continuam sugerindo o uso direto desses códigos. É prática muito, muito ruim fazer tais suposições. Mesmo que esse seja um código específico do shell, ele pode ser traduzido por qualquer pessoa que possua uma quantidade iniciante de experiência no shell.
Osirisgothra
34

Como outros já declararam, você pode usar caracteres de escape. Você pode usar meu cabeçalho para facilitar:

#ifndef _COLORS_
#define _COLORS_

/* FOREGROUND */
#define RST  "\x1B[0m"
#define KRED  "\x1B[31m"
#define KGRN  "\x1B[32m"
#define KYEL  "\x1B[33m"
#define KBLU  "\x1B[34m"
#define KMAG  "\x1B[35m"
#define KCYN  "\x1B[36m"
#define KWHT  "\x1B[37m"

#define FRED(x) KRED x RST
#define FGRN(x) KGRN x RST
#define FYEL(x) KYEL x RST
#define FBLU(x) KBLU x RST
#define FMAG(x) KMAG x RST
#define FCYN(x) KCYN x RST
#define FWHT(x) KWHT x RST

#define BOLD(x) "\x1B[1m" x RST
#define UNDL(x) "\x1B[4m" x RST

#endif  /* _COLORS_ */

Um exemplo usando as macros do cabeçalho pode ser:

#include <iostream>
#include "colors.h"
using namespace std;

int main()
{
    cout << FBLU("I'm blue.") << endl;
    cout << BOLD(FBLU("I'm blue-bold.")) << endl;
    return 0;
}

insira a descrição da imagem aqui

gon1332
fonte
Cabeçalho impressionante!
Zheng Qu
16

Eu uso a seguinte solução, é bastante simples e elegante, pode ser facilmente colada no código-fonte e funciona no Linux / Bash:

const std::string red("\033[0;31m");
const std::string green("\033[1;32m");
const std::string yellow("\033[1;33m");
const std::string cyan("\033[0;36m");
const std::string magenta("\033[0;35m");
const std::string reset("\033[0m");

std::cout << "Measured runtime: " << yellow << timer.count() << reset << std::endl;
Daniel Langr
fonte
14

Pelo meu entendimento, um código de cor ANSI típico

"\033[{FORMAT_ATTRIBUTE};{FORGROUND_COLOR};{BACKGROUND_COLOR}m{TEXT}\033[{RESET_FORMATE_ATTRIBUTE}m"

é composto por (nome e codec)

  • ATRIBUTO FORMATO

    { "Default", "0" },
    { "Bold", "1" },
    { "Dim", "2" },
    { "Underlined", "3" },
    { "Blink", "5" },
    { "Reverse", "7" },
    { "Hidden", "8" }
  • COR DO ESQUERDO

    { "Default", "39" },
    { "Black", "30" },
    { "Red", "31" },
    { "Green", "32" },
    { "Yellow", "33" },
    { "Blue", "34" },
    { "Magenta", "35" },
    { "Cyan", "36" },
    { "Light Gray", "37" },
    { "Dark Gray", "90" },
    { "Light Red", "91" },
    { "Light Green", "92" },
    { "Light Yellow", "93" },
    { "Light Blue", "94" },
    { "Light Magenta", "95" },
    { "Light Cyan", "96" },
    { "White", "97" }
  • COR DE FUNDO

    { "Default", "49" },
    { "Black", "40" },
    { "Red", "41" },
    { "Green", "42" },
    { "Yellow", "43" },
    { "Blue", "44" },
    { "Megenta", "45" },
    { "Cyan", "46" },
    { "Light Gray", "47" },
    { "Dark Gray", "100" },
    { "Light Red", "101" },
    { "Light Green", "102" },
    { "Light Yellow", "103" },
    { "Light Blue", "104" },
    { "Light Magenta", "105" },
    { "Light Cyan", "106" },
    { "White", "107" }
  • TEXTO

  • RESET FORMAT ATTRIBUTE

    { "All", "0" },
    { "Bold", "21" },
    { "Dim", "22" },
    { "Underlined", "24" },
    { "Blink", "25" },
    { "Reverse", "27" },
    { "Hidden", "28" }

Com essas informações, é fácil colorir uma sequência de caracteres "Eu sou uma banana!" com forground cor "amarelo" e cor de fundo "verde" como este

"\033[0;33;42mI am a Banana!\033[0m"

Ou com uma biblioteca C ++ colorida

auto const& colorized_text = color::rize( "I am a banana!", "Yellow", "Green" );
std::cout << colorized_text << std::endl;

Mais exemplos com FORMAT ATTRIBUTE aquiinsira a descrição da imagem aqui

Feng Wang
fonte
Isso é muito melhor e eu posso usá-lo na minha extensão PHP C ++.
Aftab Naveed
12

Este é um tópico antigo, mas escrevi uma classe com subclasses aninhadas e membros estáticos para cores definidas por macros C simples.

Eu peguei a colorfunção deste post Texto em cores em C Programming no dreamincode.net pelo usuário no2pencil.

Eu fiz dessa maneira para poder usar as constantes estáticas no fluxo std :: cout assim:

cout << zkr::cc::fore::red << "This is red text. " 
     << zkr::cc::console << "And changing to console default colors, fg, bg."
     << endl;

A classe e o código fonte do programa de teste podem ser baixados aqui .

cc::consoleredefinirá para consolar as cores e os atributos padrão, cc::underlinesublinhará o texto, que funciona na massa que testei o programa de teste.

Cores:

black
blue
red
magenta
green
cyan
yellow
white

lightblack
lightblue
lightred
lightmagenta
lightgreen
lightcyan
lightyellow
lightwhite

Que pode ser usado com as subclasses estática foree backda ccclasse estática.

EDIT 2017

Estou apenas adicionando o código da classe aqui para ser mais prático.

As macros do código de cores:

#define CC_CONSOLE_COLOR_DEFAULT "\033[0m"
#define CC_FORECOLOR(C) "\033[" #C "m"
#define CC_BACKCOLOR(C) "\033[" #C "m"
#define CC_ATTR(A) "\033[" #A "m"

e a principal função de cor que define uma cor ou um atributo para a tela:

char *cc::color(int attr, int fg, int bg)
{
    static char command[13];

    /* Command is the control command to the terminal */
    sprintf(command, "%c[%d;%d;%dm", 0x1B, attr, fg + 30, bg + 40);
    return command;
}

ccolor.h

#include <stdio.h>

#define CC_CONSOLE_COLOR_DEFAULT "\033[0m"
#define CC_FORECOLOR(C) "\033[" #C "m"
#define CC_BACKCOLOR(C) "\033[" #C "m"
#define CC_ATTR(A) "\033[" #A "m"

namespace zkr
{
    class cc
    {
    public:

        class fore
        {
        public:
            static const char *black;
            static const char *blue;
            static const char *red;
            static const char *magenta;
            static const char *green;
            static const char *cyan;
            static const char *yellow;
            static const char *white;
            static const char *console;

            static const char *lightblack;
            static const char *lightblue;
            static const char *lightred;
            static const char *lightmagenta;
            static const char *lightgreen;
            static const char *lightcyan;
            static const char *lightyellow;
            static const char *lightwhite;
        };

        class back
        {
        public:
            static const char *black;
            static const char *blue;
            static const char *red;
            static const char *magenta;
            static const char *green;
            static const char *cyan;
            static const char *yellow;
            static const char *white;
            static const char *console;

            static const char *lightblack;
            static const char *lightblue;
            static const char *lightred;
            static const char *lightmagenta;
            static const char *lightgreen;
            static const char *lightcyan;
            static const char *lightyellow;
            static const char *lightwhite;
        };

        static char *color(int attr, int fg, int bg);
        static const char *console;
        static const char *underline;
        static const char *bold;
    };
}

ccolor.cpp

#include "ccolor.h"

using namespace std;

namespace zkr
{
    enum Color
    {
        Black,
        Red,
        Green,
        Yellow,
        Blue,
        Magenta,
        Cyan,
        White,
        Default = 9
    };

    enum Attributes
    {
        Reset,
        Bright,
        Dim,
        Underline,
        Blink,
        Reverse,
        Hidden
    };

    char *cc::color(int attr, int fg, int bg)
    {
        static char command[13];
        /* Command is the control command to the terminal */
        sprintf(command, "%c[%d;%d;%dm", 0x1B, attr, fg + 30, bg + 40);
        return command;
    }

    const char *cc::console = CC_CONSOLE_COLOR_DEFAULT;
    const char *cc::underline = CC_ATTR(4);
    const char *cc::bold = CC_ATTR(1);

    const char *cc::fore::black = CC_FORECOLOR(30);
    const char *cc::fore::blue = CC_FORECOLOR(34);
    const char *cc::fore::red = CC_FORECOLOR(31);
    const char *cc::fore::magenta = CC_FORECOLOR(35);
    const char *cc::fore::green = CC_FORECOLOR(92);
    const char *cc::fore::cyan = CC_FORECOLOR(36);
    const char *cc::fore::yellow = CC_FORECOLOR(33);
    const char *cc::fore::white = CC_FORECOLOR(37);
    const char *cc::fore::console = CC_FORECOLOR(39);

    const char *cc::fore::lightblack = CC_FORECOLOR(90);
    const char *cc::fore::lightblue = CC_FORECOLOR(94);
    const char *cc::fore::lightred = CC_FORECOLOR(91);
    const char *cc::fore::lightmagenta = CC_FORECOLOR(95);
    const char *cc::fore::lightgreen = CC_FORECOLOR(92);
    const char *cc::fore::lightcyan = CC_FORECOLOR(96);
    const char *cc::fore::lightyellow = CC_FORECOLOR(93);
    const char *cc::fore::lightwhite = CC_FORECOLOR(97);

    const char *cc::back::black = CC_BACKCOLOR(40);
    const char *cc::back::blue = CC_BACKCOLOR(44);
    const char *cc::back::red = CC_BACKCOLOR(41);
    const char *cc::back::magenta = CC_BACKCOLOR(45);
    const char *cc::back::green = CC_BACKCOLOR(42);
    const char *cc::back::cyan = CC_BACKCOLOR(46);
    const char *cc::back::yellow = CC_BACKCOLOR(43);
    const char *cc::back::white = CC_BACKCOLOR(47);
    const char *cc::back::console = CC_BACKCOLOR(49);

    const char *cc::back::lightblack = CC_BACKCOLOR(100);
    const char *cc::back::lightblue = CC_BACKCOLOR(104);
    const char *cc::back::lightred = CC_BACKCOLOR(101);
    const char *cc::back::lightmagenta = CC_BACKCOLOR(105);
    const char *cc::back::lightgreen = CC_BACKCOLOR(102);
    const char *cc::back::lightcyan = CC_BACKCOLOR(106);
    const char *cc::back::lightyellow = CC_BACKCOLOR(103);
    const char *cc::back::lightwhite = CC_BACKCOLOR(107);
}
Christos Lytras
fonte
2
Obrigado pelo código. Adicionei outro código de escape ANSI para permitir a exibição de texto em negrito:const char *cc::bold = CC_ATTR(1);
Drew Noakes
Obrigado pela adição. Eu incluí isso no código da classe.
Christos Lytras
9

Você pode usar seqüências de escape, se o seu terminal suportar. Por exemplo:

echo \[\033[32m\]Hello, \[\033[36m\]colourful \[\033[33mworld!\033[0m\]
Vlad
fonte
9

Uma versão expandida do cabeçalho de gon1332:

//
//  COLORS.h
//
//  Posted by Gon1332 May 15 2015 on StackOverflow
//  /programming/2616906/how-do-i-output-coloured-text-to-a-linux-terminal#2616912
//
//  Description: An easy header file to make colored text output to terminal second nature.
//  Modified by Shades Aug. 14 2018

// PLEASE carefully read comments before using this tool, this will save you a lot of bugs that are going to be just about impossible to find.
#ifndef COLORS_h
#define COLORS_h

/* FOREGROUND */
// These codes set the actual text to the specified color
#define RESETTEXT  "\x1B[0m" // Set all colors back to normal.
#define FOREBLK  "\x1B[30m" // Black
#define FORERED  "\x1B[31m" // Red
#define FOREGRN  "\x1B[32m" // Green
#define FOREYEL  "\x1B[33m" // Yellow
#define FOREBLU  "\x1B[34m" // Blue
#define FOREMAG  "\x1B[35m" // Magenta
#define FORECYN  "\x1B[36m" // Cyan
#define FOREWHT  "\x1B[37m" // White

/* BACKGROUND */
// These codes set the background color behind the text.
#define BACKBLK "\x1B[40m"
#define BACKRED "\x1B[41m"
#define BACKGRN "\x1B[42m"
#define BACKYEL "\x1B[43m"
#define BACKBLU "\x1B[44m"
#define BACKMAG "\x1B[45m"
#define BACKCYN "\x1B[46m"
#define BACKWHT "\x1B[47m"

// These will set the text color and then set it back to normal afterwards.
#define BLK(x) FOREBLK x RESETTEXT
#define RED(x) FORERED x RESETTEXT
#define GRN(x) FOREGRN x RESETTEXT
#define YEL(x) FOREYEL x RESETTEXT
#define BLU(x) FOREBLU x RESETTEXT
#define MAG(x) FOREMAG x RESETTEXT
#define CYN(x) FORECYN x RESETTEXT
#define WHT(x) FOREWHT x RESETTEXT

// Example usage: cout << BLU("This text's color is now blue!") << endl;

// These will set the text's background color then reset it back.
#define BackBLK(x) BACKBLK x RESETTEXT
#define BackRED(x) BACKRED x RESETTEXT
#define BackGRN(x) BACKGRN x RESETTEXT
#define BackYEL(x) BACKYEL x RESETTEXT
#define BackBLU(x) BACKBLU x RESETTEXT
#define BackMAG(x) BACKMAG x RESETTEXT
#define BackCYN(x) BACKCYN x RESETTEXT
#define BackWHT(x) BACKWHT x RESETTEXT

// Example usage: cout << BACKRED(FOREBLU("I am blue text on a red background!")) << endl;

// These functions will set the background to the specified color indefinitely.
// NOTE: These do NOT call RESETTEXT afterwards. Thus, they will set the background color indefinitely until the user executes cout << RESETTEXT
// OR if a function is used that calles RESETTEXT i.e. cout << RED("Hello World!") will reset the background color since it calls RESETTEXT.
// To set text COLOR indefinitely, see SetFore functions below.
#define SetBackBLK BACKBLK
#define SetBackRED BACKRED
#define SetBackGRN BACKGRN
#define SetBackYEL BACKYEL
#define SetBackBLU BACKBLU
#define SetBackMAG BACKMAG
#define SetBackCYN BACKCYN
#define SetBackWHT BACKWHT

// Example usage: cout << SetBackRED << "This text's background and all text after it will be red until RESETTEXT is called in some way" << endl;

// These functions will set the text color until RESETTEXT is called. (See above comments)
#define SetForeBLK FOREBLK
#define SetForeRED FORERED
#define SetForeGRN FOREGRN
#define SetForeYEL FOREYEL
#define SetForeBLU FOREBLU
#define SetForeMAG FOREMAG
#define SetForeCYN FORECYN
#define SetForeWHT FOREWHT

// Example usage: cout << SetForeRED << "This text and all text after it will be red until RESETTEXT is called in some way" << endl;

#define BOLD(x) "\x1B[1m" x RESETTEXT // Embolden text then reset it.
#define BRIGHT(x) "\x1B[1m" x RESETTEXT // Brighten text then reset it. (Same as bold but is available for program clarity)
#define UNDL(x) "\x1B[4m" x RESETTEXT // Underline text then reset it.

// Example usage: cout << BOLD(BLU("I am bold blue text!")) << endl;

// These functions will embolden or underline text indefinitely until RESETTEXT is called in some way.

#define SetBOLD "\x1B[1m" // Embolden text indefinitely.
#define SetBRIGHT "\x1B[1m" // Brighten text indefinitely. (Same as bold but is available for program clarity)
#define SetUNDL "\x1B[4m" // Underline text indefinitely.

// Example usage: cout << setBOLD << "I and all text after me will be BOLD/Bright until RESETTEXT is called in some way!" << endl;

#endif /* COLORS_h */

Como você pode ver, ele possui mais recursos, como a capacidade de definir a cor de fundo temporariamente, indefinidamente e outros recursos. Eu também acredito que é um pouco mais amigável para iniciantes e mais fácil de lembrar de todas as funções.

#include <iostream>
#include "COLORS.h"

int main() {
  std::cout << SetBackBLU << SetForeRED << endl;
  std::cout << "I am red text on a blue background! :) " << endl;
  return 0;
}

Basta incluir o arquivo de cabeçalho no seu projeto e você estará pronto para o rock and roll com a saída colorida do terminal.

Tons
fonte
3

experimente meu cabeçalho aqui para obter uma maneira rápida e fácil de colorir o texto: cabeçalho colorido da Aedi


Sequência de escape-Cabeçalho de cor

Colorir sua saída no Unix usando C ++ !!


Opções de atributo de texto:

ATTRIBUTES_OFF, BOLD, UNDERSCORE, BLINK, REVERSE_VIDEO, CONCEALED


Opções de cores:

BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE


Formato:

Formato geral, inclua o valor desejado em $ variable $

COLOR_$Foreground_Color$_$Background_Color$
COLOR_$Text_Attribute$_$Foreground_Color$_$Background_Color$
COLOR_NORMAL  // To set color to default

por exemplo

COLOR_BLUE_BLACK // Leave Text Attribute Blank if no Text Attribute appied
COLOR_UNDERSCORE_YELLOW_RED
COLOR_NORMAL


Uso:

Use apenas para transmitir a cor desejada antes de enviar o texto e use novamente para definir a cor normal após a saída do texto.

cout << COLOR_BLUE_BLACK << "TEXT" << COLOR_NORMAL << endl;
cout << COLOR_BOLD_YELLOW_CYAN << "TEXT" << COLOR_NORMAL << endl;
Uduse
fonte
Esta é uma resposta apenas para link e será inútil se o link for desativado. Por favor, adicione algum código ou elabore sua resposta
dgilperez
2
Desculpe, novato aqui ... Acabei de adicionar mais algumas informações. Dose este trabalho?
Uduse
@ sjm324 Eu acho que se BLINK é suportado é baseado em seu sistema
Uduse
3

Você pode usar códigos de cores ANSI.

use essas funções.

enum c_color{BLACK=30,RED=31,GREEN=32,YELLOW=33,BLUE=34,MAGENTA=35,CYAN=36,WHITE=37};
enum c_decoration{NORMAL=0,BOLD=1,FAINT=2,ITALIC=3,UNDERLINE=4,RIVERCED=26,FRAMED=51};
void pr(const string str,c_color color,c_decoration decoration=c_decoration::NORMAL){
  cout<<"\033["<<decoration<<";"<<color<<"m"<<str<<"\033[0m";
}

void prl(const string str,c_color color,c_decoration decoration=c_decoration::NORMAL){
   cout<<"\033["<<decoration<<";"<<color<<"m"<<str<<"\033[0m"<<endl;
}
Shanaka Rusith
fonte
2

A melhor maneira é usar a biblioteca ncurses - embora possa ser uma marreta para quebrar uma noz, se você quiser apenas produzir uma string colorida simples

usuario
fonte
3
@ Nick: seria difícil usar ncurses para conseguir alguma coloração via eco. :)
portador de anel 23/04
2

no shell OSX, isso funciona para mim (incluindo 2 espaços na frente do "texto em vermelho"):

$ printf "\e[033;31m  red text\n"
$ echo "$(tput setaf 1)  red text"
BananaAcid
fonte