ฉันจะพิมพ์อักขระสีไปยังเทอร์มินัล Linux ที่รองรับได้อย่างไร

ฉันจะบอกได้อย่างไรว่าเครื่องรองรับรหัสสีหรือไม่

คุณจำเป็นต้องส่งออกรหัสสี ANSI โปรดทราบว่าไม่ใช่เทอร์มินัลทั้งหมดสนับสนุนสิ่งนี้ หากไม่รองรับลำดับสีขยะจะปรากฏขึ้น

ตัวอย่าง:

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

ที่นี่\033เป็นตัวละคร ESC, ASCII 27. มันตามมาด้วย[แล้วศูนย์หรือมากกว่าตัวเลขคั่นด้วยและในที่สุดตัวอักษร; 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 ++ colorize

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

ตัวอย่างเพิ่มเติมที่มีรูปแบบที่นี่

นี่เป็นหัวข้อเก่า แต่ฉันเขียนคลาสที่มีคลาสย่อยซ้อนกันและสมาชิกแบบสแตติกสำหรับสีที่กำหนดโดยแมโคร C แบบง่าย

ฉันได้รับcolorฟังก์ชั่นจากโพสต์ข้อความสีในการเขียนโปรแกรม Cใน dreamincode.net โดยผู้ใช้ no2pencil

ฉันทำมันด้วยวิธีนี้เพื่อให้สามารถใช้ค่าคงที่คงที่ใน std :: cout stream ดังนี้:

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

คุณสามารถใช้ลำดับ escape หากเทอร์มินัลของคุณรองรับ ตัวอย่างเช่น:

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

เพียงรวมไฟล์ส่วนหัวในโครงการของคุณและคุณก็พร้อมที่จะร็อคแอนด์โรลด้วยเอาท์พุทเทอร์มินัลสี

ลองใช้ส่วนหัวของฉันที่นี่เพื่อหาวิธีระบายสีข้อความอย่างรวดเร็วและง่าย: Color Header ของ Aedi

หนีลำดับ-สีส่วนหัว

สีเอาท์พุทของคุณใน Unix โดยใช้ 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"