LoginSignup
55
49

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

@javacommons

マルチバイト文字列(std::string)とワイド文字列(std::wstring)の間の変換を行うライブラリを作りました(SJIS, UTF-8, UTF-16に対応。SJIS⇔UTF-8の変換も可能)

Last updated at Posted at 2017-05-22

C++でWindowsアプリを作る場合に、マルチバイト文字列(std::string)とワイド文字列(std::wstring)の間で変換しなければならないことがあります。今回は、Windows API の MultiByteToWideChar() と WideCharToMultiByte() を使って変換を行うライブラリ(ヘッダーオンリー)を作ってみました(文末の strconv2.h を保存してお使いください。C++専用です。Cでは使えません)。また、内部的にワイド文字列を経由することで シフトJIS⇔UTF-8 の変換(マルチバイト文字列同士の変換)を行う関数も用意しています。

  • UTF-16/UTF-32対応をいれたので、C++98で使えなくなりました。C++98のコンパイラで使いたい場合は strconv.h をお使いください。strconv.h の方も引き続きサポートします。
  • このライブラリは多くの企業／デベロッパーで利用されています。
  • Visual C++, MinGW の 32bit/64bit 版でコンパイル・動作を確認しています。
  • 添付の strconv2.h のライセンスを MIT License or Public Domain (Unlicense) のデュアルライセンスにしました。詳しくはこちらをご覧ください。
    Public Domain (Unlicense) に関しては https://ja.wikipedia.org/wiki/Unlicense もご覧ください。

使用例1(ライブラリをそのまま使用)

main1.cpp
#include <windows.h>
#include "strconv2.h"

int main(int argc, char **argv)
{
  std::string utf8_str = u8"あいう";
  printf("utf8_str.length()=%u\n", utf8_str.length());
  std::wstring wide_str = utf8_to_wide(utf8_str);
  printf("wide_str.length()=%u\n", wide_str.length());
  std::string sjis_str = wide_to_sjis(wide_str);
  printf("sjis_str.length()=%u\n", sjis_str.length());
  printf("sjis_str.c_str()=%s\n", sjis_str.c_str());
  return 0;
}
実行結果
>main1.exe
utf8_str.length()=9
wide_str.length()=3
sjis_str.length()=6
sjis_str.c_str()=あいう

使用例2(メッセージをコード変換して出力)

使用例3とちがって、formatA の出力は、(日本語Windowsでは)シフトJISにしか対応していません。(chcp 65001 を実行すると文字化けします)
※ formatを使って韓国語などを表示したい(chcp 65001 に対応したい)場合は、
unicode_ostream aout(std::cout, GetConsoleOutputCP()); aout << format(u8"漢字=%s", u8"한자") << std::endl;
のようにしてください。unicode_ostream と一緒に用いる場合は formatA() ではなくて format() を用いてください。

main2.cpp
#include "strconv2.h"
#include <iostream>
#include <string>

int main(void)
{
    std::string nameUtf8 = u8"太郎";
    int age = 15;
    // 以下の3行は同じ意味です。
    std::cout << utf8_to_ansi(format(u8"ハロー、私の名前は %s。 年は %d だ!", nameUtf8.c_str(), age)) << std::endl;
    std::cout << formatA(u8"ハロー、私の名前は %s。 年は %d だ!", nameUtf8.c_str(), age) << std::endl;
    formatA(std::cout, u8"ハロー、私の名前は %s。 年は %d だ!\n", nameUtf8.c_str(), age);
    std::wstring nameWide = L"花子";
    age = 23;
    // 以下の3行は同じ意味です。
    std::cout << wide_to_ansi(format(L"ハロー、私の名前は %s。 年は %d だ!", nameWide.c_str(), age)) << std::endl;
    std::cout << formatA(L"ハロー、私の名前は %s。 年は %d だ!", nameWide.c_str(), age) << std::endl;
    formatA(std::cout, L"ハロー、私の名前は %s。 年は %d だ!\n", nameWide.c_str(), age);
    return 0;
}
実行結果(日本語版WindowsではシフトJISで出力されます)
>main2.exe
ハロー、私の名前は 太郎。 年は 15 だ!
ハロー、私の名前は 太郎。 年は 15 だ!
ハロー、私の名前は 太郎。 年は 15 だ!
ハロー、私の名前は 花子。 年は 23 だ!
ハロー、私の名前は 花子。 年は 23 だ!
ハロー、私の名前は 花子。 年は 23 だ!

使用例3(メッセージをコード変換して出力(std::cout互換＝型安全な方法))

main3.cpp
#include "strconv2.h"
#include <iostream>
#include <iomanip>
#include <cmath>

using namespace std;

class CMyClass
{
    time_t t;
    int count;

public:
    CMyClass()
    {
        this->t = std::time(nullptr);
        this->count = 0;
    }
    int CountUp()
    {
        return ++this->count;
    }
    friend unicode_ostream &operator<<(unicode_ostream &stream, const CMyClass &value);
};

unicode_ostream &operator<<(unicode_ostream &stream, const CMyClass &value)
{
    struct tm *ptm = std::localtime(&value.t);
    stream << u8"[作成日時=" << std::put_time(ptm, "%Y-%m-%d %H:%M:%S");
    stream << u8"、カウント=" << value.count << "]";
    return stream;
};

