ฉันจะเรียกใช้ฟังก์ชัน C ++ แบบพกพาที่ใช้ถ่าน ** บนบางแพลตฟอร์มและ 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 ต้องการ

UPDATE: เปลี่ยนไปใช้ 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;
}

เมื่อคุณตรวจพบคุณสมบัติของประเภทพารามิเตอร์ได้แล้วคุณสามารถเขียนฟังก์ชัน wrapper สองฟังก์ชันที่เรียกใช้ฟังก์ชัน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**และลินุกซ์ / OSX มันจะไปถึงฟังก์ชั่นแม่แบบและบน FreeBSD iconvมันจะไปโดยตรงไป

ข้อเสียเปรียบ: จะอนุญาตให้มีการโทรเช่นiconv(foo, 2.5)ซึ่งจะทำให้คอมไพเลอร์เกิดการเกิดซ้ำแบบไม่สิ้นสุด

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

ที่นี่คุณมีรหัสของระบบปฏิบัติการทั้งหมด สำหรับฉันมันไม่มีจุดที่จะลองทำสิ่งที่ขึ้นอยู่กับระบบปฏิบัติการโดยไม่ตรวจสอบระบบนี้ เหมือนกับการซื้อกางเกงขายาวสีเขียว แต่ไม่ได้มอง

คุณได้ระบุว่าการใช้ฟังก์ชัน Wrapper ของคุณเองนั้นยอมรับได้ ดูเหมือนว่าคุณเต็มใจที่จะอยู่กับคำเตือน

ดังนั้นแทนที่จะเขียน wrapper ของคุณใน 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**เรียกว่า "ประเภทที่คล้ายกัน" คุณจะไม่ได้ไปเพื่อหลีกเลี่ยงการละเมิด aliasing เข้มงวดอื่น ๆ ที่นอกเหนือจากการสร้าง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;
}

สิ่งนี้ปลอดภัยจาก POV ของความถูกต้องของ const เพราะสิ่งที่iconvทำinbufคือการเพิ่มตัวชี้ที่เก็บไว้ในนั้น ดังนั้นเราจึง "แคสต์ const ออกไป" จากตัวชี้ที่ได้มาจากตัวชี้ที่ไม่ใช่ const เมื่อเราเห็นครั้งแรก

นอกจากนี้เรายังสามารถเขียนเกินพิกัดmyconvและmyconv_helperที่ใช้const char **inbufและทำให้สิ่งต่าง ๆ ยุ่งเหยิงไปในทิศทางอื่นเพื่อให้ผู้โทรมีทางเลือกว่าจะส่งconst char**ไฟล์char**. เนื้อหาใดที่iconvควรให้แก่ผู้โทรตั้งแต่แรกใน C ++ แต่แน่นอนว่าอินเทอร์เฟซนั้นคัดลอกมาจาก C โดยที่ไม่มีฟังก์ชันโอเวอร์โหลด

อัปเดต: ตอนนี้ฉันเห็นว่ามันเป็นไปได้ที่จะจัดการมันใน C ++ โดยไม่ต้องใช้เครื่องมืออัตโนมัติ แต่ฉันกำลังออกจากโซลูชัน autoconf สำหรับผู้ที่กำลังมองหามัน

สิ่งที่คุณกำลังมองหาคือiconv.m4สิ่งที่ติดตั้งโดยแพ็คเกจ gettext

AFAICS เป็นเพียง:

AM_ICONV

ใน config.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);
}