Comment puis-je sortie du texte de couleur à un terminal Linux?

Bases

J'ai écrit une classe C++ qui peuvent être utilisées pour mettre au premier plan et la couleur d'arrière-plan de la production. Cet exemple de programme est un exemple de l'impression This ->word<- is red. et la mise en forme, de sorte que la couleur de premier plan word est 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;
}

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 << "3[" << mod.code << "m";
        }
    };
}

Avancé

Vous pouvez ajouter des fonctionnalités supplémentaires à la classe. Il est, par exemple, possible d'ajouter de la couleur magenta et même les styles comme gras. Pour ce faire, une nouvelle entrée du Code énumération. Cette est une bonne référence.

Comme d'autres l'ont dit, vous pouvez utiliser les caractères d'échappement.
Vous pouvez utiliser l'en-tête afin de le rendre plus facile:

#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 à l'aide des 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;
}

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

J'ai eu le color fonction de ce post Couleur Du Texte Dans La Programmation En C dans dreamincode.net par l'utilisateur no2pencil.

Je l'ai fait de cette manière afin d'être en mesure d'utiliser les constantes statiques dans std::cout stream 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 programme de test de code source peut être téléchargé ici.

cc::console sera remis à la console par défaut les couleurs et les attributs, cc::underline souligne 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

Qui peut être utilisé à la fois avec fore et back statique de la sous-classes de la cc statique de la classe.

MODIFIER 2017

Je suis juste en ajoutant le code de la classe ici pour être plus pratique.

Le code de couleur des macros:

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

et la couleur principale fonction qui définit une couleur ou d'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);
}

À partir de ma compréhension, typique de la norme ANSI code de couleur

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

est composé de (nom et le codec)

• ATTRIBUT DE FORMAT

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

• FORGROUND COULEUR

  { "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 D'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

• RÉINITIALISER LE FORMAT DE L'ATTRIBUT

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

Avec cette information, il est facile de coloriser une chaîne de "je suis une banane!" avec forground couleur "Jaune" et la couleur d'arrière-plan "Vert" comme ce

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

Ou avec une bibliothèque C++ coloriser

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

Plus d'exemples de FORMAT de l'ATTRIBUT ici

tenter ma tête ici pour un moyen facile et rapide de couleur de texte: Aedi de la Couleur de l'en-Tête

Des Séquences D'Échappement-La Couleur De L'En-Tête

Couleur de Votre Sortie sous Unix à l'aide de C++!!

Texte De L'Attribut Options:

ATTRIBUTES_OFF, BOLD, UNDERSCORE, BLINK, REVERSE_VIDEO, CONCEALED

Options De Couleur:

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

Format:

Format général, comprennent la valeur que vous voulez dans la 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

Utilisation:

Simplement utiliser pour diffuser la couleur que vous voulez avant de sortir de texte et
utilisez à nouveau pour définir la couleur à la normale après la sortie de texte.

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

Le meilleur moyen est d'utiliser la bibliothèque ncurses - même si cela pourrait être une masse pour casser une noix si vous voulez juste à la sortie d'une simple couleur de la chaîne