int main()
{
#ifdef ANSI_ONLY
    unicode_ostream aout(cout);
#else
    unicode_ostream aout(cout, GetConsoleOutputCP()); // chcp 65001 とすると「한자」が「??」に化けずに表示される
#endif
    CMyClass mc;
    mc.CountUp();
    mc.CountUp();
    aout << mc << endl;
    double pi = 4 * atan(1.0);
    aout << u8"π(1)=" << pi << endl;
    aout << u8"π(2)=" << format("%.2f", pi) << endl;

    aout << 1 << u8" char*漢字=한자 " << std::string(u8" string漢字=한자 ") << 1.2345 << endl;
    aout << 2 << L" wchar_t*漢字=한자 " << std::wstring(L" wstring漢字=한자 ") << 1.2345 << endl;

    double A = 100;
    double B = 2001.5251;

    // 書式指定(A) hex の代わりに setbase(16) を使うこともできます
    aout << hex << left << showbase << nouppercase;
    // 実際の印字処理(A)
    aout << (long long)A << endl;

    // 書式指定(B) setbase(10) の代わりに dec を使うこともできます
    aout << setbase(10) << right << setw(15)
         << setfill('_') << showpos
         << fixed << setprecision(2);
    // 実際の印字処理(B)
    aout << B << endl;

    return 0;
}

chcp 65001 を試すときは、生の PowerShell では漢字や韓国語が表示されませんので、コマンドプロンプトか Windows Terminal をお使いください。Windows Terminal の PowerShell では chcp 65001 しても、漢字や韓国語が問題なく表示されます。

実行結果
>chcp 932
>main3.exe
[作成日時=2020-12-25 21:17:18、カウント=2]
π(1)=3.14159
π(2)=3.14
1 char*漢字=??  string漢字=?? 1.2345
2 wchar_t*漢字=??  wstring漢字=?? 1.2345
0x64
_______+2001.53

>chcp 65001
>main3.exe
[作成日時=2020-12-25 21:20:44、カウント=2]
π(1)=3.14159
π(2)=3.14
1 char*漢字=한자  string漢字=한자 1.2345
2 wchar_t*漢字=한자  wstring漢字=한자 1.2345
0x64
_______+2001.53

使用例4(UTF-16, UTF-32との変換)

main4.cpp
#include "strconv2.h"

int main(int argc, char *argv[])
{
    unicode_ostream uout(std::cout, GetConsoleOutputCP());

    std::string utf8 = U8("ユーティーエフ8");
    uout << utf8_to_char16(utf8) << std::endl;
    uout << utf8_to_char32(utf8) << std::endl;

    uout << u"ゆーてぃーえふ16" << std::endl;
    uout << U"ゆーてぃーえふ32" << std::endl;

    std::u16string u16s = U16("ゆー16");
    std::u32string u32s = U32("ゆー32");

    uout << char16_to_utf8(u16s) << std::endl;
    uout << char32_to_utf8(u32s) << std::endl;

    std::vector<unsigned int> v = {
        437,    // OEM 米国
        737,    // ギリシャ語
        775,    // バルト言語
        850,    // 西ヨーロッパ言語
        852,    // 中央ヨーロッパ言語
        855,    // OEM キリル
        857,    // トルコ語
        858,    // OEM マルチリンガル ラテン I
        860,    // ポルトガル語
        861,    // アイスランド語
        862,    // ヘブライ語
        863,    // フランス語 (カナダ)
        864,    // アラビア語
        865,    // 北欧
        866,    // キリル言語
        869,    // ギリシャ語, Modern
        874,    // タイ語
        932,    // 日本語 (シフト JIS)
        936,    // 簡体字中国語 (GB2312)
        949,    // 韓国語
        950,    // 繁体字中国語 (Big5)
        1250,   // 中央ヨーロッパ言語
        1251,   // キリル言語
        1252,   // 西ヨーロッパ言語
        1253,   // ギリシャ語
        1254,   // トルコ語
        1255,   // ヘブライ語
        1256,   // アラビア語
        1257,   // バルト言語
        1258,   // ベトナム語
        1361,   // 韓国語 (Johab)
        65001,  // Unicode (UTF-8)
    };
    std::string s = U8("abc");
    int error_count = 0;
    for (std::size_t i = 0; i < v.size(); i++)
    {
        std::string s2 = utf8_to_cp(s, v[i]);
        if (s2 == s) continue;
        uout << "ERROR: " << v[i] << ":" << utf8_to_cp(s, v[i]) << std::endl;
        error_count++;
    }
    uout << U8("変換エラー: ") << error_count << U8("個") << std::endl;

    return 0;
}
実行結果
ユーティーエフ8
ユーティーエフ8
ゆーてぃーえふ16
ゆーてぃーえふ32
ゆー16
ゆー32
変換エラー: 0個

C++20への対応

C++20(モード)でコンパイルすると、std::string s = u8"あいうえお"; の部分がエラーになります。
逆にこの部分だけ対処すればソースコードの互換性、および動作の互換性を保証することができます。
また、明示的に std::u8string を使う場合には、format(), formatA(), unicode_ostreamクラス等も std::u8string に対応しています。

C++20でエラーになるソースコード
#include "strconv2.h"
int main(int argc, char *argv[])
{
    std::string s = u8"あいうえお";
    formatA(std::cout, "%s\n", s.c_str());
    return 0;
}
対処方法1(確実な方法)
#include "strconv2.h"
int main(int argc, char *argv[])
{
    // std::string s = (const char *)u8"あいうえお"; に展開されるマクロ
    std::string s = U8("あいうえお");
    formatA(std::cout, "%s\n", s.c_str());
    return 0;
}
対処方法2(MinGWのgccなどで文字コードが元々utf-8な場合)
#include "strconv2.h"
int main(int argc, char *argv[])
{
    std::string s = "あいうえお"; // u8 を取り除く
    formatA(std::cout, "%s\n", s.c_str());
    return 0;
}
対処方法3(char8_t *, std::u8string に対応した関数を使う⇒ソース非互換になる)
#include "strconv2.h"
int main(int argc, char *argv[])
{
    std::u8string s = u8"あいうえお";
    formatA(std::cout, u8"%s\n", s.c_str());
    std::wstring ws = char8_to_wide(s);
    formatA(std::cout, L"%s\n", ws.c_str());
    return 0;
}

