Renkli karakterleri destekleyen bir Linux terminaline nasıl yazdırabilirim?

Terminalin renk kodlarını destekleyip desteklemediğini nasıl anlarım?

ANSI renk kodlarını çıkarmanız gerekir . Tüm terminallerin bunu desteklemediğini unutmayın; renk dizileri desteklenmiyorsa, çöp görünecektir.

Misal:

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

Burada, \033ESC karakteri, ASCII 27'dir. Bunu [, ardından sıfır veya daha fazla sayı ile ayrılmış ;ve son olarak da harf izler m. Sayılar, o noktadan itibaren geçiş yapmak için renk ve formatı tanımlar.

Ön plan ve arka plan renkleri için kodlar:

         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

Ayrıca, bunları kullanabilirsiniz:

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

Daha az yaygın olarak desteklenen diğer kodlar için Wikipedia'daki tabloya bakın .

Terminalinizin renk dizilerini destekleyip desteklemediğini belirlemek için TERMortam değişkeninin değerini okuyun . Kullanılan özel terminal türünü belirtmek gerekir (örneğin vt100, gnome-terminal, xterm, screen, ...). Sonra terminfo veritabanına bakın ; colorsyeteneği kontrol edin .

temeller

Çıktının ön ve arka plan rengini ayarlamak için kullanılabilecek bir C ++ sınıfı yazdım. Bu örnek program This ->word<- is red., ön plan rengi wordkırmızı olacak şekilde yazdırma ve biçimlendirme örneği olarak kullanılır .

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

Kaynak

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

ileri

Sınıfa ek özellikler eklemek isteyebilirsiniz. Örneğin, macenta rengini ve hatta kalın yazı gibi stilleri eklemek mümkündür . Bunu yapmak için, Codenumaralandırmaya sadece başka bir giriş . Bu iyi bir referans.

Herhangi bir rengi çıkarmadan önce bir terminalde olduğunuzdan emin olun:

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

Daha sonra rengi destekliyorsa terminal kapasitesini kontrol etmeniz gerekir

(Linux tabanlı) sistemlerdeterminfo , desteklenen renklerin miktarını

Number_Of_colors_Supported=$(tput colors)

termcap (BSD tabanlı) sistemlerde , desteklenen renklerin miktarını şu şekilde elde edebilirsiniz:

Number_Of_colors_Supported=$(tput Co)

Sonra karar verin:

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

BTW, ESC karakterleriyle daha önce önerildiği gibi renklendirme kullanmayın. Terminalin desteklediği DOĞRU renkleri atayacağınız standart terminal çağrısı özelliğini kullanın.

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

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

echo -e "${fg_red}  Red  ${fg_green} Bull ${reset}"

Diğerlerinin de belirttiği gibi, kaçış karakterleri kullanabilirsiniz. Sen kullanabilirsiniz benim başlığını kolaylaştırmak amacıyla:

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

Üstbilginin makrolarını kullanan bir örnek şunlar olabilir:

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

Aşağıdaki çözümü kullanıyorum, oldukça basit ve zarif, kaynağa kolayca yapıştırılabilir ve Linux / Bash üzerinde çalışır:

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;

Anladığım kadarıyla, tipik bir ANSI renk kodu

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

şunlardan oluşur (ad ve kodek)

• FORMAT ATTRIBUTE

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

• UNUTULAN RENK

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

• ARKA PLAN RENGİ

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

• METİN

• FORMAT ATTRIBUTE'İ SIFIRLA

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

Bu bilgi ile, "Ben bir muzum!" Dizesini renklendirmek kolaydır. forground color "Yellow" ve arka plan rengi "Green" gibi

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

Veya bir C ++ kütüphanesi ile renklendirme

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

FORMAT ATTRIBUTE ile daha fazla örnek burada

Bu eski bir konudur, ancak basit C makroları tarafından tanımlanan renkler için iç içe alt sınıfları ve statik üyeleri olan bir sınıf yazdım.

colorBu yazıdan fonksiyon aldım Renkli Metin In C Programlama dreamincode.net kullanıcı no2pencil tarafından.

Bu şekilde std :: cout akışında statik sabitleri şu şekilde kullanabilmek için bu şekilde yaptım:

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

Sınıf ve bir test programı kaynak kodu indirilebilir burada .

cc::console konsolun varsayılan renklerine ve niteliklerine sıfırlanacak, cc::underline , test programını test ettiğim macun üzerinde çalışan metnin altını çizecektir.

Renkler:

black
blue
red
magenta
green
cyan
yellow
white

lightblack
lightblue
lightred
lightmagenta
lightgreen
lightcyan
lightyellow
lightwhite

Hangi statik sınıfın hem foreve backstatik alt sınıfları ile kullanılabilir cc.

2017 DÜZENLE

Daha pratik olmak için burada sadece sınıf kodunu ekliyorum.

Renk kodu makroları:

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

ve ekrana bir renk veya nitelik tanımlayan ana renk işlevi:

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

Terminaliniz destekliyorsa kaçış dizileri kullanabilirsiniz. Örneğin:

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

Gon1332 başlığının genişletilmiş bir sürümü:

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

Gördüğünüz gibi, arka plan rengini geçici olarak, süresiz olarak ayarlama ve diğer özellikler gibi daha fazla özelliğe sahiptir. Ben de biraz daha başlangıç ​​dostu ve tüm fonksiyonları hatırlamak daha kolay olduğuna inanıyorum.

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

Başlık dosyasını projenize eklemeniz yeterlidir ve renkli terminal çıktısıyla sallanmaya ve sarılmaya hazırsınız.

metni renklendirmenin hızlı ve kolay bir yolu için başlığımı burada deneyin: Aedi'nin Renk Başlığı

Kaçış-Dizi-Renk-Başlık

C ++ kullanarak Unix Çıktınızı Renklendirin !!

Metin Özellik Seçenekleri:

ATTRIBUTES_OFF, BOLD, UNDERSCORE, BLINK, REVERSE_VIDEO, CONCEALED

Renk Seçenekleri:

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

Biçim:

Genel Biçim, $ değişken $ içine istediğiniz değeri ekleyin

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

Örneğin

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

Kullanımı:

Metin çıkmadan önce istediğiniz rengi akıtmak için kullanın ve metin çıktıktan sonra rengi normale ayarlamak için tekrar kullanın.

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

ANSI renk kodlarını kullanabilirsiniz.

bu işlevleri kullanın.

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

En iyi yol ncurses kütüphanesini kullanmaktır - ancak basit bir renkli dize çıkarmak istiyorsanız bir somun kırmak için bir balyoz olabilir.

OSX kabuğunda, bu benim için çalışıyor ("kırmızı metin" önünde 2 boşluk dahil):

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