Исправить имеющийся вывод на вывод в виде таблицы

snprintf(msgtemp2, sizeof(msgtemp2), "------------- BATTLE.ON.KG TOP-15 -------------");
message_send_text(c,message_type_error,c,msgtemp2);
 
            snprintf(msgtemp, sizeof(msgtemp), "    Account    |    Score    |    Games    ");
            message_send_text(c,message_type_info,c,msgtemp);
            counter = 1;
            snprintf(query,sizeof(query),"select uid, acct_username,score,games FROM BNET ORDER BY `score` DESC LIMIT 15 ");
            result = sql->query_res(query);
            while(Row = sql->fetch_row(result))
            {
            int acct_username = std::atoi( Row[1] );
            int Score = std::atoi( Row[2] );
            int games = std::atoi( Row[3] );
                char* d_marker;
if (Score >= 0)
    d_marker = "D-";
if (Score >= 399)
    d_marker = "D-";
if (Score >= 400)
    d_marker = "D-";
if (Score >= 899)
    d_marker = "D-";
if (Score >= 900)
    d_marker = "D";
if (Score >= 1999)
    d_marker = "D";
if (Score >= 2000)
    d_marker = "D+";
if (Score >= 2999)
    d_marker = "D+";
if (Score >= 3000)
    d_marker = "C-";
if (Score >= 3999)
    d_marker = "C-";
if (Score >= 4000)
    d_marker = "C";
if (Score >= 4999)
    d_marker = "C";
if (Score >= 5000)
    d_marker = "C+";
if (Score >= 5999)
    d_marker = "C+";
if (Score >= 6000)
    d_marker = "B-";
if (Score >= 6999)
    d_marker = "B-";
if (Score >= 7000)
    d_marker = "B";
if (Score >= 7999)
    d_marker = "B";
if (Score >= 8000)
    d_marker = "B+";
if (Score >= 8999)
    d_marker = "B+";
if (Score >= 9000)
    d_marker = "A-";
if (Score >= 10499)
    d_marker = "A-";
if (Score >= 10500)
    d_marker = "A";
if (Score >= 11999)
    d_marker = "A";
if (Score >= 12000)
    d_marker = "A+";
if (Score >= 14999)
    d_marker = "A+";
if (Score >= 15000)
    d_marker = "A+";
if (Score >= 20000)
    d_marker = "A+";
            //int uid = std::atoi( Row[0] );
            snprintf(msgtemp, sizeof(msgtemp), "    %s    |    [%s] %s pts    |    %s " ,Row[1],d_marker,Row[2],Row[3]);
            message_send_text(c,message_type_info,c,msgtemp);

///----------------------------------------------------------------------------|
/// Пример использования.
///----------------------------------------------------------------------------:
void testclass_Tab()
{   ///-----------------------|
    /// Создаём табулятор.    |
    ///-----------------------:
    Tab tab;
 
    ///-----------------------|
    /// Заголовок.            |
    ///-----------------------:
        tab.head("NN", "Первый", "Второй", 3);
 
    ///-----------------------|
    /// Как угодно заполняем. |
    ///-----------------------:
        tab[1][1] = 2020;
        tab[2][2] = "qwerty";
        tab[4][3] = 3.14;
        tab[0][4] = "Яша + Оля";
 
    ///-----------------------|
    /// Вывод на экран/файл.  |
    ///-----------------------:
    std::cout << tab;
    std::cout << tab;
}
 
///----------------------------------------------------------------------------|
/// Старт.
///----------------------------------------------------------------------------:
int main()
{
    setlocale(0,"");
    testclass_Tab();
}

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
 
#define l(v) std::wcout << #v << " = " << (v) << "\n";
 
// Класс-обертка для преобразования в строку
class StringConverter
{
public:
    template<typename T>
    static std::wstring toString(T val)
    {
        std::wostringstream oss;
        oss << val;
        return oss.str();
    }
};
 
// Класс для работы со строками
class MyString : public std::wstring
{
public:
    MyString() : std::wstring() {}
    MyString(std::wstring s) : std::wstring(s) {}
    MyString(const wchar_t* s) : std::wstring(s) {}
 
    template<typename T>
    MyString& operator=(const T a)
    {
        *this = StringConverter::toString(a);
        return *this;
    }
};
 
// Класс для работы с вектором
template<typename T>
class MyVector : public std::vector<T>
{
public:
    T& operator[](const size_t i)
    {
        if (i >= this->size()) this->resize(i + 1);
        return *(this->begin() + i);
    }
 
    void resize(size_t new_size, const T& value = T())
    {
        std::vector<T>::resize(new_size, value);
    }
};
 
// Класс для форматирования таблицы
class TableFormatter
{
private:
    size_t CMAX;
    MyVector<MyVector<MyString>>& m;
    MyVector<MyString>& h;
 
public:
    TableFormatter(size_t& cmax, MyVector<MyVector<MyString>>& data,
        MyVector<MyString>& header)
        : CMAX(cmax), m(data), h(header) {
    }
 
    void format()
    {
        calculateMaxColumns();
        resizeRows();
        addRowNumbers();
        calculateColumnWidths();
        alignColumns();
        alignHeaders();
    }
 
private:
    void calculateMaxColumns()
    {
        for (const auto& e : m)
            if (CMAX < e.size())
                CMAX = e.size();
    }
 
    void resizeRows()
    {
        for (auto& e : m)
            if (CMAX > e.size())
                e.resize(CMAX);
 
        if (CMAX > h.size())
            h.resize(CMAX);
    }
 
    void addRowNumbers()
    {
        for (size_t r = 0; r < m.size(); ++r)
        {
            m[r][0] = StringConverter::toString(r + 1);
        }
    }
 
    void calculateColumnWidths()
    {
        std::vector<size_t> n(CMAX, 0);
 
        // Инициализация ширинами заголовков
        for (size_t i = 0; i < h.size() && i < CMAX; ++i)
        {
            n[i] = h[i].size();
        }
 
        // Нахождение максимальных ширин
        for (size_t c = 0; c < CMAX; ++c)
        {
            for (size_t r = 0; r < m.size(); ++r)
            {
                if (n[c] < m[r][c].size())
                    n[c] = m[r][c].size();
            }
        }
 
        // Выравнивание столбцов
        for (size_t c = 0; c < CMAX; ++c)
        {
            for (size_t r = 0; r < m.size(); ++r)
            {
                if (n[c] > m[r][c].size())
                    m[r][c].resize(n[c], ' ');
            }
        }
 
        // Выравнивание заголовков
        for (size_t c = 0; c < CMAX; ++c)
        {
            if (h[c].size() < m[0][c].size())
                h[c].resize(m[0][c].size(), ' ');
        }
    }
 
    void alignColumns() {} // Заглушка для совместимости с логикой
    void alignHeaders() {} // Заглушка для совместимости с логикой
};
 
// Класс для вывода таблицы
class TablePrinter
{
private:
    MyVector<MyVector<MyString>>& m;
    MyVector<MyString>& h;
    size_t& CMAX;
 
public:
    TablePrinter(MyVector<MyVector<MyString>>& data,
        MyVector<MyString>& header, size_t& cmax)
        : m(data), h(header), CMAX(cmax) {
    }
 
    void print(std::wostream& o)
    {
        std::wstring line = createLine();
 
        o << line << '\n';
        printHeader(o);
        o << '\n' << line << '\n';
        printRows(o);
        o << line << '\n' << '\n';
    }
 
private:
    std::wstring createLine()
    {
        std::wstring line;
        for (size_t c = 0; c < CMAX; ++c)
        {
            line += std::wstring(h[c].size() + 3, '=');
        }
        return line;
    }
 
    void printHeader(std::wostream& o)
    {
        for (size_t c = 0; c < CMAX; ++c)
        {
            o << ' ' << h[c] << " |";
        }
    }
 
    void printRows(std::wostream& o)
    {
        for (const auto& r : m)
        {
            for (const auto& e : r)
            {
                o << ' ' << e << " |";
            }
            o << '\n';
        }
    }
};
 
// Основной класс таблицы
class Tab
{
private:
    MyVector<MyVector<MyString>> m;
    MyVector<MyString> h;
    size_t CMAX = 0;
 
public:
    Tab() = default;
 
    MyVector<MyString>& operator[](const size_t i)
    {
        if (i >= m.size()) m.resize(i + 1);
        return *(m.begin() + i);
    }
 
    template<typename ... T>
    void head(T ... t)
    {
        (h.push_back(StringConverter::toString(t)), ...);
    }
 
    void formater()
    {
        TableFormatter formatter(CMAX, m, h);
        formatter.format();
    }
 
    friend std::wostream& operator<<(std::wostream&, Tab&);
};
 
std::wostream& operator<<(std::wostream& o, Tab& t)
{
    t.formater();
 
    TablePrinter printer(t.m, t.h, t.CMAX);
    printer.print(o);
 
    return o;
}
 
///----------------------------------------------------------------------------|
/// Тест.
///----------------------------------------------------------------------------:
class TabTest
{
public:
    void run()
    {
        ///-----------------------|
        /// Создаём табулятор.    |
        ///-----------------------:
        Tab tab;
 
        ///-----------------------|
        /// Заголовок.            |
        ///-----------------------:
        tab.head(L"NN", L"Первый", L"Второй", 3);
 
        ///-----------------------|
        /// Как угодно заполняем. |
        ///-----------------------:
        tab[1][1] = 2020;
        tab[2][2] = "qwerty";
        tab[4][3] = 3.14;
        tab[0][4] = L"Яша + Оля";
 
        ///-----------------------|
        /// Вывод на экран/файл.  |
        ///-----------------------:
        std::wcout << tab;
        std::wcout << tab;
    }
};
 
///----------------------------------------------------------------------------|
/// Старт.
///----------------------------------------------------------------------------:
int main()
{
    setlocale(0, "");
 
    TabTest test;
    test.run();
 
    return 0;
}

template<typename T>
MyString& operator=(const T a)
{
    *this = StringConverter::toString(a);
    return *this;
}

template<typename T>
MyString& operator=(const T a)
{
    *static_cast<std::wstring *>(this) = StringConverter::toString(a);
    return *this;
}

// Класс для работы со строками
class MyString : public std::wstring
{
public:
    MyString() : std::wstring() {}
    MyString(std::wstring    s) : std::wstring(s) {}
    MyString(const wchar_t*  s) : std::wstring(s) {}
 
    MyString& operator=(const std::wstring& a)
    {   return   *static_cast<std::wstring*>(this) = a, *this;
    }
 
    template<typename T>
    MyString& operator=(const T a)
    {   *this = StringConverter::toString(a);
        return *this;
    }
};

class TabTest
{
public:
    void run()
    {
        ///-----------------------|
        /// Создаём табулятор.    |
        ///-----------------------:
        Tab tab;
 
        ///-----------------------|
        /// Заголовок.            |
        ///-----------------------:
        tab.head(L"NN", L"Первый", L"Второй", 3);
 
        ///-----------------------|
        /// Как угодно заполняем. |
        ///-----------------------:
        tab[1][1] = 2020;
        tab[2][2] = "qwerty";
        tab[4][3] = 3.14;
        tab[0][4] = L"Яша + Оля";
 
        ///-----------------------|
        /// Вывод на экран/файл.  |
        ///-----------------------:
        std::wcout << tab;
        std::wcout << tab;
    }
};

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
 
#define l(v) std::wcout << #v << " = " << (v) << "\n";
 
 
// Класс-обертка для преобразования в строку
class StringConverter
{
public:
    template<typename T>
    static std::wstring toString(T val)
    {   return (std::wostringstream() << val).str();
    }
};
 
 
// Класс для работы со строками
class MyString : public std::wstring
{
public:
    MyString() : std::wstring() {}
    MyString(std::wstring    s) : std::wstring(s) {}
    MyString(const wchar_t*  s) : std::wstring(s) {}
 
    MyString& operator=(const std::wstring& a)
    {   return   *static_cast<std::wstring*>(this) = a, *this;
    }
 
    template<typename T> 
    MyString& operator=(const T a)
    {   return *this = StringConverter::toString(a);
    }
};
 
 
// Класс для работы с вектором
template<typename T>
class MyVector : public std::vector<T>
{
public:
    T& operator[](const size_t i)
    {   if (i >= this->size()) this->resize(i + 1);
        return *(this->begin() + i);
    }
 
    void resize(size_t new_size, const T& value = T())
    {   std::vector<T>::resize(new_size, value);
    }
};
 
 
// Класс для форматирования таблицы
class TableFormatter
{
private:
    MyVector<MyVector<MyString>>& m;
    MyVector<MyString>&           h;
    size_t&                    CMAX;
 
public:
    TableFormatter(size_t&                       cmax,
                   MyVector<MyVector<MyString>>& data,
                   MyVector<MyString>&         header)
        :  m(data), h(header), CMAX(cmax)
    {
    }
 
    void format()
    {   calculateMaxColumns  ();
        resizeRows           ();
        addRowNumbers        ();
        calculateColumnWidths();
        alignColumns         ();
        alignHeaders         ();
    }
 
private:
    void calculateMaxColumns ()
    {   for (const auto& e : m)
            if (CMAX < e.size())
                CMAX = e.size();
    }
 
    void resizeRows()
    {   for (auto& e : m)
            if (CMAX > e.size()) e.resize(CMAX);
 
        if     (CMAX > h.size()) h.resize(CMAX);
    }
 
    void addRowNumbers()
    {   for (size_t r = 0; r < m.size(); ++r)
        {   m[r][0] = StringConverter::toString(r + 1);
        }
    }
 
    void calculateColumnWidths()
    {   std::vector<size_t> n(CMAX, 0);
 
        // Инициализация ширинами заголовков
        for (size_t i = 0; i < h.size() && i < CMAX; ++i)
        {   n[i] = h[i].size();
        }
 
        // Нахождение максимальных ширин
        for     (size_t c = 0; c < CMAX;     ++c)
        {   for (size_t r = 0; r < m.size(); ++r)
            {   if (n[c] < m[r][c].size())
                    n[c] = m[r][c].size();
            }
        }
 
        // Выравнивание столбцов
        for     (size_t c = 0; c < CMAX;     ++c)
        {   for (size_t r = 0; r < m.size(); ++r)
            {   if (n[c] > m[r][c].size())
                    m[r][c].resize(n[c], ' ');
            }
        }
 
        // Выравнивание заголовков
        for (size_t c = 0; c < CMAX; ++c)
        {   if (h[c].size() < m[0][c].size())
                h[c].resize ( m[0][c].size(), ' ');
        }
    }
 
    void alignColumns() {} // Заглушка для совместимости с логикой
    void alignHeaders() {} // Заглушка для совместимости с логикой
};
 
 
// Класс для вывода таблицы
class TablePrinter
{
private:
    MyVector<MyVector<MyString>>& m;
    MyVector<MyString>&           h;
    size_t&                    CMAX;
 
public:
    TablePrinter(
        size_t&                        cmax,
        MyVector<MyVector<MyString>>&  data,
                 MyVector<MyString>& header)
        : CMAX(cmax), m(data), h(header)
    {
    }
 
    void print(std::wostream& o)
    {   std::wstring line = createLine();
 
        o << line << '\n';
        printHeader(o);
        o << '\n' << line << '\n';
        printRows(o);
        o << line << '\n' << '\n';
    }
 
private:
    std::wstring createLine()
    {   std::wstring line;
        for (size_t c = 0; c < CMAX; ++c)
        {   line += std::wstring(h[c].size() + 3, '=');
        }
        return line;
    }
 
    void printHeader(std::wostream& o)
    {   for (size_t c = 0; c < CMAX; ++c)
        {   o << ' ' << h[c] << " |";
        }
    }
 
    void printRows(std::wostream& o)
    {   for (const auto& r : m)
        {   for (const auto& e : r)
            {   o << ' ' << e << " |";
            }   o << '\n';
        }
    }
};
 
// Основной класс таблицы
class Tab
{
private:
    MyVector<MyVector<MyString>> m;
    MyVector<MyString> h;
    size_t CMAX = 0;
 
public:
    Tab() = default;
 
    MyVector<MyString>& operator[](const size_t i)
    {   if (i >= m.size()) m.resize(i + 1);
        return *(m.begin() + i);
    }
 
    template<typename ... T>
    void head(T ... t)
    {   (h.push_back(StringConverter::toString(t)), ...);
    }
 
    void formater()
    {   TableFormatter formatter(CMAX, m, h);
        formatter.format();
    }
 
    friend std::wostream& operator<<(std::wostream&, Tab&);
};
 
std::wostream& operator<<(std::wostream& o, Tab& t)
{   t.formater();
 
    TablePrinter printer(t.CMAX, t.m, t.h);
    printer.print(o);
 
    return o;
}
 
///----------------------------------------------------------------------------|
/// Тест.
///----------------------------------------------------------------------------:
class TabTest
{
public:
    void run()
    {   ///-----------------------|
        /// Создаём табулятор.    |
        ///-----------------------:
        Tab tab;
 
        ///-----------------------|
        /// Заголовок.            |
        ///-----------------------:
        tab.head(L"NN", L"Первый", L"Второй", 3);
 
        ///-----------------------|
        /// Как угодно заполняем. |
        ///-----------------------:
        tab[1][1] = 2020;
        tab[2][2] = "qwerty";
        tab[4][3] = 3.14;
        tab[0][4] = L"Яша + Оля";
 
        ///-----------------------|
        /// Вывод на экран/файл.  |
        ///-----------------------:
        std::wcout << tab;
 
        tab[2][4] = 2025;
        tab[3][5] = 'A';
 
        std::wcout << tab;
    }
};
 
///----------------------------------------------------------------------------|
/// Старт.
///----------------------------------------------------------------------------:
int main()
{   setlocale(0, "");
 
    TabTest test;
            test.run();
 
    return 0;
}