strconv2.h には以下の関数があり、char8_t *, std::u8string と std::string/std::wstring の間の変換ができるようになっています。

  • static inline std::u8string utf8_to_char8(const std::string &s)
  • static inline std::string char8_to_utf8(const std::u8string &s)
  • static inline std::wstring char8_to_wide(const std::u8string &s)
  • static inline std::u8string wide_to_char8(const std::wstring &s)
  • static inline std::u8string ansi_to_char8(const std::string &s)
  • static inline std::string char8_to_ansi(const std::u8string &s)
  • static inline std::u8string sjis_to_char8(const std::string &s)
  • static inline std::string char8_to_sjis(const std::u8string &s)

関数一覧

std::wstring ansi_to_wide(const std::string &s)

システムロケールにおける既定のコードページの文字コードからワイド文字列への変換を行います。システムロケールが「日本/日本語」の場合は sjis_to_wide() と同じ結果となります。

std::string wide_to_ansi(const std::wstring &s)

ワイド文字列からシステムロケールにおける既定のコードページの文字コードへの変換を行います。システムロケールが「日本/日本語」の場合は wide_to_sjis() と同じ結果となります。

std::wstring sjis_to_wide(const std::string &s)

シフトJIS(コードページ932)からワイド文字列への変換を行います。

std::string wide_to_sjis(const std::wstring &s)

ワイド文字列からシフトJIS(コードページ932)への変換を行います。

std::wstring utf8_to_wide(const std::string &s)

UTF-8からワイド文字列への変換を行います。

std::string wide_to_utf8(const std::wstring &s)

ワイド文字列からUTF-8への変換を行います。

std::string ansi_to_utf8(const std::string &s)

システムロケールにおける既定のコードページの文字コードからUTF-8への変換を行います。システムロケールが「日本/日本語」の場合は sjis_to_utf8() と同じ結果となります。

std::string utf8_to_ansi(const std::string &s)

UTF-8からシステムロケールにおける既定のコードページの文字コードへの変換を行います。システムロケールが「日本/日本語」の場合は utf8_to_sjis() と同じ結果となります。

std::string sjis_to_utf8(const std::string &s)

シフトJIS(コードページ932)からUTF-8への変換を行います。

std::string utf8_to_sjis(const std::string &s)

UTF-8からシフトJIS(コードページ932)への変換を行います。

std::string format(const char *format, ...)

printf()の書式指定に従って std::string を出力します。sprintf()のようなものです。(主に UTF-8 の入力を想定していますが、シフトJISで使っていただいても構いません)

std::wstring format(const wchar_t *format, ...)

wprintf()の書式指定に従って std::wstring を出力します。wide版sprintf()のようなものです。(こちらはワイド文字列用です)

std::string formatA(const char *format, ...)

上記format()関数の出力をANSI(日本語WindowsではシフトJIS)に変換して返します。そのまま std::cout への出力に使えます。(但し、入力はUTF-8を想定しています←utf8_to_ansi()を適用しているため)

    // 以下の3行は同じ意味です。
    std::cout << utf8_to_ansi(format(u8"ハロー、私の名前は %s。 年は %d だ!", nameUtf8.c_str(), age)) << std::endl;
    std::cout << formatA(u8"ハロー、私の名前は %s。 年は %d だ!", nameUtf8.c_str(), age) << std::endl;
    formatA(std::cout, u8"ハロー、私の名前は %s。 年は %d だ!\n", nameUtf8.c_str(), age);

std::string formatA(const wchar_t *format, ...)

上記format()関数の出力をANSI(日本語WindowsではシフトJIS)に変換して返します。そのまま std::cout への出力に使えます。(ワイド文字列を入力とする関数です)

    // 以下の3行は同じ意味です。
    std::cout << wide_to_ansi(format(L"ハロー、私の名前は %s。 年は %d だ!", nameWide.c_str(), age)) << std::endl;
    std::cout << formatA(L"ハロー、私の名前は %s。 年は %d だ!", nameWide.c_str(), age) << std::endl;
    formatA(std::cout, L"ハロー、私の名前は %s。 年は %d だ!\n", nameWide.c_str(), age);

char8_t *, std::u8string と std::string/std::wstring の間の変換用

static inline std::u8string utf8_to_char8(const std::string &s)
static inline std::string char8_to_utf8(const std::u8string &s)
static inline std::wstring char8_to_wide(const std::u8string &s)
static inline std::u8string wide_to_char8(const std::wstring &s)
static inline std::u8string ansi_to_char8(const std::string &s)
static inline std::string char8_to_ansi(const std::u8string &s)
static inline std::u8string sjis_to_char8(const std::string &s)
static inline std::string char8_to_sjis(const std::u8string &s)

UTF-16, UTF-32対応関数

  • static inline std::string char16_to_utf8(const std::u16string &s)
  • static inline std::u16string utf8_to_char16(const std::string &s)
  • static inline std::string char32_to_utf8(const std::u32string &s)
  • static inline std::u32string utf8_to_char32(const std::string &s)
    // 以下C++20用
  • static inline std::u8string char16_to_char8(const std::u16string &s)
  • static inline std::u16string char8_to_char16(const std::u8string &s)
  • static inline std::u8string char32_to_char8(const std::u32string &s)
  • static inline std::u32string char8_to_char32(const std::u8string &s)

