Come posso inviare testo colorato su un terminale Linux?


300

Come stampare caratteri colorati su un terminale Linux che lo supporta?

Come faccio a sapere se il terminale supporta i codici colore?


9
Per determinare di cosa è capace il terminale, controllare il database delle capacità del terminale. vedi termcap(5).
jrockway,

1
Sentiti libero di dare un'occhiata a uno snippet di codice che ho inserito qui . È un piccolo strumento che colora il suo output con l'aiuto di alcune macro.
epatel,

7
"Il database termcap è una struttura obsoleta per descrivere le capacità dei terminali e delle stampanti a celle di caratteri. È conservato solo per funzionalità con vecchi programmi; quelli nuovi dovrebbero usare il terminfo(5)database e le librerie associate." -termcap(5)
OrangeDog,

Puoi facilmente termcolor
Rudy Jessop,

1
Se vuoi fare alcune cose avanzate con la stampa a colori, ti suggerisco di leggere questo articolo. L'ho trovato molto utile
Sottomacchina

Risposte:


408

È necessario emettere codici colore ANSI . Si noti che non tutti i terminali supportano questo; se le sequenze di colori non sono supportate, verrà visualizzata la spazzatura.

Esempio:

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

Qui \033è il carattere ESC, ASCII 27. È seguito da [, quindi zero o più numeri separati da ;, e infine la lettera m. I numeri descrivono il colore e il formato a cui passare da quel punto in poi.

I codici per i colori di primo piano e di sfondo sono:

         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

Inoltre, puoi usare questi:

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

Consulta la tabella su Wikipedia per altri codici meno ampiamente supportati.


Per determinare se il tuo terminale supporta sequenze di colori, leggi il valore della TERMvariabile d'ambiente. Si dovrebbe specificare il tipo particolare terminale utilizzato (ad esempio vt100, gnome-terminal, xterm, screen, ...). Quindi cercalo nel database terminfo ; controlla la colorscapacità.


15
Queste erano le ginocchia dell'ape sul BBS ...
Potatoswatter l'

11
Cosa significa m/ rappresenta?
nipponese,

4
@nipponese \033[e msegna l'inizio e la fine della sequenza di escape per i codici colore ANSI. Rif: en.wikipedia.org/wiki/ANSI_escape_code#CSI_codes
thameera

20
Lo uso definendo "manipolatori", come const std::string red("\033[0;31m");o const std::string reset("\033[0m");. Quindi, posso scrivere semplicemente cout << red << "red text" << reset << endl;.
Daniel Langr,


97

Nozioni di base

Ho scritto una classe C ++ che può essere utilizzata per impostare il colore di primo piano e di sfondo dell'output. Questo programma di esempio serve da esempio per stamparlo This ->word<- is red.e formattarlo in modo che il colore di primo piano wordsia rosso.

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

Avanzate

Potresti voler aggiungere funzionalità aggiuntive alla classe. Ad esempio, è possibile aggiungere il colore magenta e persino stili come grassetto . Per fare questo, solo un'altra voce Codeall'enumerazione. Questo è un buon riferimento.


Grande. Può essere utile se puoi aggiungere altri colori e anche i colori di sfondo.
nano,

7
ancora: `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_GAY = 90, FG_DARK_GAY = 90, FG_D 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 si definisce operator<<per Code, quindi è possibile scrivere direttamente std::cout << Color::FG_RED;anziché std::cout << Modifier(Color::FG_RED);. Cioè, Modifiernon sarebbe necessario.
Nawaz,

2
@Nawaz Buona idea. Ecco un'implementazione del genere: pastebin.com/zWC3t9hC . Tuttavia, manterrò la mia implementazione originale nella risposta perché ritengo che sia più estensibile.
Joel Sjögren,

1
In realtà mi piace di più la prima implementazione in quanto è possibile aggiungere un flag per attivare o disattivare i colori: aggiungere bool sh;alla classe e cambiare il costruttore in Modifier (Code pCode, bool show = true) : code(pCode), sh(show) {}. Infine, nel corpo <<dell'operatore restituisce la riga corrente if (sh)e in return << os;altro modo. Ciò consente di scrivere il codice con Color::Modifier red(Color::FG_RED, BoolVar);cui è possibile impostare BoolVarcome vero o falso come un'inizializzazione del programma. Puoi accenderlo per vederlo sullo schermo e disattivarlo per reindirizzare a un file.
rpsml,

42

Prima di produrre qualsiasi colore, è necessario assicurarsi di trovarsi in un terminale:

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

Quindi è necessario verificare la capacità del terminale se supporta il colore

sui sistemi con terminfo (basato su Linux) è possibile ottenere quantità di colori supportati come

Number_Of_colors_Supported=$(tput colors)

sui sistemi con termcap (basato su BSD) è possibile ottenere quantità di colori supportati come

Number_Of_colors_Supported=$(tput Co)

Quindi prendi la tua decisione:

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

A proposito, non usare la colorazione come era stato suggerito prima con i caratteri ESC. Utilizzare la funzionalità di chiamata al terminale standard che assegnerà colori CORRETTI a quel particolare supporto del terminale.

Basato su 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)"
Basato su 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)"
Usare come
echo -e "${fg_red}  Red  ${fg_green} Bull ${reset}"

3
Questo bash non è specifico? -t 1 ovviamente non funzionerà in C ++ e la chiamata a questo programma tput lo renderà molto rotonda in un programma C ++.
Macha,

2
@Macha, sì, [ -t 1 ]è specifico per sh / bash, ma sul lato destro dopo il #(comment)segno c'è la funzione C che fa lo stesso. man 3 isattydovrebbe aiutare in questo;) Esempio mostrato come comandi di shell per semplificare la spiegazione del punto principale. Per quanto riguarda tputl'utilità di origine OPEN per eseguire query sull'interfaccia di capacità terminale standard.
Alex,

1
Non sono sicuro del motivo per cui le persone continuano a suggerire di usare questi codici direttamente. È davvero, davvero una cattiva pratica fare simili ipotesi. Anche se si tratta di un codice specifico per la shell, può essere tradotto da chiunque abbia anche una minima esperienza di shell.
Osirisgothra,

34

Come altri hanno già detto, puoi usare i caratteri di escape. Puoi usare la mia intestazione per rendere più semplice:

#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_ */

Un esempio che utilizza le macro dell'intestazione potrebbe essere:

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

inserisci qui la descrizione dell'immagine


Intestazione fantastica!
Zheng Qu,

16

Uso la seguente soluzione, è abbastanza semplice ed elegante, può essere facilmente incollata nel sorgente e funziona su 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;

14

Da quanto ho capito, un tipico codice colore ANSI

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

è composto da (nome e codec)

  • FORMATO ATTRIBUTO

    { "Default", "0" },
    { "Bold", "1" },
    { "Dim", "2" },
    { "Underlined", "3" },
    { "Blink", "5" },
    { "Reverse", "7" },
    { "Hidden", "8" }
  • COLORE DI FORGROUND

    { "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" }
  • COLORE DI SFONDO

    { "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" }
  • TESTO

  • RESET FORMATO ATTRIBUTO

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

Con queste informazioni, è facile colorare una stringa "I am a banana!" con il colore di primo piano "Giallo" e il colore di sfondo "Verde" come questo

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

O con una libreria C ++ colorize

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

Altri esempi con FORMAT ATTRIBUTE quiinserisci qui la descrizione dell'immagine


Questo è molto meglio e sono in grado di usarlo nella mia estensione PHP C ++.
Aftab Naveed,

12

Questo è un vecchio argomento, ma ho scritto una classe con sottoclassi nidificate e membri statici per i colori definiti da semplici macro C.

Ho ricevuto la colorfunzione da questo post Color Text In C Programming in dreamincode.net dall'utente no2pencil.

L'ho fatto in questo modo in modo da poter usare le costanti statiche nel flusso std :: cout in questo modo:

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

La classe e un codice sorgente del programma di prova possono essere scaricati qui .

cc::consoleripristinerà i colori e gli attributi predefiniti della console, cc::underlinesottolineerà il testo, che funziona su stucco che ho testato il programma di test.

Colori:

black
blue
red
magenta
green
cyan
yellow
white

lightblack
lightblue
lightred
lightmagenta
lightgreen
lightcyan
lightyellow
lightwhite

Che può essere utilizzato con entrambe foree backstatiche sottoclassi della ccclasse statica.

EDIT 2017

Sto solo aggiungendo il codice di classe qui per essere più pratico.

Le macro dei codici colore:

#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 la funzione colore principale che definisce un colore o un attributo allo schermo:

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

2
Grazie per il codice Ho aggiunto un altro codice di escape ANSI per consentire la visualizzazione di testo in grassetto:const char *cc::bold = CC_ATTR(1);
Drew Noakes,

Grazie per l'aggiunta. Ho incluso questo nel codice di classe.
Christos Lytras,

9

Puoi usare le sequenze di escape, se il tuo terminale lo supporta. Per esempio:

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

9

Una versione estesa dell'intestazione di 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 */

Come puoi vedere, ha più capacità come la possibilità di impostare il colore di sfondo temporaneamente, indefinitamente e altre funzionalità. Credo anche che sia un po 'più facile per i principianti e più facile ricordare tutte le funzioni.

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

Includi semplicemente il file header nel tuo progetto e sei pronto per il rock and roll con l'output colorato del terminale.


3

prova la mia intestazione qui per un modo semplice e veloce per colorare il testo: Aedi's Color Header


Fuga-Sequence-Color-Header

Colora il tuo output in Unix usando C ++ !!


Opzioni per gli attributi di testo:

ATTRIBUTES_OFF, BOLD, UNDERSCORE, BLINK, REVERSE_VIDEO, CONCEALED


Opzioni colore:

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


Formato:

Formato generale, includi il valore desiderato in $ variabile $

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

per esempio

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


Uso:

Basta usare per eseguire lo streaming del colore desiderato prima di emettere il testo e riutilizzarlo per impostare il colore su normale dopo aver emesso il testo.

cout << COLOR_BLUE_BLACK << "TEXT" << COLOR_NORMAL << endl;
cout << COLOR_BOLD_YELLOW_CYAN << "TEXT" << COLOR_NORMAL << endl;

Questa è una risposta di solo collegamento e renderà inutile se il collegamento si interrompe. Aggiungi un po 'di codice o elabora la tua risposta
dgilperez,

2
Siamo spiacenti, principiante qui ... Ho appena aggiunto alcune informazioni. Dose questo lavoro?
Uduse,

@ sjm324 Suppongo che BLINK sia supportato sia basato sul tuo sistema
Uduse

3

È possibile utilizzare i codici colore ANSI.

usa queste funzioni.

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

2

Il modo migliore è usare la libreria ncurses - anche se questo potrebbe essere un martello per rompere un dado se vuoi solo produrre una semplice stringa colorata


3
@Nick sarebbe un dolore usare ncurses per ottenere un po 'di colorazione tramite l'eco. :)
portatore dell'anello

2

sulla shell OSX, questo funziona per me (inclusi 2 spazi davanti al "testo rosso"):

$ printf "\e[033;31m  red text\n"
$ echo "$(tput setaf 1)  red text"
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.