如何可移植地调用一个 C++ 函数，该函数在某些平台上采用 char**，在其他平台上采用 const char**

Question

在我的Linux(和OS X(机器上，iconv()函数有这个原型：

size_t iconv (iconv_t, char **inbuf...

而在 FreeBSD 上，它看起来像这样：

size_t iconv (iconv_t, const char **inbuf...

我希望我的C++代码在两个平台上构建。对于 C 编译器，传递const char**参数的char**(反之亦然(通常仅发出警告;然而，在C++，这是一个致命的错误。因此，如果我通过一个char**，它不会在BSD上编译，如果我通过一个const char**它不会在Linux/OS X上编译。如何编写在两者上编译的代码，而无需尝试检测平台？

我的一个(失败的(想法是提供一个本地原型，覆盖标头提供的任何原型：

void myfunc(void) {
    size_t iconv (iconv_t, char **inbuf);
    iconv(foo, ptr);
}

这失败了iconv因为需要 C 链接，并且您不能将extern "C"放在函数中(为什么不呢？

我想出的最好的工作想法是强制转换函数指针本身：

typedef void (*func_t)(iconv_t, const char **);
((func_t)(iconv))(foo, ptr);

但这有可能掩盖其他更严重的错误。

Answer 1

如果你想要的只是对一些 const 问题视而不见，那么你可以使用模糊区别的转换，即使 char** 和 const char** 可互操作：

template<class T>
class sloppy {}; 
// convert between T** and const T** 
template<class T>
class sloppy<T**>
{
    T** t;
    public: 
    sloppy(T** mt) : t(mt) {}
    sloppy(const T** mt) : t(const_cast<T**>(mt)) {}
    operator T** () const { return t; }
    operator const T** () const { return const_cast<const T**>(t); }
};

然后在程序的后面：

iconv(c, sloppy<char**>(&in) ,&inlen, &out,&outlen);

sloppy(( 取一个char**或一个const char*并将其转换为char**或const char*，无论 iconv 的第二个参数要求什么。

更新：更改为使用const_cast并称草率而不是 as 演员表。

Answer 2

可以通过检查声明函数的签名来消除两个声明之间的歧义。 下面是检查参数类型所需的模板的基本示例。 这很容易概括(或者您可以使用 Boost 的函数特征(，但这足以证明您的特定问题的解决方案：

#include <iostream>
#include <stddef.h>
#include <type_traits>
// I've declared this just so the example is portable:
struct iconv_t { };
// use_const<decltype(&iconv)>::value will be 'true' if the function is
// declared as taking a char const**, otherwise ::value will be false.
template <typename>
struct use_const;
template <>
struct use_const<size_t(*)(iconv_t, char**, size_t*, char**, size_t*)>
{
    enum { value = false };
};
template <>
struct use_const<size_t(*)(iconv_t, char const**, size_t*, char**, size_t*)>
{
    enum { value = true };
};

下面是演示该行为的示例：

size_t iconv(iconv_t, char**, size_t*, char**, size_t*);
size_t iconv_const(iconv_t, char const**, size_t*, char**, size_t*);
int main()
{
    using std::cout;
    using std::endl;
    cout << "iconv: "       << use_const<decltype(&iconv)      >::value << endl;
    cout << "iconv_const: " << use_const<decltype(&iconv_const)>::value << endl;
}

一旦你可以检测到参数类型的限定，你可以编写两个调用iconv的包装函数：一个使用 char const** 参数调用 iconv，另一个使用 char** 参数调用iconv。

由于应避免函数模板专用化，因此我们使用类模板进行专用化。 请注意，我们还使每个调用程序成为函数模板，以确保仅实例化我们使用的专用化。 如果编译器尝试为错误的专用化生成代码，则会收到错误。

然后，我们将这些用法包装为call_iconv，使调用它像直接调用iconv一样简单。 以下是显示如何编写的一般模式：

template <bool UseConst>
struct iconv_invoker
{
    template <typename T>
    static size_t invoke(T const&, /* arguments */) { /* etc. */ }
};
template <>
struct iconv_invoker<true>
{
    template <typename T>
    static size_t invoke(T const&, /* arguments */) { /* etc. */ }
};
size_t call_iconv(/* arguments */)
{
    return iconv_invoker<
        use_const<decltype(&iconv)>::value
    >::invoke(&iconv, /* arguments */);
}

(后一种逻辑可以清理和推广;我试图使它的每一部分都明确，希望能更清楚地说明它是如何工作的。

Answer 3

您可以使用

以下内容：

template <typename T>
size_t iconv (iconv_t i, const T inbuf)
{
   return iconv(i, const_cast<T>(inbuf));
}
void myfunc(void) {
  const char** ptr = // ...
  iconv(foo, ptr);
}

您可以传递const char**，在Linux/OSX上，它将通过模板功能在 FreeBSD 上，它将直接转到 iconv 。

缺点：它将允许像iconv(foo, 2.5)这样的调用，这将使编译器无限重复。

Answer 4

#ifdef __linux__
... // linux code goes here.
#elif __FreeBSD__
... // FreeBSD code goes here.
#endif

在这里，您拥有所有操作系统的ID。对我来说，在不检查此系统的情况下尝试做一些取决于操作系统的事情没有任何意义。这就像买绿色裤子，但不看它们。

Answer 5

您已经指出使用自己的包装函数是可以接受的。 你似乎也愿意忍受警告。

因此，与其用 C++ 编写包装器，不如用 C 编写它，在某些系统上你只会收到警告：

// my_iconv.h
#if __cpluscplus
extern "C" {
#endif
size_t my_iconv( iconv_t cd, char **restrict inbuf, ?* etc... */);

#if __cpluscplus
}
#endif

// my_iconv.c
#include <iconv.h>
#include "my_iconv.h"
size_t my_iconv( iconv_t cd, char **inbuf, ?* etc... */)
{
    return iconv( cd, 
                inbuf /* will generate a warning on FreeBSD */,
                /* etc... */
                );
}

Answer 6

怎么样

static void Test(char **)
{
}
int main(void)
{
    const char *t="foo";
    Test(const_cast<char**>(&t));
    return 0;
}

编辑：当然，"没有检测到平台"有点问题。哎呀：-(

编辑2：好的，改进版本，也许？

static void Test(char **)
{
}
struct Foo
{
    const char **t;
    operator char**() { return const_cast<char**>(t); }
    operator const char**() { return t; }
    Foo(const char* s) : t(&s) { }
};
int main(void)
{
    Test(Foo("foo"));
    return 0;
}

Answer 7

怎么样：

#include <cstddef>
using std::size_t;
// test harness, these definitions aren't part of the solution
#ifdef CONST_ICONV
    // other parameters removed for tediousness
    size_t iconv(const char **inbuf) { return 0; }
#else
    // other parameters removed for tediousness
    size_t iconv(char **inbuf) { return 0; }
#endif
// solution
template <typename T>
size_t myconv_helper(size_t (*system_iconv)(T **), char **inbuf) {
    return system_iconv((T**)inbuf); // sledgehammer cast
}
size_t myconv(char **inbuf) {
    return myconv_helper(iconv, inbuf);
}
// usage
int main() {
    char *foo = 0;
    myconv(&foo);
}

我认为这违反了 C++03 中的严格混叠，但在 C++11 中没有，因为在 C++11 中const char**和char**是所谓的"相似类型"。除了创建一个const char*，将其设置为等于*foo，使用指向临时的指针调用iconv，然后在const_cast后将结果复制回*foo之外，您不会避免违反严格别名

：

template <typename T>
size_t myconv_helper(size_t (*system_iconv)(T **), char **inbuf) {
    T *tmpbuf;
    tmpbuf = *inbuf;
    size_t result = system_iconv(&tmpbuf);
    *inbuf = const_cast<char*>(tmpbuf);
    return result;
}

这对于恒定正确性的 POV 是安全的，因为iconv对inbuf所做的只是递增存储在其中的指针。因此，我们正在从从我们第一次看到它时是非常量的指针派生的指针中"抛弃 const"。

我们还可以编写一个重载的myconv和myconv_helper，这些重载const char **inbuf并在另一个方向上搞砸事情，以便调用者可以选择是传入const char**还是char**。可以说iconv应该首先在C++中提供给调用者，但当然接口只是从没有函数重载的 C 复制的。

Answer 8

更新：现在我看到可以在没有自动工具的情况下C++处理它，但我将 autoconf 解决方案留给寻找它的人。

您正在寻找的是iconv.m4它是由gettext包安装的。

AFAICS 只是：

AM_ICONV

在 configure.ac 中，它应该检测到正确的原型。

然后，在您使用的代码中：

#ifdef ICONV_CONST
// const char**
#else
// char**
#endif

Answer 9

我参加这个聚会迟到了，但仍然是我的解决方案：

// This is here because some compilers (Sun CC) think that there is a
// difference if the typedefs are not in an extern "C" block.
extern "C"
{
//! SUSv3 iconv() type.
typedef size_t (& iconv_func_type_1) (iconv_t cd, char * * inbuf,
    size_t * inbytesleft, char * * outbuf, size_t * outbytesleft); 

//! GNU iconv() type.
typedef size_t (& iconv_func_type_2) (iconv_t cd, const char * * inbuf,
    size_t * inbytesleft, char * * outbuf, size_t * outbytesleft);
} // extern "C"
//...
size_t
call_iconv (iconv_func_type_1 iconv_func, char * * inbuf,
    size_t * inbytesleft, char * * outbuf, size_t * outbytesleft)
{
    return iconv_func (handle, inbuf, inbytesleft, outbuf, outbytesleft);
}
size_t
call_iconv (iconv_func_type_2 iconv_func, char * * inbuf,
    size_t * inbytesleft, char * * outbuf, size_t * outbytesleft)
{
    return iconv_func (handle, const_cast<const char * *>(inbuf),
        inbytesleft, outbuf, outbytesleft);
}
size_t
do_iconv (char * * inbuf, size_t * inbytesleft, char * * outbuf,
    size_t * outbytesleft)
{
    return call_iconv (iconv, inbuf, inbytesleft, outbuf, outbytesleft);
}