添付ファイル(strconv2.h)

strconv2.h
/* strconv2.h v1.0.0               */
/* Last Modified: 2023/04/09 16:37 */
#ifndef STRCONV2_H
#define STRCONV2_H

#include <stdarg.h>
#include <windows.h>

#include <codecvt>
#include <iostream>
#include <locale>
#include <sstream>
#include <string>
#include <vector>

static inline std::wstring cp_to_wide(const std::string &s, UINT codepage)
{
    int in_length = (int)s.length();
    int out_length =
        MultiByteToWideChar(codepage, 0, s.c_str(), in_length, 0, 0);
    std::wstring result(out_length, L'\0');
    if (out_length)
        MultiByteToWideChar(codepage, 0, s.c_str(), in_length, &result[0],
                            out_length);
    return result;
}
static inline std::string wide_to_cp(const std::wstring &s, UINT codepage)
{
    int in_length = (int)s.length();
    int out_length =
        WideCharToMultiByte(codepage, 0, s.c_str(), in_length, 0, 0, 0, 0);
    std::string result(out_length, '\0');
    if (out_length)
        WideCharToMultiByte(codepage, 0, s.c_str(), in_length, &result[0],
                            out_length, 0, 0);
    return result;
}

static inline std::string cp_to_utf8(const std::string &s, UINT codepage)
{
    if (codepage == CP_UTF8) return s;
    std::wstring wide = cp_to_wide(s, codepage);
    return wide_to_cp(wide, CP_UTF8);
}
static inline std::string utf8_to_cp(const std::string &s, UINT codepage)
{
    if (codepage == CP_UTF8) return s;
    std::wstring wide = cp_to_wide(s, CP_UTF8);
    return wide_to_cp(wide, codepage);
}

static inline std::wstring ansi_to_wide(const std::string &s)
{
    return cp_to_wide(s, CP_ACP);
}
static inline std::string wide_to_ansi(const std::wstring &s)
{
    return wide_to_cp(s, CP_ACP);
}

static inline std::wstring sjis_to_wide(const std::string &s)
{
    return cp_to_wide(s, 932);
}
static inline std::string wide_to_sjis(const std::wstring &s)
{
    return wide_to_cp(s, 932);
}

static inline std::wstring utf8_to_wide(const std::string &s)
{
    return cp_to_wide(s, CP_UTF8);
}
static inline std::string wide_to_utf8(const std::wstring &s)
{
    return wide_to_cp(s, CP_UTF8);
}

static inline std::string ansi_to_utf8(const std::string &s)
{
    return cp_to_utf8(s, CP_ACP);
}
static inline std::string utf8_to_ansi(const std::string &s)
{
    return utf8_to_cp(s, CP_ACP);
}

static inline std::string sjis_to_utf8(const std::string &s)
{
    return cp_to_utf8(s, 932);
}
static inline std::string utf8_to_sjis(const std::string &s)
{
    return utf8_to_cp(s, 932);
}

#ifdef __cpp_char8_t
static inline std::u8string utf8_to_char8(const std::string &s)
{
    return std::u8string(s.begin(), s.end());
}
static inline std::string char8_to_utf8(const std::u8string &s)
{
    return std::string(s.begin(), s.end());
}

static inline std::wstring char8_to_wide(const std::u8string &s)
{
    return cp_to_wide(char8_to_utf8(s), CP_UTF8);
}
static inline std::u8string wide_to_char8(const std::wstring &s)
{
    return utf8_to_char8(wide_to_cp(s, CP_UTF8));
}

static inline std::u8string cp_to_char8(const std::string &s, UINT codepage)
{
    return utf8_to_char8(cp_to_utf8(s, codepage));
}
static inline std::string char8_to_cp(const std::u8string &s, UINT codepage)
{
    return utf8_to_cp(char8_to_utf8(s), codepage);
}

static inline std::u8string ansi_to_char8(const std::string &s)
{
    return cp_to_char8(s, CP_ACP);
}
static inline std::string char8_to_ansi(const std::u8string &s)
{
    return char8_to_cp(s, CP_ACP);
}

static inline std::u8string sjis_to_char8(const std::string &s)
{
    return cp_to_char8(s, 932);
}
static inline std::string char8_to_sjis(const std::u8string &s)
{
    return char8_to_cp(s, 932);
}
#endif

#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4996)
#endif

static inline std::string char16_to_utf8(const std::u16string &s)
{
    try
    {
        std::wstring_convert<std::codecvt_utf8<char16_t>, char16_t> convert;
        return convert.to_bytes(s);
    }
    catch (...)
    {
        return "";
    }
}

static inline std::u16string utf8_to_char16(const std::string &s)
{
    try
    {
        std::wstring_convert<std::codecvt_utf8<char16_t>, char16_t> convert;
        return convert.from_bytes(s);
    }
    catch (...)
    {
        return u"";
    }
}

static inline std::string char16_to_cp(const std::u16string &s,
                                       unsigned int codepage)
{
    return utf8_to_cp(char16_to_utf8(s), codepage);
}

static inline std::string char32_to_utf8(const std::u32string &s)
{
    try
    {
        std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> convert;
        return convert.to_bytes(s);
    }
    catch (...)
    {
        return "";
    }
}

