Come posso chiamare portabilmente una funzione C ++ che accetta un carattere ** su alcune piattaforme e un carattere const ** su altre?

Sulle mie macchine Linux (e OS X), la iconv()funzione ha questo prototipo:

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

mentre su FreeBSD assomiglia a questo:

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

Vorrei che il mio codice C ++ si compilasse su entrambe le piattaforme. Con i compilatori C, il passaggio di a char**per un const char**parametro (o viceversa) tipicamente genera un semplice avvertimento; tuttavia in C ++ è un errore fatale. Quindi se passo a char**, non si compilerà su BSD, e se passo a const char**non si compilerà su Linux / OS X. Come posso scrivere codice che compili su entrambi, senza ricorrere al tentativo di rilevare la piattaforma?

Un'idea (fallita) che avevo era quella di fornire un prototipo locale che sovrascriva qualsiasi fornito dall'intestazione:

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

Questo fallisce perché ha iconvbisogno del collegamento C e non puoi inserire extern "C"una funzione (perché no?)

La migliore idea di lavoro che ho avuto è quella di lanciare il puntatore alla funzione stesso:

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

ma questo ha il potenziale per mascherare altri errori più gravi.

Se quello che vuoi è solo chiudere un occhio su alcuni problemi con const, puoi usare una conversione che offusca la distinzione, cioè rende char ** e const char ** interoperabili:

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

Quindi più avanti nel programma:

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

sloppy () prende a char**o a const char*e lo converte in a char**o a const char*, qualunque sia il secondo parametro di iconv richiesto.

AGGIORNAMENTO: modificato per utilizzare const_cast e chiamare sciatto non come cast.

È possibile chiarire le ambiguità tra le due dichiarazioni controllando la firma della funzione dichiarata. Ecco un esempio di base dei modelli richiesti per ispezionare il tipo di parametro. Questo potrebbe essere facilmente generalizzato (o potresti usare i tratti della funzione di Boost), ma questo è sufficiente per dimostrare una soluzione per il tuo problema specifico:

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

Ecco un esempio che dimostra il comportamento:

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

Una volta rilevata la qualificazione del tipo di parametro, è possibile scrivere due funzioni wrapper che chiamano iconv: una che chiama iconvcon un char const**argomento e una che chiama iconvcon un char**argomento.

Poiché la specializzazione del modello di funzione dovrebbe essere evitata, utilizziamo un modello di classe per eseguire la specializzazione. Nota che rendiamo anche ogni invokers un modello di funzione, per assicurarci che venga istanziata solo la specializzazione che usiamo. Se il compilatore tenta di generare codice per la specializzazione sbagliata, verranno visualizzati degli errori.

Quindi includiamo l'uso di questi con un call_iconvper rendere la chiamata semplice come chiamare iconvdirettamente. Quello che segue è un modello generale che mostra come questo può essere scritto:

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

(Quest'ultima logica potrebbe essere ripulita e generalizzata; Ho cercato di rendere esplicita ogni parte di essa per rendere, si spera, più chiaro come funziona.)

Puoi usare quanto segue:

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

Puoi passare const char**e su Linux / OSX passerà attraverso la funzione template e su FreeBSD andrà direttamente a iconv.

Svantaggio: consentirà chiamate come quelle iconv(foo, 2.5)che metterà il compilatore in ricorrenza infinita.

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

Qui hai gli ID di tutti i sistemi operativi. Per me non ha alcun senso provare a fare qualcosa che dipende dal sistema operativo senza controllare questo sistema. È come comprare pantaloni verdi ma senza guardarli.

Hai indicato che l'utilizzo della tua funzione wrapper è accettabile. Sembri anche disposto a convivere con gli avvertimenti.

Quindi, invece di scrivere il tuo wrapper in C ++, scrivilo in C, dove riceverai un avviso solo su alcuni sistemi:

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

Che ne dite di

static void Test(char **)
{
}

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

EDIT: ovviamente, il "senza rilevare la piattaforma" è un po 'un problema. Oops :-(

EDIT 2: ok, forse una versione migliorata?

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

Che dire:

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

Penso che questo violi il rigoroso aliasing in C ++ 03, ma non in C ++ 11 perché in C ++ 11 const char**e char**sono i cosiddetti "tipi simili". Non eviterai quella violazione dell'aliasing rigoroso se non creando un const char*, impostalo uguale a *foo, chiama iconvcon un puntatore al temporaneo, quindi copia il risultato *foodopo a 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;
}

Questo è al sicuro dal punto di vista della correttezza const, perché tutto iconvfa coninbuf è incrementare il puntatore memorizzato in esso. Quindi stiamo "eliminando const" da un puntatore derivato da un puntatore che non era const quando l'abbiamo visto per la prima volta.

Potremmo anche scrivere un sovraccarico di myconve myconv_helperche prendono const char **inbufe pasticciano le cose nell'altra direzione, in modo che il chiamante possa scegliere se passare in a const char**o a char**. Che probabilmente iconvavrebbe dovuto dare al chiamante in primo luogo in C ++, ma ovviamente l'interfaccia viene semplicemente copiata da C dove non c'è sovraccarico di funzioni.

Aggiornamento: ora vedo che è possibile gestirlo in C ++ senza autotools, ma lascio la soluzione autoconf per le persone che la cercano.

Quello che stai cercando è iconv.m4che sia installato dal pacchetto gettext.

AFAICS è solo:

AM_ICONV

in configure.ac, e dovrebbe rilevare il prototipo corretto.

Quindi, nel codice che usi:

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

Sono in ritardo a questa festa ma comunque, ecco la mia soluzione:

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