Как работает string s()?

const wchar_t* LOGO = LR"(ver-0.3
///---------------------------------------------------------------------------|
/// Игра УГАДАЙ СЛОВО.
///
///     1.  Предлагается 5 раундов. Новое слово для каждого раунда.
///     2.  В каждом раунде предлагается N попытки на открытие буквы.
///     3.  Затем предлагается угадать слово целиком.
///     4.  Если слово не угадано, то игрок объявляется лузером.
///     5.  По итогам 5 рандов окончательно оперделятеся победитель.
///
///     *.  в случае вашего лузерства все претензии направляйте
///         к самому интеллекту проги,  но не к её разработчику.
///---------------------------------------------------------------------------:
)";
#include <algorithm>
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <string>
#include <limits>
 
#include <windows.h> // CharUpperW, MultiByteToWideChar
 
#define l(v) std::wcout << #v << " = " << v << "\n";
#define IGNORE_IN std::wcin.clear(); std::wcin.sync();
 
 
namespace myl
{
    bool Utf8ToUtf16(std::string const& src, std::wstring& dst)
    {
        if (src.empty()) { dst.clear(); return true; }
        if (src.size() >= static_cast<size_t>(INT_MAX)) { return false; }
 
        int srcLength = static_cast<int>(src.size());
        const int utf16Length = ::MultiByteToWideChar(
            CP_UTF8, MB_ERR_INVALID_CHARS,
            src.data(), srcLength,
            nullptr, 0
        );
 
        if (utf16Length == 0) { dst.clear(); return false; }
 
        dst.resize(utf16Length);
        const int result = ::MultiByteToWideChar(
            CP_UTF8, MB_ERR_INVALID_CHARS,
            src.data(), srcLength,
            dst.data(), utf16Length
        );
        if (result == 0) { dst.clear(); return false; }
 
        return true;
    }
 
    struct Rand
    {
        Rand(            ){ srand((unsigned)time(0)); }
        Rand(unsigned sid){ srand(sid); }
        int operator(    )(int range_min, int range_max)  const
        {   return rand() % (range_max - range_min) + range_min;
        }
    } rrand;
 
    void pause()
    {   std::wstring  w; std::getline(std::wcin, w); IGNORE_IN;
    }
}
 
 
///----------------------------------------------------------------------------|
/// Список 1000 часто встречаемых существительных.
/// https://www.cyberforum.ru/dump/thread3147830.html
///----------------------------------------------------------------------------:
struct  Words
{       Words() { load_from_file("words.txt"); }
 
    const std::wstring& get_random() { return w[myl::rrand(0, (int)w.size())]; }
 
private:
    std::vector<std::wstring> w;
 
    void load_from_file(std::string filename)
    {
        std::ifstream f(filename);
        if (f.is_open())
        {
            for (std::string s; f >> s;)
            {
                if (f >> s; !s.empty())
                {
                    if (std::wstring ss; myl::Utf8ToUtf16(s, ss))
                    {   w.push_back(ss);
                    }
                }
            }
 
            l(w.size())
          //l(w.front())
          //l(w.back ())
        }
        else
        {   std::wcout  << L"ERROR: Словарь "
                        << filename.c_str()
                        << L" отсутсвует!\n";
        }
    }
};
 
 
///----------------------------------------------------------------------------|
/// Табло со словом.
///----------------------------------------------------------------------------:
struct  Tablo
{       Tablo() : t(3) {}
 
    ///----------------------------|
    /// Выставляем слово на табло. |
    ///----------------------------:
    void init()
    {
        t[0] = words.get_random();
        t[2] = t[0];
        t[1] = std::wstring(t[0].size(), L'*');
 
        ::CharUpperW(t[0].data());
    }
 
    ///----------------------------|
    /// Есть ли такая буква?       |
    ///----------------------------:
    size_t find(wchar_t c)
    {
        size_t cnt = 0;
 
        for (size_t i = 0; i < t[0].size(); ++i)
        {
            if (t[0][i] == c)
            {   t[1][i] =  t[2][i]; cnt++;
            }
        }
        return cnt;
    }
 
    ///----------------------------|
    /// Угадал ли слово целиком?   |
    ///----------------------------:
    bool operator  ==(std::wstring w)
    {          t[1] = t[2];
        return w   == t[0];
    }
 
    ///----------------------------|
    /// Показываем скрытое слово.  |
    ///----------------------------:
    void show()
    {   std::wcout << "=" << t[1] << "=\n";
    }
 
    ///----------------------------|
    /// Сколько буков открыть?     |
    ///----------------------------:
    size_t what_letters()
    {   return t[0].size();
    }
 
    ///----------------------------|
    /// Отладочное...              |
    ///----------------------------:
    void debug()
    {
        l(t[0])
        l(t[1])
    }
 
private:
    std::vector<std::wstring> t;
    Words                 words;
};
 
 
///----------------------------------------------------------------------------|
/// Игрок.
///----------------------------------------------------------------------------:
struct  Player
{       Player(std::wstring nm) : name(nm) {}
 
