컬러 문자를 지원하는 Linux 터미널에 컬러 문자를 어떻게 인쇄합니까?

터미널이 컬러 코드를 지원하는지 어떻게 알 수 있습니까?

ANSI 색상 코드 를 출력해야합니다 . 모든 터미널이이를 지원하지는 않습니다. 색상 순서가 지원되지 않으면 가비지가 나타납니다.

예:

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

여기 \033에는 ESC 문자 인 ASCII 27이 있습니다. 뒤에 [, 그 뒤에 0으로 분리 된 숫자 ;, 및 문자로 구분됩니다 .m . 숫자는 그 시점부터 전환 할 색상과 형식을 나타냅니다.

전경색 및 배경색의 코드는 다음과 같습니다.

         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

또한 다음을 사용할 수 있습니다.

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

덜 널리 지원되는 다른 코드 는 Wikipedia 의 표를 참조하십시오 .

터미널이 색상 순서를 지원하는지 확인하려면 TERM환경 변수 의 값을 읽으십시오 . 또한 사용 된 특정 단말기 유형을 지정한다 (예를 들어 vt100, gnome-terminal, xterm, screen, ...). 그런 다음 terminfo 데이터베이스 에서 찾아보십시오 . colors기능을 확인하십시오 .

기초

출력의 전경색과 배경색을 설정하는 데 사용할 수있는 C ++ 클래스를 작성했습니다. 이 샘플 프로그램은 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열거에 대한 또 다른 항목이 필요합니다 . 이것은 좋은 참조입니다.

색상을 출력하기 전에 터미널에 있는지 확인하십시오.

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

그런 다음 색상을 지원하는 경우 터미널 기능을 확인해야합니다

terminfo (Linux 기반) 시스템 에서는 지원되는 색상을 다음과 같이 얻을 수 있습니다.

Number_Of_colors_Supported=$(tput colors)

termcap (BSD 기반) 시스템 에서 지원되는 색상의 양을 다음과 같이 얻을 수 있습니다.

Number_Of_colors_Supported=$(tput Co)

그런 다음 결정하십시오.

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

BTW, 이전에 ESC 문자에서 제안한대로 색상을 사용하지 마십시오. 특정 터미널이 지원하는 올바른 색상을 지정하는 표준 콜투 터미널 기능을 사용하십시오.

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

다른 사람들이 말했듯이 이스케이프 문자를 사용할 수 있습니다. 당신이 사용할 수있는 내 헤더를 보다 쉽게하기 위해 :

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

다음 솔루션을 사용합니다. 매우 간단하고 우아하며 쉽게 소스에 붙여 넣을 수 있으며 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;

내 이해에서 일반적인 ANSI 색상 코드

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

이 정보로 문자열 "I am a banana!"를 쉽게 채색 할 수 있습니다. 전경색 "노란색"과 배경색 "녹색"

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

또는 C ++ 라이브러리를 사용하여 색상을 지정하십시오.

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

FORMAT ATTRIBUTE에 대한 추가 예는 여기

이것은 오래된 주제이지만 간단한 C 매크로로 정의 된 색상에 대한 중첩 서브 클래스와 정적 멤버가있는 클래스를 작성했습니다.

color이 게시물 에서 함수 no2pencil에 의해 dreamincode.net의 C 프로그래밍의 컬러 텍스트를 얻었습니다.

std :: cout 스트림에서 정적 상수를 다음과 같이 사용할 수 있도록이 방법으로 만들었습니다.

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

클래스 및 테스트 프로그램 소스 코드는 여기에서 다운로드 할 수 있습니다 .

cc::console콘솔 기본 색상과 속성으로 재설정 cc::underline하고 텍스트에 밑줄을 긋고 테스트 프로그램을 테스트 한 퍼티에서 작동합니다.

그림 물감:

black
blue
red
magenta
green
cyan
yellow
white

lightblack
lightblue
lightred
lightmagenta
lightgreen
lightcyan
lightyellow
lightwhite

정적 클래스의 정적 서브 클래스 fore와 back정적 서브 클래스 와 함께 사용할 수 있습니다 cc.

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

터미널에서 지원하는 경우 이스케이프 시퀀스를 사용할 수 있습니다. 예를 들면 다음과 같습니다.

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

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

보시다시피 배경색을 일시적으로, 무기한으로 설정하는 기능 및 기타 기능과 같은 더 많은 기능이 있습니다. 나는 또한 초보자에게 친숙하고 모든 기능을 기억하기가 더 쉽다고 생각합니다.

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

프로젝트에 헤더 파일을 포함시키기 만하면 컬러 터미널 출력으로 락앤롤 할 수 있습니다.

텍스트를 빠르고 쉽게 채색하는 방법을 보려면 여기에 헤더를 입력하십시오 : Aedi 's Color Header

이스케이프 시퀀스 색상 헤더

C ++를 사용하여 유닉스에서 출력물을 채색하십시오 !!

텍스트 속성 옵션 :

ATTRIBUTES_OFF, BOLD, UNDERSCORE, BLINK, REVERSE_VIDEO, CONCEALED

색상 옵션 :

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

체재:

일반 형식 ($ variable $에 원하는 값 포함)

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;

ANSI 색상 코드를 사용할 수 있습니다.

이 기능을 사용하십시오.

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

가장 좋은 방법은 ncurses 라이브러리를 사용하는 것입니다. 단순히 색상이 지정된 문자열을 출력하려는 ​​경우 너트를 크랙하는 망치가 될 수 있습니다.

OSX 쉘에서 이것은 나를 위해 작동합니다 ( "빨간색 텍스트"앞에 2 공백 포함).

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