Bazı platformlarda char ** ve diğerlerinde const char ** alan bir C ++ işlevini taşınabilir bir şekilde nasıl çağırabilirim?

Linux (ve OS X) makinelerimde, iconv()işlev şu prototipe sahiptir:

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

FreeBSD'de şu şekilde görünür:

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

C ++ kodumun her iki platformda da oluşturulmasını istiyorum. C derleyicileriyle, char**bir const char**parametre için (veya tam tersi) geçmek tipik olarak yalnızca bir uyarı verir; ancak C ++ 'da bu ölümcül bir hatadır. Yani eğer char**a'yı geçersem, BSD'de derlenmez ve eğer bir const char**geçersem Linux / OS X'de derlenmez. Platformu tespit etmeye çalışmadan her ikisinde de derleyen kod yazabilirim?

Aklımdaki (başarısız) bir fikir, başlık tarafından sağlananları geçersiz kılan yerel bir prototip sağlamaktı:

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

Bu başarısız olur çünkü iconvC bağlantısına ihtiyaç vardır ve extern "C"bir işlevin içine koyamazsınız (neden olmasın?)

Bulduğum en iyi çalışma fikri, işlev işaretçisini kendisinin atmasıdır:

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

ancak bu daha ciddi hataları maskeleme potansiyeline sahiptir.

İstediğiniz şey yalnızca bazı sabit sorunları görmezden gelmekse, o zaman ayrımı bulanıklaştıran, yani char ** ve const char ** ile birlikte çalışabilir hale getiren bir dönüştürme kullanabilirsiniz:

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

Daha sonra programda:

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

sloppy (), a char**veya a'yı alır const char*ve iconv'nin ikinci parametresi ne olursa olsun bunu a char**veya a'ya dönüştürür const char*.

GÜNCELLEME: const_cast kullanmak için değiştirildi ve döküm olarak değil özensiz çağrısı.

Bildirilen işlevin imzasını inceleyerek iki bildirim arasındaki belirsizliği ortadan kaldırabilirsiniz. Parametre türünü incelemek için gereken şablonların temel bir örneğini burada bulabilirsiniz. Bu kolayca genelleştirilebilir (veya Boost'un işlev özelliklerini kullanabilirsiniz), ancak bu, özel probleminize bir çözüm göstermek için yeterlidir:

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

İşte davranışı gösteren bir örnek:

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

Parametre türü niteliğini algılayabilir sonra, çağrı iki sarıcı işlevleri yazabilirsiniz iconv: birini o çağrıları iconvbir ile char const**argüman ve bir o çağrıları iconvbir ile char**argüman.

İşlev şablonu uzmanlaşmasından kaçınılması gerektiğinden, uzmanlaşmayı yapmak için bir sınıf şablonu kullanıyoruz. Ayrıca, yalnızca kullandığımız uzmanlığın somutlaştırılmasını sağlamak için her invokeri bir işlev şablonu yaptığımızı unutmayın. Derleyici yanlış uzmanlık için kod üretmeye çalışırsa, hatalar alırsınız.

Daha sonra, call_iconvbunu iconvdoğrudan aramak kadar basit bir şekilde çağırmak için bunların kullanımını a ile sarıyoruz . Aşağıda bunun nasıl yazılabileceğini gösteren genel bir kalıp verilmiştir:

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

(Bu son mantık temizlenebilir ve genelleştirilebilir; umarım nasıl çalıştığını daha net hale getirmek için her bir parçasını açık hale getirmeye çalıştım.)

Aşağıdakileri kullanabilirsiniz:

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

Geçebilirsiniz const char**ve Linux / OSX üzerinde şablon işlevinden geçecek ve FreeBSD'de doğrudan gidecektir iconv.

Dezavantajı: iconv(foo, 2.5)Derleyiciyi sonsuz yinelemeye sokacak gibi çağrılara izin verecektir.

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

Burada tüm işletim sistemlerinin kimliklerine sahipsiniz. Benim için bu sistemi kontrol etmeden işletim sistemine bağlı bir şey yapmayı denemenin bir anlamı yok. Yeşil pantolon almaya benziyor ama onlara bakmadan.

Kendi sarmalayıcı işlevinizi kullanmanın kabul edilebilir olduğunu belirttiniz. Ayrıca uyarılarla yaşamaya istekli görünüyorsun.

Bu nedenle, sarmalayıcınızı C ++ 'da yazmak yerine, yalnızca bazı sistemlerde bir uyarı alacağınız C dilinde yazın:

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

Ne dersin

static void Test(char **)
{
}

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

DÜZENLEME: Tabii ki, "platformu tespit etmeden" biraz problemdir. Hata :-(

DÜZENLEME 2: tamam, geliştirilmiş sürüm, belki?

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

Ne dersin:

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

Bunun C ++ 03'te katı örtüşme ihlal ettiğini düşünüyorum, ancak C ++ 11'de değil çünkü C ++ 11'de const char**ve char**sözde "benzer türler" olarak adlandırılıyor. Bu katı örtüşme ihlalini, a oluşturmak const char*, eşit olarak ayarlamak , geçici bir işaretçi ile *fooaramak iconvve ardından sonucu a'dan *foosonra geri kopyalamak dışında engelleyemezsiniz 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;
}

Bu sabit doğruluk bakış açısına göre güvenlidir, çünkü tüm iconvyaptığı, inbufiçinde depolanan işaretçiyi artırmaktır. Yani ilk gördüğümüzde const olmayan bir göstericiden türetilen bir göstericiden "const uzağa atıyoruz".

Ayrıca, bir aşırı yük yazabiliriz myconvve myconv_helperbu const char **inbuf, işleri diğer yönde alıp karıştırır , böylece arayan kişi a const char**veya a geçme seçeneğine sahip olur char**. Muhtemelen iconvarayan kişiye C ++ 'da ilk etapta verilmiş olmalıydı, ancak elbette arayüz, işlev aşırı yüklemesinin olmadığı C'den kopyalandı.

Güncelleme: Artık bunu otomatik araçlar olmadan C ++ 'da kullanmanın mümkün olduğunu görüyorum, ancak bunu arayan insanlar için autoconf çözümünü bırakıyorum.

Aradığınız şey iconv.m4gettext paketi tarafından kuruludur.

AFAICS sadece:

AM_ICONV

configure.ac içinde ve doğru prototipi algılaması gerekir.

Ardından, kullandığınız kodda:

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

Bu partiye geç kaldım ama yine de işte çözümüm:

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