static inline std::u32string utf8_to_char32(const std::string &s)
{
    try
    {
        std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> convert;
        return convert.from_bytes(s);
    }
    catch (...)
    {
        return U"";
    }
}

static inline std::string char32_to_cp(const std::u32string &s,
                                       unsigned int codepage)
{
    return utf8_to_cp(char32_to_utf8(s), codepage);
}

#ifdef __cpp_char8_t
static inline std::u8string char16_to_char8(const std::u16string &s)
{
    try
    {
        std::wstring_convert<std::codecvt_utf8<char16_t>, char16_t> convert;
        return utf8_to_char8(convert.to_bytes(s));
    }
    catch (...)
    {
        return u8"";
    }
}

static inline std::u16string char8_to_char16(const std::u8string &s)
{
    try
    {
        std::wstring_convert<std::codecvt_utf8<char16_t>, char16_t> convert;
        return convert.from_bytes(char8_to_utf8(s));
    }
    catch (...)
    {
        return u"";
    }
}

static inline std::u8string char32_to_char8(const std::u32string &s)
{
    try
    {
        std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> convert;
        return utf8_to_char8(convert.to_bytes(s));
    }
    catch (...)
    {
        return u8"";
    }
}

static inline std::u32string char8_to_char32(const std::u8string &s)
{
    try
    {
        std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> convert;
        return convert.from_bytes(char8_to_utf8(s));
    }
    catch (...)
    {
        return U"";
    }
}
#endif

static inline std::wstring vformat(const wchar_t *format, va_list args)
{
    int len = _vsnwprintf(0, 0, format, args);
    if (len < 0) return L"";
    std::vector<wchar_t> buffer(len + 1);
    len = _vsnwprintf(&buffer[0], len, format, args);
    if (len < 0) return L"";
    buffer[len] = L'\0';
    return &buffer[0];
}
static inline std::string vformat(const char *format, va_list args)
{
    int len = _vsnprintf(0, 0, format, args);
    if (len < 0) return "";
    std::vector<char> buffer(len + 1);
    len = _vsnprintf(&buffer[0], len, format, args);
    if (len < 0) return "";
    buffer[len] = '\0';
    return &buffer[0];
}
#ifdef __cpp_char8_t
static inline std::u8string vformat(const char8_t *format, va_list args)
{
    int len = _vsnprintf(0, 0, (const char *)format, args);
    if (len < 0) return u8"";
    std::vector<char> buffer(len + 1);
    len = _vsnprintf(&buffer[0], len, (const char *)format, args);
    if (len < 0) return u8"";
    buffer[len] = '\0';
    return (char8_t *)&buffer[0];
}
#endif

#if defined(_MSC_VER)
#pragma warning(pop)
#endif

static inline std::wstring format(const wchar_t *format, ...)
{
    va_list args;
    va_start(args, format);
    std::wstring s = vformat(format, args);
    va_end(args);
    return s;
}
static inline std::string format(const char *format, ...)
{
    va_list args;
    va_start(args, format);
    std::string s = vformat(format, args);
    va_end(args);
    return s;
}
#ifdef __cpp_char8_t
static inline std::u8string format(const char8_t *format, ...)
{
    va_list args;
    va_start(args, format);
    std::u8string s = vformat(format, args);
    va_end(args);
    return s;
}
#endif

static inline void format(std::ostream &ostrm, const wchar_t *format, ...)
{
    va_list args;
    va_start(args, format);
    std::wstring s = vformat(format, args);
    va_end(args);
    ostrm << wide_to_utf8(s) << std::flush;
}
static inline void format(std::ostream &ostrm, const char *format, ...)
{
    va_list args;
    va_start(args, format);
    std::string s = vformat(format, args);
    va_end(args);
    ostrm << s << std::flush;
}
#ifdef __cpp_char8_t
static inline void format(std::ostream &ostrm, const char8_t *format, ...)
{
    va_list args;
    va_start(args, format);
    std::u8string s = vformat(format, args);
    va_end(args);
    ostrm << char8_to_utf8(s) << std::flush;
}
#endif

static inline std::string formatA(const wchar_t *format, ...)
{
    va_list args;
    va_start(args, format);
    std::wstring s = vformat(format, args);
    va_end(args);
    return wide_to_ansi(s);
}
static inline std::string formatA(const char *format, ...)
{
    va_list args;
    va_start(args, format);
    std::string s = vformat(format, args);
    va_end(args);
    return utf8_to_ansi(s);
}
#ifdef __cpp_char8_t
static inline std::string formatA(const char8_t *format, ...)
{
    va_list args;
    va_start(args, format);
    std::u8string s = vformat(format, args);
    va_end(args);
    return char8_to_ansi(s);
}
#endif

static inline void formatA(std::ostream &ostrm, const wchar_t *format, ...)
{
    va_list args;
    va_start(args, format);
    std::wstring s = vformat(format, args);
    va_end(args);
    ostrm << wide_to_ansi(s) << std::flush;
}
static inline void formatA(std::ostream &ostrm, const char *format, ...)
{
    va_list args;
    va_start(args, format);
    std::string s = vformat(format, args);
    va_end(args);
    ostrm << utf8_to_ansi(s) << std::flush;
}
#ifdef __cpp_char8_t
static inline void formatA(std::ostream &ostrm, const char8_t *format, ...)
{
    va_list args;
    va_start(args, format);
    std::u8string s = vformat(format, args);
    va_end(args);
    ostrm << char8_to_ansi(s) << std::flush;
}
#endif

