c++ - 不明确的模板参数

Question

我创建了一个定义为的模板函数

template < typename _Iter8, typename _Iter32 >
int Utf8toUtf32 ( const _Iter8 & _from, const _Iter8 & _from_end, _Iter32 & _dest, const _Iter32 & _dest_end );

已编辑:第一个参数为 const 类型。

第一个和第三个参数发生变化以反射(reflect)它们的新位置。第二个和第四个参数标记迭代的上边界。

我希望实现“一机多能”的逻辑。唯一的规定是这两个 _Iter 类型是同一类型并且是可解引用的。我还希望模板参数是可推导的。

我遇到的第一个问题是

char utf8String [] "...some utf8 string ...";
wchar_t wideString [ 100 ];
char * pIter = utfString;
Utf8toUtf16( pIter, pIter + n, wideString, wideString + 100 );

_Iter16 不明确。我猜是因为编译器将第三个参数视为 wchar_t[100] 类型，将第四个参数视为 wchar_t* 类型。如我错了请纠正我。将代码更改为:

Utf8toUtf16( pIter, pIter + n, (wchar_t*)wideString, wideString + 100 );

解决了这个问题。丑陋但有效。

然后我遇到了另一个问题:

unsigned long nCodepoint;
Utf8toUtf32( pIter, pIter + n, &nCodepoint, &nCodepoint + 1 ));

显然，如果我将 nCodepoint 更改为数组类型并应用与第一个相同的转换，它会编译。

我不确定我是否定义了错误的模板参数。我的问题是如何根据上述限制正确地对此进行编码，有没有一种方法可以在不求助于强制转换的情况下做到这一点？

编辑:正如 Jogojapan 和 DyP 在下面指出的那样，上面的转换不应该编译。相反，我应该创建一个指向数组前端的新指针并将其传入。至于 nCodepoint，我可能必须将其创建为长度为 1 的数组。

Answer 1

作为jogojapan实际上给出了答案，我将把它做成一个社区 wiki。

IMO，这是一个合适的解决方案:

template < typename Iter8, typename Iter32 >
Iter32 Utf8toUtf32(Iter8 _from, Iter8 _from_end, Iter32 _dest, Iter32 _dest_end);

这旨在返回您希望 _dest 更改为的内容。

如果你真的还需要返回一个int，你可以返回一对。

为了反射(reflect)要读取哪些迭代器，要写入哪些迭代器，您可以为模板参数使用命名方案，例如InputIterator8 和 OutputIterator32。

---

用标准库的一个函数来打个比方:

std::vector<int> v = {1,2,3,4};
for(auto i = v.begin(); i != v.end();)
{
    if(*i == 2)
    {
        i = v.erase(i);  // iterator invalidated and new "next" iterator returned
    }
}

如果您希望您的函数 a) 接受数组并且 b) 类似于标准库函数，除了返回“已更改”的迭代器之外，我看不到任何其他方法。我所知道的唯一一个实际改变传递的迭代器的库函数是 std::advance。

例子:

template < typename Iter8, typename Iter32 >
std::tuple<int, Iter8, Iter32> Utf8toUtf32(Iter8 _from, Iter8 _from_end,
                                           Iter32 _dest, Iter32 _dest_end);

char utf8String [] = "...some utf8 string ...";
wchar_t wideString [ 100 ];
char* pUtf8Res = nullptr;
wchar_t* pUtf16Res = nullptr;
int res = 0;
std::tie(res, pUtf8Res, pUtf16Res) = Utf8toUtf16( begin(pIter), end(pIter),
                                         begin(wideString), end(wideString) );

---

(jogojapan 编辑)

如果因为要更新迭代器指向的文本位置而必须继续将迭代器作为引用传递，则无法直接解决问题中描述的两个问题。

问题 1:将本地数组 wideString 传递给函数将意味着其类型衰减为 wchar_t* 右值，并且不能绑定(bind)到wchar_t *& 非常量引用。换句话说，您不能让函数修改本地数组的地址。将其转换为指针并不会改变这一事实，并且编译器在接受该解决方案时是错误的。

问题 2:类似地，通过引用传递 nCodepoint 的地址是不可能的，因为该地址无法更改。唯一的解决方案是先将地址存储在一个单独的指针中，然后再传递:

unsigned long *pCodepoint = &nCodepoint;
Utf8toUtf32(pIter,PIter+5,pCodepoint,pCodepoint+1);

---

(jogojapan 的另一个编辑)

如果你想通过引用传递，但你想让函数足够灵活以接受非引用参数，你实际上可以提供模板的重载定义:

/* Using C++11 code for convenience. Rewriting in C++03 is easy. */
#include <type_traits>

template <typename T>
using noref = typename std::remove_reference<T>::type;

template <typename Iter8, typename Iter32>
int Utf8toUtf32 (Iter8 &from, const Iter8 from_end, Iter32 &dest, const Iter32 dest_end)
{
  return 0;
}

template <typename Iter8, typename Iter32>
int Utf8toUtf32 (Iter8 &from, const Iter8 from_end, noref<Iter32> dest, const Iter32 dest_end)
{
  noref<Iter32> p_dest = dest;
  return Utf8toUtf32(from,from_end,p_dest,dest_end);
}

template <typename Iter8, typename Iter32>
int Utf8toUtf32 (noref<Iter8> from, const Iter8 from_end, Iter32 &dest, const Iter32 dest_end)
{
  noref<Iter8> p_from = from;
  return Utf8toUtf32(p_from,from_end,dest,dest_end);
}

template <typename Iter8, typename Iter32>
int Utf8toUtf32 (noref<Iter8> from, const Iter8 from_end, noref<Iter32> dest, const Iter32 dest_end)
{
  noref<Iter8>  p_from = from;
  noref<Iter32> p_dest = dest;
  return Utf8toUtf32(p_from,from_end,p_dest,dest_end);
}

然后您可以使用左值和右值的各种组合来调用它:

int main()
{
  char input[]        = "hello";
  const char *p_input = input;
  unsigned long dest;
  unsigned long *p_dest = &dest;
  std::string input_str("hello");

  Utf8toUtf32(input,input+5,&dest,&dest+1);
  Utf8toUtf32(p_input,p_input+5,&dest,&dest+1);

  Utf8toUtf32(input,input+5,p_dest,p_dest+1);
  Utf8toUtf32(p_input,p_input+5,p_dest,p_dest+1);

  Utf8toUtf32(begin(input_str),end(input_str),p_dest,p_dest+1);
  Utf8toUtf32(begin(input_str),end(input_str),&dest,&dest+1);

  return 0;
}

但要注意:当传递一个右值(例如数组或像 &local_var 的表达式)时，调用将起作用并且不会有未定义的行为，但当然是本地的地址变量或数组当然仍然不会改变。因此，在这种情况下，调用者无法找出该函数能够处理多少个字符。