Coloring a specified char in C++ - c++

Question

I have a minesweeper console game and I want to make it a bit more beautiful. I found some coloring libraries from the internet. and used them.
the library is:
// ConsoleColor.h
#pragma once
#include <iostream>
#include <windows.h>
inline std::ostream& blue(std::ostream &s)
{
HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hStdout, FOREGROUND_BLUE
|FOREGROUND_GREEN|FOREGROUND_INTENSITY);
return s;
}
inline std::ostream& red(std::ostream &s)
{
HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hStdout,
FOREGROUND_RED|FOREGROUND_INTENSITY);
return s;
}
inline std::ostream& green(std::ostream &s)
{
HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hStdout,
FOREGROUND_GREEN|FOREGROUND_INTENSITY);
return s;
}
inline std::ostream& yellow(std::ostream &s)
{
HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hStdout,
FOREGROUND_GREEN|FOREGROUND_RED|FOREGROUND_INTENSITY);
return s;
}
inline std::ostream& white(std::ostream &s)
{
HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hStdout,
FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE);
return s;
}
struct color {
color(WORD attribute):m_color(attribute){};
WORD m_color;
};
template <class _Elem, class _Traits>
std::basic_ostream<_Elem,_Traits>&
operator<<(std::basic_ostream<_Elem,_Traits>& i, color& c)
{
HANDLE hStdout=GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hStdout,c.m_color);
return i;
}
It works fine but I have a question. is there anyway to colorize a character in cpp? for example I want to print all 'X' of my program red. is is possible?
thanks for helping

Answer 1

Yes, what you're asking for is entirely possible, though it appears that only a few people know much about the applicable parts of the library. Setting the highlight color with a manipulator adds a little bit more work, but not a whole lot. Code could look something like this:
#include <iostream>
#include <windows.h>
class attribute {
DWORD attrib;
public:
attribute(DWORD attrib) : attrib(attrib) {}
DWORD operator()() const { return attrib; }
};
class outbuf : public std::streambuf {
HANDLE h;
DWORD default_color = FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE;
DWORD highlight_color = FOREGROUND_GREEN;
public:
outbuf(HANDLE h) : h(h) {
SetConsoleTextAttribute(h, default_color);
}
void set_highlight(DWORD color) { highlight_color = color; }
protected:
virtual int_type overflow(int_type c) override {
if (c != EOF) {
if (c == 'x') {
SetConsoleTextAttribute(h, highlight_color);
DWORD written;
WriteConsole(h, &c, 1, &written, nullptr);
SetConsoleTextAttribute(h, default_color);
}
else {
DWORD written;
WriteConsole(h, &c, 1, &written, nullptr);
}
}
return c;
}
};
std::ostream &operator<<(std::ostream &os, attribute a) {
outbuf *out = dynamic_cast<outbuf *>(os.rdbuf());
if (out) {
out->set_highlight(a());
}
return os;
}
int main() {
outbuf buf(GetStdHandle(STD_OUTPUT_HANDLE));
attribute red{FOREGROUND_RED};
attribute blue{FOREGROUND_BLUE | FOREGROUND_INTENSITY};
std::cout.rdbuf(&buf);
std::cout << "oxen\n" << red << "axis\n" << blue << "waxy";
}
Result:

Answer 2

There are essentially two ways you can go about it:
Using the Console API (as illustrated in Jerry Coffin's answer).
Taking advantage of the console's ability to process Virtual Terminal Sequences1.
The latter is easier to implement and a lot more versatile. For example, it allows you to use the full range of 24-bit colors, something that isn't available through the Console API. The following illustrates how to enable processing of virtual terminal sequences, and how to use them:
#include <Windows.h>
#include <iostream>
// Define commonly used formatting control sequences
auto const& reset { L"\x1b[0m" };
auto const& red { L"\x1b[31m" };
auto const& bright_red { L"\x1b[91m" };
int wmain()
{
// Enable processing of virtual terminal sequences
auto output_handle { ::GetStdHandle(STD_OUTPUT_HANDLE) };
DWORD mode {};
auto success { ::GetConsoleMode(output_handle, &mode) };
mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
success = ::SetConsoleMode(output_handle, mode);
std::wcout << red << L"Red Text\n"
<< bright_red << L"Bright Red Text\n"
<< reset << L"Normal Text\n";
}
This produces the following output:
1 I wasn't able to find information on when virtual terminal sequence processing was introduced into Windows' console.