Wie kann ich eine C ++ - Funktion portabel aufrufen, die auf einigen Plattformen ein Zeichen ** und auf anderen ein const char ** verwendet?

Auf meinen Linux- (und OS X-) Computern hat die iconv()Funktion diesen Prototyp:

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

auf FreeBSD sieht es so aus:

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

Ich möchte, dass mein C ++ - Code auf beiden Plattformen erstellt wird. Bei C-Compilern gibt das Übergeben von a char**für einen const char**Parameter (oder umgekehrt) normalerweise nur eine Warnung aus. In C ++ ist dies jedoch ein schwerwiegender Fehler. Wenn ich also a übergebe char**, wird es unter BSD nicht kompiliert, und wenn ich a übergebe const char**, wird es unter Linux / OS X nicht kompiliert. Wie kann ich Code schreiben, der auf beiden kompiliert wird, ohne zu versuchen, die Plattform zu erkennen?

Eine (fehlgeschlagene) Idee war, einen lokalen Prototyp bereitzustellen, der alle vom Header bereitgestellten überschreibt:

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

Dies schlägt fehl, weil iconveine C-Verknüpfung erforderlich ist und Sie keine extern "C"Funktion einfügen können (warum nicht?)

Die beste Arbeitsidee, die ich mir ausgedacht habe, ist, den Funktionszeiger selbst umzuwandeln:

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

Dies kann jedoch andere, schwerwiegendere Fehler maskieren.

Wenn Sie nur ein Auge auf einige konstante Probleme werfen möchten, können Sie eine Konvertierung verwenden, die die Unterscheidung verwischt, dh char ** und const char ** interoperabel macht:

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

Dann später im Programm:

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

sloppy () nimmt a char**oder a const char*und konvertiert es in a char**oder a const char*, unabhängig davon, was der zweite Parameter von iconv verlangt.

UPDATE: geändert, um const_cast zu verwenden und schlampig aufzurufen, nicht als Besetzung.

Sie können zwischen den beiden Deklarationen unterscheiden, indem Sie die Signatur der deklarierten Funktion überprüfen. Hier ist ein grundlegendes Beispiel für die Vorlagen, die zum Überprüfen des Parametertyps erforderlich sind. Dies könnte leicht verallgemeinert werden (oder Sie könnten die Funktionsmerkmale von Boost verwenden), aber dies reicht aus, um eine Lösung für Ihr spezifisches Problem zu demonstrieren:

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

Hier ist ein Beispiel, das das Verhalten demonstriert:

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

Sobald Sie die Qualifikation des Parametertyps erkannt haben, können Sie zwei Wrapper-Funktionen schreiben, die aufrufen iconv: eine, die iconvmit einem char const**Argument aufruft, und eine, die iconvmit einem char**Argument aufruft .

Da die Spezialisierung von Funktionsvorlagen vermieden werden sollte, verwenden wir eine Klassenvorlage, um die Spezialisierung durchzuführen. Beachten Sie, dass wir jeden Aufrufer auch zu einer Funktionsvorlage machen, um sicherzustellen, dass nur die von uns verwendete Spezialisierung instanziiert wird. Wenn der Compiler versucht, Code für die falsche Spezialisierung zu generieren, werden Fehler angezeigt.

Wir schließen diese dann mit einem ab call_iconv, um das Aufrufen so einfach wie das iconvdirekte Aufrufen zu machen . Das Folgende ist ein allgemeines Muster, das zeigt, wie dies geschrieben werden kann:

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

(Diese letztere Logik könnte bereinigt und verallgemeinert werden. Ich habe versucht, jedes Stück explizit zu machen, um hoffentlich klarer zu machen, wie es funktioniert.)

Sie können Folgendes verwenden:

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

Sie können übergeben const char**und unter Linux / OSX wird es die Vorlagenfunktion durchlaufen und unter FreeBSD wird es direkt zu gehen iconv.

Nachteil: Es ermöglicht Aufrufe, mit iconv(foo, 2.5)denen der Compiler unendlich oft wiederholt wird.

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

Hier haben Sie IDs aller Betriebssysteme. Für mich hat es keinen Sinn, etwas zu tun, was vom Betriebssystem abhängt, ohne dieses System zu überprüfen. Es ist, als würde man eine grüne Hose kaufen, ohne sie anzusehen.

Sie haben angegeben, dass die Verwendung Ihrer eigenen Wrapper-Funktion akzeptabel ist. Sie scheinen auch bereit zu sein, mit Warnungen zu leben.

Schreiben Sie Ihren Wrapper also nicht in C ++, sondern in C, wo Sie nur auf einigen Systemen eine Warnung erhalten:

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

Wie wäre es mit

static void Test(char **)
{
}

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

EDIT: Natürlich ist das "ohne die Plattform zu erkennen" ein kleines Problem. Hoppla :-(

EDIT 2: ok, verbesserte Version vielleicht?

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

Wie wäre es mit:

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

Ich denke , das strenge Aliasing in C ++ verletzt 03, aber nicht in C ++ 11 , da in C ++ 11 const char**und char**sind so genannte "ähnliche Typen". Sie werden diese Verletzung des strengen Aliasing nicht vermeiden, außer indem Sie ein erstellen const char*, es auf setzen *foo, iconvmit einem Zeiger auf das temporäre Element aufrufen und das Ergebnis *foonach a zurückkopieren 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;
}

Dies ist sicher vor dem POV der Konstantenkorrektheit, weil alles damit zu iconvtun hatinbuf Zuwachs ist der Zeiger in ihm gespeichert. Wir "werfen const weg" von einem Zeiger, der von einem Zeiger abgeleitet wurde, der nicht const war, als wir ihn zum ersten Mal sahen.

Wir könnten auch eine Überlastung der schreiben myconvund myconv_helperdas nimmt const char **inbufund Verwirrungen Dinge über in der anderen Richtung, so dass der Anrufer die Wahl hat , ob in einem zu übergeben const char**oder ein char**. Welches wohliconv dem Aufrufer in C ++ eigentlich hätte geben sollen, aber natürlich wird die Schnittstelle nur von C kopiert, wo es keine Funktionsüberladung gibt.

Update: Jetzt sehe ich, dass es möglich ist, es in C ++ ohne Autotools zu handhaben, aber ich lasse die Autoconf-Lösung für Leute, die danach suchen.

Was Sie suchen, ist iconv.m4 das, was von gettext package installiert wird.

AFAICS es ist nur:

AM_ICONV

in configure.ac, und es sollte den richtigen Prototyp erkennen.

Dann in dem Code, den Sie verwenden:

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

Ich bin zu spät zu dieser Party, aber hier ist meine Lösung:

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