static inline void dbgmsg(const wchar_t *title, const wchar_t *format, ...)
{
    va_list args;
    va_start(args, format);
    std::wstring s = vformat(format, args);
    va_end(args);
    MessageBoxW(0, s.c_str(), title, MB_OK);
}
static inline void dbgmsg(const char *title, const char *format, ...)
{
    va_list args;
    va_start(args, format);
    std::string s = vformat(format, args);
    va_end(args);
    MessageBoxW(0, utf8_to_wide(s).c_str(), utf8_to_wide(title).c_str(), MB_OK);
}
#ifdef __cpp_char8_t
static inline void dbgmsg(const char8_t *title, const char8_t *format, ...)
{
    va_list args;
    va_start(args, format);
    std::u8string s = vformat(format, args);
    va_end(args);
    MessageBoxW(0, char8_to_wide(s).c_str(), char8_to_wide(title).c_str(),
                MB_OK);
}
#endif

static inline HANDLE handle_for_ostream(std::ostream &ostrm)
{
    if (&ostrm == &std::cout)
    {
        return GetStdHandle(STD_OUTPUT_HANDLE);
    }
    else if (&ostrm == &std::cerr)
    {
        return GetStdHandle(STD_ERROR_HANDLE);
    }
    return INVALID_HANDLE_VALUE;
}
static inline void dbgout(std::ostream &ostrm, const wchar_t *format, ...)
{
    va_list args;
    va_start(args, format);
    std::wstring ws = vformat(format, args);
    va_end(args);
    HANDLE h = handle_for_ostream(ostrm);
    if (h == INVALID_HANDLE_VALUE)
    {
        return;
    }
    DWORD dwNumberOfCharsWrite;
    if (GetFileType(h) != FILE_TYPE_CHAR)
    {
        std::string s = wide_to_cp(ws, GetConsoleOutputCP());
        WriteFile(h, s.c_str(), (DWORD)s.size(), &dwNumberOfCharsWrite, NULL);
    }
    else
    {
        WriteConsoleW(h, ws.c_str(), (DWORD)ws.size(), &dwNumberOfCharsWrite,
                      NULL);
    }
}
static inline void dbgout(std::ostream &ostrm, const char *format, ...)
{
    va_list args;
    va_start(args, format);
    std::string s = vformat(format, args);
    va_end(args);
    HANDLE h = handle_for_ostream(ostrm);
    if (h == INVALID_HANDLE_VALUE)
    {
        return;
    }
    DWORD dwNumberOfCharsWrite;
    if (GetFileType(h) != FILE_TYPE_CHAR)
    {
        s = utf8_to_cp(s, GetConsoleOutputCP());
        WriteFile(h, s.c_str(), (DWORD)s.size(), &dwNumberOfCharsWrite, NULL);
    }
    else
    {
        std::wstring ws = utf8_to_wide(s);
        WriteConsoleW(h, ws.c_str(), (DWORD)ws.size(), &dwNumberOfCharsWrite,
                      NULL);
    }
}
#ifdef __cpp_char8_t
static inline void dbgout(std::ostream &ostrm, const char8_t *format, ...)
{
    va_list args;
    va_start(args, format);
    std::u8string s = vformat(format, args);
    va_end(args);
    HANDLE h = handle_for_ostream(ostrm);
    if (h == INVALID_HANDLE_VALUE)
    {
        return;
    }
    DWORD dwNumberOfCharsWrite;
    if (GetFileType(h) != FILE_TYPE_CHAR)
    {
        std::string str = char8_to_cp(s, GetConsoleOutputCP());
        WriteFile(h, (const char *)str.c_str(), (DWORD)str.size(),
                  &dwNumberOfCharsWrite, NULL);
    }
    else
    {
        std::wstring ws = char8_to_wide(s);
        WriteConsoleW(h, ws.c_str(), (DWORD)ws.size(), &dwNumberOfCharsWrite,
                      NULL);
    }
}
#endif

class unicode_ostream
{
private:
    std::ostream *m_ostrm;
    UINT m_target_cp;
    bool is_ascii(const std::string &s)
    {
        for (std::size_t i = 0; i < s.size(); i++)
        {
            unsigned char c = (unsigned char)s[i];
            if (c > 0x7f) return false;
        }
        return true;
    }

public:
    unicode_ostream(std::ostream &ostrm, UINT target_cp = CP_ACP)
        : m_ostrm(&ostrm), m_target_cp(target_cp)
    {
    }
    std::ostream &stream() { return *m_ostrm; }
    void stream(std::ostream &ostrm) { m_ostrm = &ostrm; }
    UINT target_cp() { return m_target_cp; }
    void target_cp(UINT cp) { m_target_cp = cp; }
    template <typename T>
    unicode_ostream &operator<<(const T &x)
    {
        std::ostringstream oss;
        oss << x;
        std::string output = oss.str();
        if (is_ascii(output))
        {
            (*m_ostrm) << x;
        }
        else
        {
            (*m_ostrm) << utf8_to_cp(output, m_target_cp);
        }
        return *this;
    }
    unicode_ostream &operator<<(const std::wstring &x)
    {
        (*m_ostrm) << wide_to_cp(x, m_target_cp);
        return *this;
    }
    unicode_ostream &operator<<(const wchar_t *x)
    {
        (*m_ostrm) << wide_to_cp(x, m_target_cp);
        return *this;
    }
    unicode_ostream &operator<<(const std::string &x)
    {
        (*m_ostrm) << utf8_to_cp(x, m_target_cp);
        return *this;
    }
    unicode_ostream &operator<<(const char *x)
    {
        (*m_ostrm) << utf8_to_cp(x, m_target_cp);
        return *this;
    }
#ifdef __cpp_char8_t
    unicode_ostream &operator<<(const std::u8string &x)
    {
        (*m_ostrm) << char8_to_cp(x, m_target_cp);
        return *this;
    }
    unicode_ostream &operator<<(const char8_t *x)
    {
        (*m_ostrm) << char8_to_cp(x, m_target_cp);
        return *this;
    }
#endif
    unicode_ostream &operator<<(const std::u16string &x)
    {
        (*m_ostrm) << char16_to_cp(x, m_target_cp);
        return *this;
    }
    unicode_ostream &operator<<(const char16_t *x)
    {
        (*m_ostrm) << char16_to_cp(x, m_target_cp);
        return *this;
    }
    unicode_ostream &operator<<(const std::u32string &x)
    {
        (*m_ostrm) << char32_to_cp(x, m_target_cp);
        return *this;
    }
    unicode_ostream &operator<<(const char32_t *x)
    {
        (*m_ostrm) << char32_to_cp(x, m_target_cp);
        return *this;
    }
    unicode_ostream &operator<<(
        std::ostream &(*pf)(std::ostream &))  // For manipulators...
    {
        (*m_ostrm) << pf;
        return *this;
    }
    unicode_ostream &operator<<(std::basic_ios<char> &(*pf)(
        std::basic_ios<char> &))  // For manipulators...
    {
        (*m_ostrm) << pf;
        return *this;
    }
};

