Comment imprimer du texte en couleur sur un terminal Linux?

300

Comment imprimer des caractères colorés sur un terminal Linux qui le prend en charge?

Comment savoir si le terminal prend en charge les codes couleur?

Macha
la source
9
Pour déterminer les capacités du terminal, consultez la base de données des capacités du terminal. voir termcap(5).
jrockway
1
N'hésitez pas à consulter un extrait de code que je mets ici . C'est un petit outil qui colore sa sortie à l'aide de quelques macros.
epatel
7
"La base de données termcap est une fonction obsolète pour décrire les capacités des terminaux et des imprimantes à cellules de caractères. Elle n'est conservée que pour les capacités avec les anciens programmes; les nouveaux devraient utiliser la terminfo(5)base de données et les bibliothèques associées." -termcap(5)
OrangeDog
Vous pouvez facilement vous termcolor
Rudy Jessop
1
Si vous voulez faire des choses avancées avec l'impression couleur, je vous suggère de lire cet article. Je l'ai trouvé très utile
SubMachine

Réponses:

408

Vous devez sortir les codes couleurs ANSI . Notez que tous les terminaux ne le prennent pas en charge; si les séquences de couleurs ne sont pas prises en charge, les déchets s'affichent.

Exemple:

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

Voici \033le caractère ESC, ASCII 27. Il est suivi par [, puis zéro ou plusieurs nombres séparés par ;, et enfin la lettre m. Les chiffres décrivent la couleur et le format à partir desquels basculer.

Les codes pour les couleurs de premier plan et d'arrière-plan sont les suivants:

         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

De plus, vous pouvez les utiliser:

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

Consultez le tableau sur Wikipédia pour d'autres codes moins largement pris en charge.


Pour déterminer si votre terminal prend en charge les séquences de couleurs, lisez la valeur de la TERMvariable d'environnement. Il doit préciser le type de terminal particulier utilisé (par exemple vt100, gnome-terminal, xterm, screen, ...). Recherchez ensuite cela dans la base de données terminfo ; vérifier la colorscapacité.

Thomas
la source
15
C'était les genoux de l'abeille sur le BBS…
Potatoswatter
11
Que signifie m/ représente?
nipponese
4
@nipponese \033[et mmarquez le début et la fin de la séquence d'échappement pour les codes de couleur ANSI. Ref: en.wikipedia.org/wiki/ANSI_escape_code#CSI_codes
thameera
20
Je l'utilise en définissant des "manipulateurs", comme const std::string red("\033[0;31m");ou const std::string reset("\033[0m");. Ensuite, je peux écrire simplement cout << red << "red text" << reset << endl;.
Daniel Langr
4
Je regarderais cela pour une visualisation des couleurs: misc.flogisoft.com/bash/tip_colors_and_formatting
Liran Funaro
97

Les bases

J'ai écrit une classe C ++ qui peut être utilisée pour définir la couleur de premier plan et d'arrière-plan de la sortie. Cet exemple de programme sert d'exemple d'impression This ->word<- is red.et de mise en forme afin que la couleur de premier plan de wordsoit rouge.

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

La source

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

Avancée

Vous voudrez peut-être ajouter des fonctionnalités supplémentaires à la classe. Il est par exemple possible d'ajouter la couleur magenta et même des styles comme boldface . Pour ce faire, juste une autre entrée à l' Codeénumération. Ceci est une bonne référence.

Joel Sjögren
la source
Génial. Il peut être utile d'ajouter d'autres couleurs ainsi que des couleurs d'arrière-plan.
nano
7
quelques autres: `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_GRA__GRA__GRA_ 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
6
Si vous définissez operator<<pour Code, vous pouvez directement écrire std::cout << Color::FG_RED;au lieu de std::cout << Modifier(Color::FG_RED);. Autrement dit, Modifierne serait pas nécessaire.
Nawaz
2
@Nawaz Bonne idée. Voici une implémentation comme celle-ci: pastebin.com/zWC3t9hC . Cependant, je garderai mon implémentation d'origine dans la réponse car je pense qu'elle est plus extensible.
Joel Sjögren
1
En fait, j'aime mieux la première implémentation car vous pouvez ajouter un indicateur pour activer ou désactiver les couleurs: ajoutez bool sh;à la classe et changez le constructeur en Modifier (Code pCode, bool show = true) : code(pCode), sh(show) {}. Enfin, dans le corps de l' <<opérateur retourne la ligne courante if (sh)et return << os;autrement. Cela permet d'écrire votre code avec Color::Modifier red(Color::FG_RED, BoolVar);où vous pouvez définir BoolVarcomme vrai ou faux comme une initialisation du programme. Vous pouvez l'activer pour le voir à l'écran et le désactiver pour rediriger vers un fichier.
rpsml
42

Avant de sortir une couleur, vous devez vous assurer que vous êtes dans un terminal:

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

Ensuite, vous devez vérifier la capacité du terminal s'il prend en charge la couleur

sur les systèmes avec terminfo (basé sur Linux), vous pouvez obtenir une quantité de couleurs

Number_Of_colors_Supported=$(tput colors)

sur les systèmes avec termcap (basé sur BSD), vous pouvez obtenir la quantité de couleurs

Number_Of_colors_Supported=$(tput Co)

Ensuite, prenez votre décision:

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

BTW, n'utilisez pas la coloration comme cela a été suggéré auparavant avec les caractères ESC. Utilisez la capacité d'appel standard vers le terminal qui vous attribuera des couleurs CORRECTES que ce terminal prend en charge.

Basé sur 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)"
Basé sur 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)"
Utilisé comme
echo -e "${fg_red}  Red  ${fg_green} Bull ${reset}"
Alex
la source
3
N'est-ce pas spécifique à bash? -t 1 ne fonctionnera évidemment pas en C ++, et appeler ce programme tput le rendra très détourné lorsqu'il est dans un programme C ++.
Macha
2
@Macha, oui, [ -t 1 ]c'est spécifique à sh / bash, mais sur le côté droit après le #(comment)signe, il y a une fonction C qui fait de même. man 3 isattydevrait aider à ce sujet;) Exemple montré comme des commandes shell pour simplifier l'explication du point principal. En ce qui concerne tputson utilitaire source OPEN pour interroger l'interface de capacité de terminal standard.
Alex
1
Je ne sais pas pourquoi les gens continuent de suggérer d'utiliser ces codes directement. C'est vraiment, vraiment une mauvaise pratique de faire de telles hypothèses. Même s'il s'agit d'un code spécifique au shell, il peut être traduit par toute personne ayant même une expérience novice du shell.
osirisgothra
34

Comme d'autres l'ont dit, vous pouvez utiliser des caractères d'échappement. Vous pouvez utiliser mon en-tête pour vous faciliter la tâche:

#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 exemple utilisant les macros de l'en-tête pourrait être:

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

entrez la description de l'image ici

gon1332
la source
En-tête génial!
Zheng Qu
16

J'utilise la solution suivante, elle est assez simple et élégante, peut être facilement collée dans la source et fonctionne sous 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
la source
14

D'après ma compréhension, un code couleur ANSI typique

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

est composé de (nom et codec)

  • FORMAT ATTRIBUTE

    { "Default", "0" },
    { "Bold", "1" },
    { "Dim", "2" },
    { "Underlined", "3" },
    { "Blink", "5" },
    { "Reverse", "7" },
    { "Hidden", "8" }
  • COULEUR DE FOND

    { "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" }
  • COULEUR DE L'ARRIÈRE PLAN

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

  • RESET FORMAT ATTRIBUTE

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

Avec ces informations, il est facile de coloriser une chaîne "Je suis une banane!" avec la couleur de fond "Jaune" et la couleur de fond "Vert" comme ceci

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

Ou avec une bibliothèque C ++ colorize

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

Plus d'exemples avec FORMAT ATTRIBUTE icientrez la description de l'image ici

Feng Wang
la source
C'est beaucoup mieux et je peux l'utiliser dans mon extension PHP C ++.
Aftab Naveed
12

C'est un vieux sujet, mais j'ai écrit une classe avec des sous-classes imbriquées et des membres statiques pour les couleurs définies par de simples macros C.

J'ai obtenu la colorfonction de ce poste Color Text In C Programming dans dreamincode.net par l'utilisateur no2pencil.

Je l'ai fait de cette façon afin de pouvoir utiliser les constantes statiques dans le flux std :: cout comme ceci:

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

La classe et un code source du programme de test peuvent être téléchargés ici .

cc::consoleréinitialisera les couleurs et les attributs par défaut de la console, cc::underlinesoulignera le texte, qui fonctionne sur le mastic que j'ai testé le programme de test.

Couleurs:

black
blue
red
magenta
green
cyan
yellow
white

lightblack
lightblue
lightred
lightmagenta
lightgreen
lightcyan
lightyellow
lightwhite

Ce qui peut être utilisé avec les deux foreet les backsous - classes statiques de la ccclasse statique.

EDIT 2017

J'ajoute juste le code de classe ici pour être plus pratique.

Les macros de code couleur:

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

et la fonction de couleur principale qui définit une couleur ou un attribut à l'écran:

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
la source
2
Merci pour le code. J'ai ajouté un autre code d'échappement ANSI pour permettre l'affichage de texte en gras:const char *cc::bold = CC_ATTR(1);
Drew Noakes
Merci pour l'ajout. J'ai inclus cela dans le code de classe.
Christos Lytras
9

Vous pouvez utiliser des séquences d'échappement, si votre terminal le prend en charge. Par exemple:

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

Une version étendue de l'en-tête 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 */

Comme vous pouvez le voir, il a plus de fonctionnalités telles que la possibilité de définir la couleur d'arrière-plan temporairement, indéfiniment et d'autres fonctionnalités. Je pense aussi que c'est un peu plus convivial pour les débutants et plus facile à retenir de toutes les fonctions.

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

Incluez simplement le fichier d'en-tête dans votre projet et vous êtes prêt à basculer avec la sortie du terminal coloré.

Nuances
la source
3

essayez mon en-tête ici pour un moyen rapide et facile de colorer du texte: En-tête de couleur d'Aedi


En-tête-couleur-séquence-d'échappement

Colorez votre sortie sous Unix en utilisant C ++ !!


Options d'attribut de texte:

ATTRIBUTES_OFF, BOLD, UNDERSCORE, BLINK, REVERSE_VIDEO, CONCEALED


Options de couleur:

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


Format:

Format général, incluez la valeur souhaitée dans $ variable $

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

par exemple

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


Usage:

Utilisez simplement pour diffuser la couleur souhaitée avant de sortir le texte et utilisez à nouveau pour définir la couleur à la normale après la sortie du texte.

cout << COLOR_BLUE_BLACK << "TEXT" << COLOR_NORMAL << endl;
cout << COLOR_BOLD_YELLOW_CYAN << "TEXT" << COLOR_NORMAL << endl;
Uduse
la source
Il s'agit d'une réponse de lien uniquement et sera inutile si le lien tombe en panne. Veuillez ajouter du code ou élaborer votre réponse
dgilperez
2
Désolé, débutant ici ... Je viens d'ajouter quelques informations. Dose ce travail?
Uduse
@ sjm324 Je suppose que la prise en charge de BLINK est basée sur votre système
Uduse
3

Vous pouvez utiliser des codes couleurs ANSI.

utiliser ces fonctions.

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
la source
2

La meilleure façon est d'utiliser la bibliothèque ncurses - bien que cela puisse être un marteau pour casser un écrou si vous voulez simplement sortir une chaîne de couleur simple

pseudo
la source
3
@Nick, ce serait pénible d'utiliser ncurses pour réaliser simplement une coloration via l'écho. :)
porteur de l'anneau
2

sur OSX shell, cela fonctionne pour moi (dont 2 espaces devant "texte rouge"):

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