    ///----------------|
    /// Говорит букву. |
    ///----------------:
    wchar_t get_letter()
    {
        ///--------------------------------|
        /// TODO: Защита от дурака?!       |
        ///--------------------------------|
        /// Будет принят только последний символ в строке:
        std::wstring  w; std::getline(std::wcin, w); IGNORE_IN;
      ::CharUpperW ( &w.back ());
        return        w.empty() ? L'?' : w.back();
    }
 
    ///----------------|
    /// Говорит слово. |
    ///----------------:
    std::wstring get_word()
    {
        std::wstring w; std::getline(std::wcin, w); IGNORE_IN;
      ::CharUpperW ( w.data());
        return       w;
    }
 
    ///----------------|
    /// Имя игрока.    |
    ///----------------:
    std::wstring name{ L"???" };
 
private:
};
 
 
///----------------------------------------------------------------------------|
/// Игра.
///----------------------------------------------------------------------------:
struct  Game
{       Game() : player(L"Вася")
        {
            run();
        }
 
private:
    void run()
    {
        std::wcout << L"\nНачать - НАЖМИТЕ ENTER ..." << std::endl;
        myl::pause();
 
        /// 1.
        ///-----------------------------------------------|
        /// Предлагается 5 раундов.                       |
        ///-----------------------------------------------:
        for (int  i = 0; i < 5; ++i)
        {
            round(i);
        }
 
        /// 5.
        ///-----------------------------------------------|
        /// По итогам 5 рандов оперделятеся победитель.   |
        ///-----------------------------------------------:
        std::wcout << L"ИТОГОВЫЙ СЧЁТ: " << win << L" - " << loss << L'\n';
 
        ///-----------------------------------------------|
        /// Для ODD кол-ва раундов НИЧЬИ быть не может.   |
        ///-----------------------------------------------:
        win > loss ?
            std::wcout << player.name << L" ВЫИГРАЛ!!!\n" :
            std::wcout << player.name << L" ЛУЗЕР...\n"   ;
 
        myl::pause();
    }
 
    void round(int ir)
    {
        std::system("cls");
 
        std::wcout << L"Внимание РАУНД №" << ++ir << "!\n\n";
 
      //tablo.init (L"ГОВНОкод");
        tablo.init();
      //tablo.debug();
        tablo.show();
 
        /// 2.
        ///-----------------------------------------------|
        /// Предлагается N попыток на открытие буквы.     |
        ///-----------------------------------------------:
        for (size_t i = 0, N = tablo.what_letters(); i < N; ++i)
        {
            std::wcout << L"  Назовите букву: ";
            wchar_t c = player.get_letter();
 
            auto
            n = tablo.find(c);
            n > 0 ?
            n > 1 ?
                std::wcout << L"  ЕСТЬ ТАКИЕ БУКВЫ!\n" :
                std::wcout << L"  ЕСТЬ ТАКАЯ БУКВА!\n" :
                std::wcout << L"  НЕТ  ТАКОЙ БУКВЫ...\n";
 
            tablo.show();
        }
 
        /// 3.
        ///-----------------------------------------------|
        /// Предлагается угадать слово целиком.           |
        ///-----------------------------------------------:
        std::wcout << L"  А СЕЙЧАС НАЗОВИТЕ СЛОВО ЦЕЛИКОМ: ";
        auto w = player.get_word();
 
        /// 4.
        ///-----------------------------------------------|
        /// Печатаем ИТОГИ.                               |
        ///-----------------------------------------------:
        bool
        b = tablo == w;
        b ?
            std::wcout << L"ВЕРНО!!!\n" :
            std::wcout << L"ВЫ, " << player.name << L", ЛУЗЕР...\n";
 
        tablo.show();
 
        b ? ++win : ++loss;
 
        ir < 5 ?
            std::wcout << L"\nК следующему раунду - НАЖМИТЕ ENTER ...\n" :
            std::wcout << L"\nПоказать итоги игры - НАЖМИТЕ ENTER ...\n";
 
        myl::pause();
    }
 
    Tablo  tablo;
    Player player;
 
    int win = 0;
    int loss = 0;
 
};
 
 
#include "fcntl.h"
#include "io.h"
 
///----------------------------------------------------------------------------|
/// Запуск...
///----------------------------------------------------------------------------:
int main()
{
    //setlocale(0, "");
    _setmode(_fileno(stdout), _O_U16TEXT);
    _setmode(_fileno(stdin ), _O_U16TEXT);
    _setmode(_fileno(stderr), _O_U16TEXT);
 
    //std::system("chcp 65001");
 
    std::system("mode 80,30");
 
    std::wcout << LOGO;
 
    std::wcout << L"ИГРА: УГАДАЙ СЛОВО.\n"
               << L"(проверьте русскую раскладку на клавиатуре!).\n\n";
 
    ///----------------|
    /// Запуск игры... |
    ///----------------:
    Game run;
 
    std::wcout << L"\nИГРА ЗАКОНЧЕНА" << std::endl;
    std::cin.get();
}