일부 플랫폼에서는 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**대해 전달 const char**(또는 그 반대)은 일반적으로 단순한 경고를 내 보냅니다. 그러나 C ++에서는 치명적인 오류입니다. 따라서를 전달하면 char**BSD에서 컴파일되지 않고, 전달하면 const char**Linux / OS X에서 컴파일되지 않습니다. 플랫폼을 감지하지 않고 두 가지 모두에서 컴파일되는 코드를 어떻게 작성할 수 있습니까?

한 가지 (실패한) 아이디어는 헤더에서 제공하는 모든 것을 재정의하는 로컬 프로토 타입을 제공하는 것이 었습니다.

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

iconvC 연결 이 필요 하기 때문에 실패 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);

sloppy ()는 a char**또는 a const char*를 받아서 iconv의 두 번째 매개 변수가 요구하는대로 a char**또는 a 로 변환합니다 const char*.

업데이트 : const_cast를 사용하고 as cast가 아닌 sloppy를 호출하도록 변경되었습니다.

선언 된 함수의 시그니처를 검사하여 두 선언을 명확하게 할 수 있습니다. 다음은 매개 변수 유형을 검사하는 데 필요한 템플릿의 기본 예입니다. 이것은 쉽게 일반화 될 수 있지만 (또는 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;
}

이것은 모든 iconv것이 inbuf그 안에 저장된 포인터를 증가시키기 때문에 const-correctness의 POV로부터 안전 합니다. 그래서 우리는 처음 보았을 때 상수가 아닌 포인터에서 파생 된 포인터에서 "const를 캐스팅"하고 있습니다.

우리는 또한 overload of myconvand myconv_helperthat take const char **inbufand messes something about the other direction, 그래서 호출자가 a const char**또는 char**. iconvC ++에서 처음에 호출자에게 주어 졌어 야했지만, 물론 인터페이스는 함수 오버로딩이없는 C에서 복사됩니다.

업데이트 : 이제 autotools없이 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);
}