Як я можу переносити функцію C ++, яка приймає char ** на одних платформах і const char ** на інших?

На моїх машинах 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 ++ це фатальна помилка. Отже, якщо я передаю a char**, він не компілюється на BSD, а якщо передаю - 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);

sloppy () приймає a char**або a const char*і перетворює його в a char**або a const char*, що б не вимагав другий параметр iconv.

ОНОВЛЕННЯ: змінено на використання const_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

Тут ви маєте ідентифікатори всіх операційних систем. Для мене немає сенсу намагатися робити щось, що залежить від операційної системи, не перевіряючи цю систему. Це все одно, що купувати зелені штани, але не дивлячись на них.

Ви вказали, що використання власної функції обгортки є прийнятним. Ви, схоже, готові жити з попередженнями.

Отже, замість того, щоб писати свою обгортку на 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;
}

EDIT: звичайно, "без виявлення платформи" - це трохи проблема. На жаль :-(

EDIT 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**є так звані "подібні типи". Ви не збираєтеся уникнути цього порушення суворого псевдоніму, окрім як створення a const char*, встановіть його рівним *foo, зателефонуйте iconvвказівником на тимчасовий, а потім скопіюйте результат назад на *fooпісля 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;
}

Це безпечно від POV конст-коректності, оскільки все iconvце робиться зinbuf - це збільшення покажчика, що зберігається в ньому. Отже, ми «відкидаємо const» від покажчика, отриманого з вказівника, який не був const, коли ми його вперше побачили.

Ми могли б також написати перевантаження 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);
}