#define U8(X) ((const char *)u8##X)
#define U16(X) (u##X)
#define U32(X) (U##X)
#define WIDE(X) (L##X)

#endif /* STRCONV2_H */

関数一覧にないコードページへの対応方法

以下の関数の UINT codepage 引数に文末の表のコードページを渡すことで様々な文字コード(日本語EUC・JIS等も含む)に対応することができます。関数一覧に挙げた関数の実際の定義を参考にして、以下の関数をラップする関数を作るのが良いかもしれません。便利なら、strconv.h の末尾にそれらの関数を付け加えても構いません。UINT codepage に 932 を渡している、sjis_to_～() や ～_to_sjis() 関数が参考になるでしょう。932 は文末のコードページ一覧表に「日本語 (シフト JIS)」として載っています。

  • std::wstring cp_to_wide(const std::string &s, UINT codepage)
  • std::string wide_to_cp(const std::wstring &s, UINT codepage)
  • std::string cp_to_utf8(const std::string &s, UINT codepage)
  • std::string utf8_to_cp(const std::string &s, UINT codepage)
(コードページ一覧表。長いので折りたたみ中。展開してご覧ください)
コードページ 説明
37 IBM EBCDIC (米国 - カナダ)
437 OEM 米国
500 IBM EBCDIC (インターナショナル)
708 アラビア語 (ASMO 708)
720 アラビア語 (DOS)
737 ギリシャ語 (DOS)
775 バルト言語 (DOS)
850 西ヨーロッパ言語 (DOS)
852 中央ヨーロッパ言語 (DOS)
855 OEM キリル
857 トルコ語 (DOS)
858 OEM マルチリンガル ラテン I
860 ポルトガル語 (DOS)
861 アイスランド語 (DOS)
862 ヘブライ語 (DOS)
863 フランス語 (カナダ) (DOS)
864 アラビア語 (864)
865 北欧 (DOS)
866 キリル言語 (DOS)
869 ギリシャ語, Modern (DOS)
870 IBM EBCDIC (多国語ラテン 2)
874 タイ語 (Windows)
875 IBM EBCDIC (ギリシャ語 Modern)
932 日本語 (シフト JIS)
936 簡体字中国語 (GB2312)
949 韓国語
950 繁体字中国語 (Big5)
1026 IBM EBCDIC (トルコ語ラテン 5)
1047 IBM ラテン-1
1140 IBM EBCDIC (米国 - カナダ - ヨーロッパ)
1141 IBM EBCDIC (ドイツ - ヨーロッパ)
1142 IBM EBCDIC (デンマーク - ノルウェー - ヨーロッパ)
1143 IBM EBCDIC (フィンランド - スウェーデン - ヨーロッパ)
1144 IBM EBCDIC (イタリア - ヨーロッパ)
1145 IBM EBCDIC (スペイン - ヨーロッパ)
1146 IBM EBCDIC (英国 - ヨーロッパ)
1147 IBM EBCDIC (フランス - ヨーロッパ)
1148 IBM EBCDIC (インターナショナル - ヨーロッパ)
1149 IBM EBCDIC (アイスランド語 - ヨーロッパ)
1200 Unicode
1201 Unicode (ビッグ エンディアン)
1250 中央ヨーロッパ言語 (Windows)
1251 キリル言語 (Windows)
1252 西ヨーロッパ言語 (Windows)
1253 ギリシャ語 (Windows)
1254 トルコ語 (Windows)
1255 ヘブライ語 (Windows)
1256 アラビア語 (Windows)
1257 バルト言語 (Windows)
1258 ベトナム語 (Windows)
1361 韓国語 (Johab)
10000 西ヨーロッパ言語 (Mac)
10001 日本語 (Mac)
10002 繁体字中国語 (Mac)
10003 韓国語 (Mac)
10004 アラビア語 (Mac)
10005 ヘブライ語 (Mac)
10006 ギリシャ語 (Mac)
10007 キリル言語 (Mac)
10008 簡体字中国語 (Mac)
10010 ルーマニア語 (Mac)
10017 ウクライナ語 (Mac)
10021 タイ語 (Mac)
10029 中央ヨーロッパ言語 (Mac)
10079 アイスランド語 (Mac)
10081 トルコ語 (Mac)
10082 クロアチア語 (Mac)
20000 繁体字中国語 (CNS)
20001 TCA 台湾
20002 繁体字中国語 (Eten)
20003 IBM5550 台湾
20004 TeleText 台湾
20005 Wang 台湾
20105 西ヨーロッパ言語 (IA5)
20106 ドイツ語 (IA5)
20107 スウェーデン語 (IA5)
20108 ノルウェー語 (IA5)
20127 US-ASCII
20261 T.61
20269 ISO-6937
20273 IBM EBCDIC (ドイツ)
20277 IBM EBCDIC (デンマーク - ノルウェー)
20278 IBM EBCDIC (フィンランド - スウェーデン)
20280 IBM EBCDIC (イタリア)
20284 IBM EBCDIC (スペイン)
20285 IBM EBCDIC (英国)
20290 IBM EBCDIC (日本語カタカナ)
20297 IBM EBCDIC (フランス)
20420 IBM EBCDIC (アラビア語)
20423 IBM EBCDIC (ギリシャ語)
20424 IBM EBCDIC (ヘブライ語)
20833 IBM EBCDIC (韓国語拡張)
20838 IBM EBCDIC (タイ語)
20866 キリル言語 (KOI8-R)
20871 IBM EBCDIC (アイスランド語)
20880 IBM EBCDIC (キリル言語 - ロシア語)
20905 IBM EBCDIC (トルコ語)
20924 IBM ラテン-1
20932 日本語 (JIS 0208-1990 および 0212-1990)
20936 簡体字中国語 (GB2312-80)
20949 韓国語 Wansung
21025 IBM EBCDIC (キリル言語 セルビア - ブルガリア)
21027 拡張アルファベットの小文字
21866 キリル言語 (KOI8-U)
28591 西ヨーロッパ言語 (ISO)
28592 中央ヨーロッパ言語 (ISO)
28593 ラテン 3 (ISO)
28594 バルト言語 (ISO)
28595 キリル言語 (ISO)
28596 アラビア語 (ISO)
28597 ギリシャ語 (ISO)
28598 ヘブライ語 (ISO-Visual)
28599 トルコ語 (ISO)
28603 リトアニア語 (ISO)
28605 ラテン 9 (ISO)
29001 ヨーロッパ
38598 ヘブライ語 (ISO-Logical)
50000 ユーザー定義
50001 自動選択
50220 日本語 (JIS)
50221 日本語 (JIS 1 バイト カタカナ可)
50222 日本語 (JIS 1 バイト カタカナ可 - SO/SI)
50225 韓国語 (ISO)
50227 簡体字中国語 (ISO-2022)
50229 繁体字中国語 (ISO-2022)
50930 IBM EBCDIC (日本語および日本語カタカナ)
50931 IBM EBCDIC (日本語および米国 - カナダ)
50932 日本語 (自動選択)
50933 IBM EBCDIC (韓国語および韓国語拡張)
50935 IBM EBCDIC (簡体字中国語)
50936 簡体字中国語 (自動選択)
50937 IBM EBCDIC (繁体字中国語)
50939 IBM EBCDIC (日本語および日本語 - ラテン語)
50949 韓国語 (自動選択)
50950 繁体字中国語 (自動選択)
51251 キリル言語 (自動選択)
51253 ギリシャ語 (自動選択)
51256 アラビア語 (自動選択)
51932 日本語 (EUC)
51936 簡体字中国語 (EUC)
51949 韓国語 (EUC)
52936 簡体字中国語 (HZ)
54936 簡体字中国語 (GB18030)
57002 ISCII デバナガリ文字
57003 ISCII ベンガル語
57004 ISCII タミール語
57005 ISCII テルグ語
57006 ISCII アッサム語
57007 ISCII オリヤー語
57008 ISCII カンナダ語
57009 ISCII マラヤーラム語
57010 ISCII グジャラート語
57011 ISCII パンジャブ語
65000 Unicode (UTF-7)
65001 Unicode (UTF-8)

