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

在我的Linux（和OS X）计算机上，该iconv()函数具有以下原型：

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

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

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

我希望我的C ++代码可以在两个平台上构建。对于C编译器，传递char**for const char**参数（反之亦然）通常仅发出警告；反之亦然。但是在C ++中，这是一个致命错误。因此，如果传递a char**，它将无法在BSD上进行编译，如果传递a 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);

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

如果您只想对某些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);

无论iconv的第二个参数要求是什么，sloppy（）都将a char**或a const char*转换为a char**或a const char*。

更新：更改为使用const_cast并调用sloppy而不是as cast。

您可以通过检查已声明函数的签名来消除两个声明之间的歧义。这是检查参数类型所需的模板的基本示例。可以很容易地将其概括（或者您可以使用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：一个iconv使用char const**参数调用，而另一个iconv使用char**参数调用。

因为应该避免功能模板的专业化，所以我们使用类模板进行专业化。请注意，我们还将每个调用者都设为一个函数模板，以确保仅实例化我们使用的专业化。如果编译器试图为错误的专业化生成代码，则会出现错误。

然后，我们使用来包装这些用法，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 */);
}

（可以对后一种逻辑进行清理和归纳；我试图将其每一部分都明确化，以期希望更清楚地说明其工作原理。）

您可以使用以下内容：

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)这样的调用使编译器无限循环。

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

在这里，您具有所有操作系统的ID。对我来说，没有检查该系统就没有必要尝试做一些依赖于操作系统的事情。这就像买绿色的裤子，但不看它们。

您已经表明可以使用自己的包装函数。您似乎也愿意忍受警告。

因此，与其使用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... */
                );
}

怎么样

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;
}

关于什么：

#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的指针到临时，然后将结果复制回*foo后const_cast：

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;
}

从const正确性的POV来看这是安全的，因为所有iconv操作inbuf都是增加存储在其中的指针。因此，我们从最初看到非常量指针的指针中“抛出了常量”。

我们也可以这样写的过载myconv和myconv_helper称取const char **inbuf和混乱的事情有关在其他方向，从而使调用者有选择是否在一传const char**或一char**。可以说，这iconv应该是在C ++中首先应该给调用方的，但是当然，接口只是从C复制而来的，这里没有函数重载。

更新：现在我看到无需自动工具就可以用C ++处理它，但是我将autoconf解决方案留给了寻找它的人们。

您要查找的是iconv.m4由gettext软件包安装的。

AFAICS只是：

AM_ICONV

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

然后，在代码中使用：

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

我参加这个聚会很晚，但是仍然是我的解决方案：

// 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);
}