テンプレートが複雑すぎる?

質問

以下のような文字列比較関数を作ろうと思っています。
○配列変数であるときは配列版を、そうでないときはポインタ版を呼び出す
　配列のサイズがわかるときは、仮に\0で終端していなくてもそれ以上検索しない
○charかwchar_tかを意識せずに使える
○charとwchar_tという記述ではなく、templateでできるだけジェネリック?的に記述したい

//charを入れるとwchar_t、wchar_tを入れるとcharを返すメタ関数
template<typename T> struct invert{};
template<> struct invert<char>{ typedef wchar_t t; };
template<> struct invert<wchar_t>{ typedef char t; };

//同じ型同士の比較は省略

//A: 両方ポインタ
template<typename T>
bool compare(const T *const &v1, const typename invert<T>::t *const &v2);

//B1: 左がポインタ、右が配列
template<typename T, size_t L>
bool compare(const T *const &v1, const typename invert<T>::t (&v2)[L]);

//B2: Tとtypename invert<T>::tを逆に
template<typename T, size_t L>
bool compare(const typename invert<T>::t *const &v1, const T (&v2)[L]);

//C: 左が配列、右がポインタ
//省略

//D: 両方配列
template<typename T, size_t L1, size_t L2>
bool compare(const T (&v1)[L1], const typename invert<T>::t (&v2)[L2]);

char aa[] = "abc";
char *pa = aa;
wchar_t aw[] = L"abc";
wchar_t *pw = aw;

bool c1 = compare(pa, pw); //A
bool c2 = compare(pa, aw); //B1はC2784, B2なら可
bool c3 = compare(aa, pw); //C
bool c4 = compare(aa, aw); //DはC2784

invert<T>::t (&v2)[L]という記述が複雑?なのかB1は呼べず、B2と記述すると通りました。
しかしDはどちらも配列であるため、B2のように回避できません。
オーバーロードを全て記述せずに、できるだけ簡単にすます方法はありませんか?

環境はVC++2010です。

回答No.1

machongola · ベストアンサー

こんにちは。

　_T()マクロやwin32apiも使用していますが、肝心なところは、compareの部分です。
　(1)のcompareを呼び出す為に、compare<T, U>と書いてある部分が幾つかありますが、書かないと、(1)のcompareがコンパイルされなかったからです。

　重箱の隅を突っつけば、色々と問題が出てきそうなのですが、当方はこれで精いっぱいです。取りあえずは、以下参考程度に。

#include"stdafx.h"
#include<windows.h>
#include<tchar.h>
#include<cstring>
#include<string>
#include<algorithm>

//----------------------------------------
//文字列のカウント(配列の場合は使用しない)
//----------------------------------------
template<typename S>
struct counter;

//wchar_tの時
template<>
struct counter<wchar_t>
{
static size_t size(const wchar_t* const& s)
{
return ::wcslen(s);
}
};

//charの時
template<>
struct counter<char>
{
static size_t size(const char* const& s)
{
return ::strlen(s);
}
};

//----------------------------------------
//UNICODEへ変換(パラメータsに\0文字は含まれていない)
//----------------------------------------
template<class T>
struct convert;

//wchar_tの時
template<>
struct convert<wchar_t>
{
//変換の必要がないのでそのまま通す
static const std::wstring get(const wchar_t* const &s, size_t sz)
{
return std::wstring(s, s + sz);
}
};

//charの時
template<>
struct convert<char>
{
//変換する
static const std::wstring get(const char* const &s, size_t sz)
{
const std::string mbcs(s, s + sz);
const int len = ::MultiByteToWideChar(CP_ACP, 0, mbcs.c_str(), -1, NULL, 0);
LPWSTR p = (LPWSTR)::malloc(len * 2);
::MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, mbcs.c_str(), -1, p, len);
const std::wstring w(p);
::free(p);
return w;
}
};

//(1): 比較
template<typename T, typename U>
int compare(const T* const &v1, size_t len1, const U* const &v2, size_t len2)
{
//UNICODEへ強制変換
const std::wstring lhs = convert<T>::get(v1, len1);
const std::wstring rhs = convert<U>::get(v2, len2);

//ここに、望む比較の仕方を実装する
//例えばlstrcmpを使用する
return ::lstrcmp(lhs.c_str(), rhs.c_str());
}

//A: 両方ポインタ
template<typename T, typename U>
int compare(const T* const &v1, const U* const &v2)
{
return compare(v1, counter<T>::size(v1), v2, counter<U>::size(v2));
}

//B1: 左がポインタ、右が配列
template<typename T, typename U, size_t L>
int compare(const T* const &v1, const U(&v2)[L])
{
return compare<T, U>(v1, counter<T>::size(v1), v2, L);
}

//C: 左が配列、右がポインタ
template<typename T, typename U, size_t L>
int compare(const T(&v1)[L], const U* const &v2)
{
return compare<T, U>(v1, L, v2, counter<U>::size(v2));
}

//D: 両方配列
template<typename T, size_t L1, typename U, size_t L2>
int compare(const T(&v1)[L1], const U(&v2)[L2])
{
return compare<T, U>(v1, L1, v2, L2);
}

int main()
{
char aa[] = {'a', 'b', 'c'};
char *pa = "abc";
wchar_t aw[] = {_T('a'), _T('b'), _T('c')};
wchar_t *pw = _T("abc");

int result = 0;

result = compare(pa, pw);
result = compare(aa, pw);
result = compare(pa, aw);
result = compare(aa, aw);

result = compare("aab", _T("b"));
result = compare(_T("bcd"), _T("bc"));

result = compare(aa, "c");
result = compare(aa, _T("ab"));

result = compare(aw, "a");
result = compare(aw, _T("ab"));

char* pka = "あいうえお";
wchar_t akw[] = {_T('あ'), _T('い'), _T('う'), _T('え'), _T('お')};

result = compare(pka, akw);
result = compare(akw, pka);

return 0;
}

補足

回答がありがとうございます。

なるほど、左の型から右の型を求めるのではなく、右の型もテンプレート引数にしてしまえば、マッチさせることができました。
無効な型を入れた場合は、comvertにcharとwchar_tしか用意されていないため、コンパイルエラーとなるわけですね。
無理に入り口で型の制限をしないで、この方法をとってみようと思います。

比較の部分も、最終的には1つの関数にまとめられていて、簡潔でわかりやすいので、このまま利用させていただきます。

ありがとうございました。