このソースコードのライセンス (MIT License or Public Domain)

Public Domain (Unlicense) に関しては https://ja.wikipedia.org/wiki/Unlicense もご覧ください。

Unlicenseは、パブリックドメインに非常に近いライセンスであり、著作権法への抵抗に重点を置いている。2010年1月1日（パブリックドメインの日）に初めて提唱された。Unlicenseはパブリックドメインとして権利を放棄する手段を提供しており、帰属の必要がない非常に緩いライセンスともいえる。2015年にGitHubは、github.com上のライセンスされた全プロジェクト500万弱のうち、2パーセントに当たる約10万のプロジェクトがUnlicenseを採用していると発表した。

------------------------------------------------------------------------------
This software is available under 2 licenses -- choose whichever you prefer.
------------------------------------------------------------------------------
ALTERNATIVE A - MIT License
Copyright (c) 2019-2021 JavaCommons
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
------------------------------------------------------------------------------
ALTERNATIVE B - Public Domain (www.unlicense.org)
This is free and unencumbered software released into the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
software, either in source code form or as a compiled binary, for any purpose,
commercial or non-commercial, and by any means.
In jurisdictions that recognize copyright laws, the author or authors of this
software dedicate any and all copyright interest in the software to the public
domain. We make this dedication for the benefit of the public at large and to
the detriment of our heirs and successors. We intend this dedication to be an
overt act of relinquishment in perpetuity of all present and future rights to
this software under copyright law.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-----------------------------------------------------------------------------
55
49
51

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
Sign upLogin
55
49

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?