Jak wyprowadzić kolorowy tekst na terminal Linuksa?

300

Jak wydrukować kolorowe znaki na terminalu Linux, który go obsługuje?

Jak sprawdzić, czy terminal obsługuje kody kolorów?

Macha
źródło
9
Aby ustalić, do czego zdolny jest terminal, sprawdź bazę danych możliwości terminalu. zob termcap(5).
jrockway
1
Zapraszam do obejrzenia fragmentu kodu, który tu umieściłem . To małe narzędzie, które koloryzuje dane wyjściowe za pomocą niektórych makr.
Epatel
7
„Baza danych termcap jest przestarzałym narzędziem do opisywania możliwości terminali i drukarek z komórkami znaków. Została zachowana tylko dla możliwości starych programów; nowe powinny korzystać z terminfo(5)bazy danych i powiązanych bibliotek”. -termcap(5)
OrangeDog
Możesz łatwo termcolor
Rudy Jessop
1
Jeśli chcesz zrobić zaawansowane rzeczy z drukowaniem w kolorze, sugeruję przeczytanie tego artykułu. Uważam to za bardzo pomocne
SubMachine,

Odpowiedzi:

408

Musisz wyprowadzić kody kolorów ANSI . Zauważ, że nie wszystkie terminale obsługują to; jeśli sekwencje kolorów nie są obsługiwane, pojawi się śmieci.

Przykład:

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

