c++ - मैं लिनक्स टर्मिनल में रंगीन पाठ कैसे आउटपुट करूं?




linux colors (8)

मूल बातें

मैंने एक सी ++ कक्षा लिखी है जिसे आउटपुट के अग्रभूमि और पृष्ठभूमि रंग को सेट करने के लिए उपयोग किया जा सकता है। यह नमूना कार्यक्रम प्रिंटिंग का एक उदाहरण के रूप में कार्य करता है This ->word<- is red. और इसे स्वरूपित करना ताकि word का अग्रभूमि रंग लाल हो।

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

स्रोत

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

उन्नत

आप कक्षा में अतिरिक्त सुविधाएं जोड़ना चाह सकते हैं। उदाहरण के लिए, रंग मैजेंटा और बोल्डफेस जैसी शैलियों को भी जोड़ना संभव है। ऐसा करने के लिए, Code गणना में बस एक और प्रविष्टि। This एक अच्छा संदर्भ है।

मैं रंगीन वर्णों को एक लिनक्स टर्मिनल में कैसे प्रिंट करूं जो इसका समर्थन करता है?

मैं कैसे बता सकता हूं कि टर्मिनल रंग कोड का समर्थन करता है या नहीं?

मैं इस कार्यक्रम के लिए सी ++ का उपयोग कर रहा हूँ।


आप एएनएसआई रंग कोड का उपयोग कर सकते हैं।

इन कार्यों का उपयोग करें।

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 रिक्त स्थान सहित):

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

कलर टेक्स्ट के त्वरित और आसान तरीके के लिए मेरे हेडर को आजमाएं: एडी का रंग हैडर


एस्केप अनुक्रम-रंग-हैडर

सी ++ का उपयोग कर यूनिक्स में अपना आउटपुट रंगो !!


टेक्स्ट विशेषता विकल्प:

ATTRIBUTES_OFF, BOLD, UNDERSCORE, BLINK, REVERSE_VIDEO, CONCEALED


रंग विकल्प:

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


प्रारूप:

सामान्य प्रारूप, उस मान को शामिल करें जिसे आप $ चर $ में चाहते हैं

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

जैसे

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


उपयोग:

पाठ को आउटपुट करने से पहले इच्छित रंग को स्ट्रीम करने के लिए बस उपयोग करें और पाठ को आउटपुट करने के बाद रंग को सामान्य पर सेट करने के लिए फिर से उपयोग करें।

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

जैसा कि अन्य ने कहा है, आप बचने के पात्रों का उपयोग कर सकते हैं। इसे आसान बनाने के लिए आप मेरे शीर्षलेख का उपयोग कर सकते हैं:

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

शीर्षलेख के मैक्रोज़ का उपयोग करने वाला एक उदाहरण हो सकता है:

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


मेरी समझ से, एक सामान्य एएनएसआई रंग कोड

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

से बना है (नाम और कोडेक)

  • फॉर्मेट अटूट

    { "Default", "0" },
    { "Bold", "1" },
    { "Dim", "2" },
    { "Underlined", "3" },
    { "Blink", "5" },
    { "Reverse", "7" },
    { "Hidden", "8" }
    
  • रंगीन रंग

    { "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" }
    
  • पीछे का रंग

    { "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" }
    
  • पाठ

  • रीसेट फॉर्मेट एट्रिब्यूट

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

इस जानकारी के साथ, एक स्ट्रिंग को रंगना आसान है "मैं केले हूं!" इस तरह के भूमिगत रंग "पीला" और पृष्ठभूमि रंग "हरा" के साथ

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

या एक सी ++ लाइब्रेरी colorize

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

यहां फॉर्मेट अटूट के साथ अधिक उदाहरण


यदि आपका टर्मिनल इसका समर्थन करता है तो आप बचने के दृश्यों का उपयोग कर सकते हैं। उदाहरण के लिए:

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

यह एक पुराना विषय है, लेकिन मैंने सरल सी मैक्रोज़ द्वारा परिभाषित रंगों के लिए नेस्टेड सबक्लास और स्थिर सदस्यों के साथ एक कक्षा लिखी है।

मुझे इस पोस्ट से color फ़ंक्शन में रंगीन पाठ सी प्रोग्रामिंग में dreamincode.net में उपयोगकर्ता no2pencil द्वारा मिला है।

मैंने इसे इस तरह बनाया है ताकि std :: cout स्ट्रीम में स्थिर स्थिरांक का उपयोग करने में सक्षम हो:

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

कक्षा और एक परीक्षण कार्यक्रम स्रोत कोड here डाउनलोड किया जा सकता here

cc::console कंसोल डिफ़ॉल्ट रंगों और विशेषताओं को रीसेट कर देगा, cc::underline टेक्स्ट को रेखांकित करेगी, जो पट्टी पर काम करती है जिसे मैंने परीक्षण कार्यक्रम का परीक्षण किया है।

रंग की:

black
blue
red
magenta
green
cyan
yellow
white

lightblack
lightblue
lightred
lightmagenta
lightgreen
lightcyan
lightyellow
lightwhite

जिसका उपयोग cc स्थैतिक वर्ग के fore और back स्थिर सबक्लास दोनों के साथ किया जा सकता है।

2017 संपादित करें

मैं बस अधिक व्यावहारिक होने के लिए यहां कक्षा कोड जोड़ रहा हूं।

रंग कोड मैक्रोज़:

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

और मुख्य रंग फ़ंक्शन जो स्क्रीन पर रंग या विशेषता को परिभाषित करता है:

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




terminal