Oto \033znak ESC, ASCII 27. Po nim następuje [zero lub więcej cyfr oddzielonych ;i na końcu litera m. Liczby opisują kolor i format, od którego należy przejść od tego momentu.

Kody kolorów pierwszego planu i tła to:

         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

Dodatkowo możesz użyć tych:

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

Zobacz tabelę na Wikipedii, aby znaleźć inne, rzadziej obsługiwane kody.


Aby ustalić, czy twój terminal obsługuje sekwencje kolorów, przeczytaj wartość TERMzmiennej środowiskowej. Należy określić konkretny rodzaj terminala używany (np vt100, gnome-terminal, xterm, screen, ...). Następnie sprawdź to w bazie danych terminfo ; sprawdź colorsmożliwości.

Tomasz
źródło
15
To były kolana pszczoły na BBS…
Potatoswatter
11
Co oznacza m/ oznacza?
nipponese
4
@nipponese \033[i mzaznacz początek i koniec sekwencji zmiany znaczenia dla kodów kolorów ANSI. Ref: en.wikipedia.org/wiki/ANSI_escape_code#CSI_codes
thameera
20
Używam go do definiowania „manipulatorów”, takich jak const std::string red("\033[0;31m");lub const std::string reset("\033[0m");. Potem mogę po prostu pisać cout << red << "red text" << reset << endl;.
Daniel Langr
4
Spojrzałbym na to w celu wizualizacji kolorów: misc.flogisoft.com/bash/tip_colors_and_formatting
Liran
97

Podstawy

Napisałem klasę C ++, której można użyć do ustawienia koloru pierwszego planu i tła wydruku. Ten przykładowy program służy jako przykład wydrukowania This ->word<- is red.i sformatowania go w taki sposób, aby kolor pierwszego planu wordbył czerwony.

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

Źródło

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

zaawansowane

Możesz dodać dodatkowe funkcje do klasy. Można na przykład dodać kolor magenta, a nawet style, takie jak pogrubienie . Aby to zrobić, wystarczy kolejny wpis do Codewyliczenia. To jest dobre odniesienie.

Joel Sjögren
źródło
Wspaniały. Pomocne może być dodanie innych kolorów, a także kolorów tła.
nano
7
trochę więcej: `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_GREY = 37, FG_DARK_GRE_ = 90, 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 23.04
6
Jeśli zdefiniujesz operator<<dla Code, możesz bezpośrednio pisać std::cout << Color::FG_RED;zamiast std::cout << Modifier(Color::FG_RED);. To Modifiernie byłoby potrzebne.
Nawaz
2
@Nawaz Dobry pomysł. Oto taka implementacja: pastebin.com/zWC3t9hC . Jednak zachowam moją oryginalną implementację w odpowiedzi, ponieważ uważam, że jest ona bardziej rozszerzalna.
Joel Sjögren
1
Właściwie bardziej podoba mi się pierwsza implementacja, ponieważ możesz dodać flagę, aby włączyć lub wyłączyć kolory: Dodaj bool sh;do klasy i zmień konstruktor na Modifier (Code pCode, bool show = true) : code(pCode), sh(show) {}. Na koniec w ciele <<operatora zwróć bieżącą linię if (sh)i return << os;inaczej. Pozwala to napisać kod, w Color::Modifier red(Color::FG_RED, BoolVar);którym można ustawić wartość BoolVartrue lub false jako inicjalizację programu. Możesz go włączyć, aby zobaczyć na ekranie, i wyłączyć, aby przekierować do pliku.
rpsml
42

Przed wydrukowaniem dowolnego koloru upewnij się, że jesteś w terminalu:

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

Następnie musisz sprawdzić możliwości terminala, jeśli obsługuje kolor

w systemach z terminfo (Linux) możesz uzyskać ilość obsługiwanych kolorów jak

Number_Of_colors_Supported=$(tput colors)

w systemach z termcap (opartych na BSD) można uzyskać ilość obsługiwanych kolorów jak

Number_Of_colors_Supported=$(tput Co)

Następnie podejmij decyzję:

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

BTW, nie używaj kolorowania, jak wcześniej sugerowano dla znaków ESC. Użyj standardowego połączenia z terminalem, które przypisuje Ci POPRAWNE kolory, które obsługują dany terminal.

Na podstawie 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)"
Oparty na systemie 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)"
Użyj jako
echo -e "${fg_red}  Red  ${fg_green} Bull ${reset}"
Alex
źródło
3
Czy to nie jest specyficzne bash? -t 1 oczywiście nie będzie działać w C ++, a wywołanie tego programu tput sprawi, że będzie on bardzo okrągły w programie C ++.
Macha,
2
@Macha, tak, [ -t 1 ]jest specyficzny dla sh / bash, ale po prawej stronie po #(comment)znaku jest funkcja C, która robi to samo. man 3 isattypowinien pomóc w tym;) Przykład pokazany jako polecenia powłoki w celu uproszczenia wyjaśnienia głównego punktu. Jeśli chodzi o tputnarzędzie źródłowe OPEN, do zapytania o standardowy interfejs funkcji terminalu.
Alex
1
Nie jestem pewien, dlaczego ludzie wciąż sugerują bezpośrednie używanie tych kodów. Przyjmowanie takich założeń jest naprawdę złą praktyką. Nawet jeśli jest to kod specyficzny dla powłoki, może być przetłumaczony przez każdego, kto ma doświadczenie w korzystaniu z powłoki.
osirisgothra
34

Jak powiedzieli inni, możesz używać znaków ucieczki. Możesz użyć mojego nagłówka , aby ułatwić:

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

Przykładem użycia makr nagłówka może być:

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

wprowadź opis zdjęcia tutaj

gon1332
źródło
Niesamowity nagłówek!
Zheng Qu
16

Korzystam z następującego rozwiązania, jest dość proste i eleganckie, można je łatwo wkleić do źródła i działa w systemie 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
źródło
14

Z mojego zrozumienia, typowy kod koloru ANSI

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

składa się z (nazwa i kodek)

  • FORMAT ATRYBUTU

    { "Default", "0" },
    { "Bold", "1" },
    { "Dim", "2" },
    { "Underlined", "3" },
    { "Blink", "5" },
    { "Reverse", "7" },
    { "Hidden", "8" }
  • PRZESZKOLONY KOLOR

    { "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" }
  • KOLOR TŁA

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

  • RESETUJ FORMAT ATRYBUTU

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

Dzięki tym informacjom łatwo jest pokolorować sznur „Jestem bananem!” z kolorem forground „Yellow” i kolorem tła „Green” w ten sposób

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

Lub z biblioteką C ++ pokoloruj

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

Więcej przykładów z FORMAT ATTRIBUTE tutajwprowadź opis zdjęcia tutaj

Feng Wang
źródło
Jest to znacznie lepsze i mogę go używać w moim rozszerzeniu PHP C ++.
Aftab Naveed
12

To stary temat, ale napisałem klasę z zagnieżdżonymi podklasami i elementami statycznymi dla kolorów zdefiniowanych przez proste makra C.

Dostałem colorfunkcję z tego postu Programowanie kolorowego tekstu w C w dreamincode.net przez użytkownika no2pencil.

Zrobiłem to w ten sposób, aby móc używać stałych statycznych w strumieniu std :: cout w następujący sposób:

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

Klasę i kod źródłowy programu testowego można pobrać tutaj .

cc::consolezresetuje do domyślnych kolorów i atrybutów konsoli, cc::underlinepodkreśli tekst, który działa na kit, który przetestowałem program testowy.

Zabarwienie:

black
blue
red
magenta
green
cyan
yellow
white

lightblack
lightblue
lightred
lightmagenta
lightgreen
lightcyan
lightyellow
lightwhite

Które mogą być używane zarówno z, jak foreiback podklasami statycznymi, statycznymi cc.

EDIT 2017

Właśnie dodam tutaj kod klasy, aby był bardziej praktyczny.

Makra kodów kolorów:

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

oraz główna funkcja koloru, która określa kolor lub atrybut ekranu:

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
źródło
2
Dzięki za kod. Dodałem kolejny kod ucieczki ANSI, aby umożliwić wyświetlanie pogrubionego tekstu:const char *cc::bold = CC_ATTR(1);
Drew Noakes,
Dzięki za dodanie. Dołączyłem to do kodu klasy.
Christos Lytras,
9

Możesz użyć sekwencji ucieczki, jeśli twój terminal to obsługuje. Na przykład:

echo \[\033[32m\]Hello, \[\033[36m\]colourful \[\033[33mworld!\033[0m\]
Vlad
źródło
9

Rozszerzona wersja nagłówka 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 */

Jak widać, ma więcej możliwości, takich jak możliwość tymczasowego, nieokreślonego ustawiania koloru tła i inne funkcje. Uważam również, że jest nieco bardziej przyjazny dla początkujących i łatwiej zapamiętać wszystkie funkcje.

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

Po prostu dołącz plik nagłówka do swojego projektu, a będziesz gotowy do rock and roll z kolorowym wyjściem terminalowym.

Odcienie
źródło
3

wypróbuj mój nagłówek tutaj, aby szybko i łatwo pokolorować tekst: Aedi's Color Header


Escape-Sequence-Color-Header

Pokoloruj swój wynik w Uniksie za pomocą C ++ !!


Opcje atrybutu tekstowego:

ATTRIBUTES_OFF, BOLD, UNDERSCORE, BLINK, REVERSE_VIDEO, CONCEALED


Opcje kolorów:

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


Format:

Format ogólny, podaj wartość, którą chcesz w zmiennej $ $

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

na przykład

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


Stosowanie:

Po prostu użyj, aby przesłać strumieniowo żądany kolor przed wydrukowaniem tekstu i użyj ponownie, aby ustawić kolor na normalny po wydrukowaniu tekstu.

cout << COLOR_BLUE_BLACK << "TEXT" << COLOR_NORMAL << endl;
cout << COLOR_BOLD_YELLOW_CYAN << "TEXT" << COLOR_NORMAL << endl;
Uduse
źródło
To jest odpowiedź tylko do linku i stanie się bezużyteczna, jeśli link się zepsuje. Dodaj kod lub
opracuj
2
Przepraszam, początkujący tutaj ... Właśnie dodałem więcej informacji. Dozować tę pracę?
Uduse,
@ sjm324 Myślę, że obsługa BLINK jest oparta na twoim systemie
Uduse
3

Możesz użyć kodów kolorów ANSI.

użyj tych funkcji.

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
źródło
2

Najlepszym sposobem jest użycie biblioteki ncurses - choć może to być młot do złamania nakrętki, jeśli chcesz uzyskać prosty kolorowy łańcuch

Nacięcie
źródło
3
@Nick Korzystanie z ncurses byłoby kłopotliwe, aby uzyskać echo. :)
okaziciela pierścienia
2

w powłoce OSX to działa dla mnie (w tym 2 spacje przed „czerwonym tekstem”):

$ printf "\e[033;31m  red text\n"
$ echo "$(tput setaf 1)  red text"
BananaAcid
źródło