আমি কীভাবে পোর্টেবলভাবে একটি সি ++ ফাংশন কল করতে পারি যা কিছু প্ল্যাটফর্মে একটি চর এবং অন্যদের কাছে কনস্টের চর নেয়?

Question 1

আমার লিনাক্স (এবং ওএস এক্স) মেশিনে, iconv()ফাংশনটির এই প্রোটোটাইপ রয়েছে:

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

ফ্রিবিএসডি থাকাকালীন এটিকে দেখতে দেখতে এমন দেখাচ্ছে:

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

আমি উভয় প্ল্যাটফর্মে আমার সি ++ কোড তৈরি করতে চাই। সি সংকলকগুলির সাথে, char**একটি const char**প্যারামিটারের জন্য একটি পাস (বা বিপরীতে) সাধারণত একটি নিছক সতর্কতা প্রকাশ করে; তবে সি ++ এ এটি মারাত্মক ত্রুটি। সুতরাং আমি যদি পাস করি তবে char**এটি বিএসডি-তে সংকলন করবে না এবং আমি যদি পাস করি তবে const char**এটি লিনাক্স / ওএস এক্স-এ সংকলিত হবে না the প্ল্যাটফর্মটি সনাক্ত করার চেষ্টা না করে আমি কীভাবে উভয়কে সংকলিত কোড লিখতে পারি?

আমার একটি (ব্যর্থ) ধারণা ছিল একটি স্থানীয় প্রোটোটাইপ সরবরাহ করা যা শিরোলেখ দ্বারা প্রদত্ত যে কোনওটিকে ওভাররাইড করে:

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

এটি ব্যর্থ হয়েছে কারণ iconvসি লিঙ্কেজ প্রয়োজন, এবং আপনি extern "C"কোনও ফাংশনের মধ্যে রাখতে পারবেন না (কেন নয়?)

আমি যে সর্বোত্তম কার্যকরী ধারণা নিয়ে এসেছি তা হ'ল ফাংশন পয়েন্টারটি নিজেই কাস্ট করা:

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

তবে এটিতে আরও গুরুতর ত্রুটিগুলি মাস্ক করার সম্ভাবনা রয়েছে।

Question 2

আপনি যা চান তা যদি কেবল কিছু স্থির বিষয়গুলিতে অন্ধ দৃষ্টি দেওয়া হয়, তবে আপনি এমন রূপান্তর ব্যবহার করতে পারেন যা পার্থক্যটিকে ঝাপসা করে, অর্থাত্ ** চর এবং ** চরকে ** আন্তঃযোগযোগ্য করে তুলবে:

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

opড়ু () একটি char**বা একটি নেয় const char*এবং আইকনভের দ্বিতীয় প্যারামিটারের দাবি অনুসারে এটিকে একটি char**বা এ রূপান্তর করে const char*।

আপডেট: কনস্ট_কাস্ট এবং কল স্লোপি কাস্ট হিসাবে নয় ব্যবহার করতে পরিবর্তিত হয়েছে।

Question 3

ঘোষিত ফাংশনের স্বাক্ষর পরিদর্শন করে আপনি দুটি ঘোষণার মধ্যে বিচ্ছিন্ন করতে পারেন। প্যারামিটার ধরণের পরীক্ষা করতে প্রয়োজনীয় টেম্পলেটগুলির একটি প্রাথমিক উদাহরণ এখানে। এটি সহজেই সাধারণীকরণ করা যেতে পারে (বা আপনি বুস্টের ফাংশন বৈশিষ্ট্যগুলি ব্যবহার করতে পারেন) তবে এটি আপনার নির্দিষ্ট সমস্যার সমাধানের জন্য যথেষ্ট sufficient

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

(এই পরবর্তী যুক্তিটি পরিষ্কার করে সাধারণীকরণ করা যেতে পারে; আমি এর প্রতিটি টুকরোটি পরিষ্কারভাবে তৈরি করার চেষ্টা করেছি আশা করি এটি কীভাবে কাজ করে তা আরও পরিষ্কার করে দেওয়া।)

Question 4

আপনি নিম্নলিখিত ব্যবহার করতে পারেন:

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**এবং লিনাক্স / ওএসএক্স এ এটি টেম্পলেট ফাংশনটি দিয়ে যাবে এবং ফ্রিবিএসডি-তে এটি সরাসরি যাবে iconv।

খসড়া: এটি এমন কলগুলিকে অনুমতি দেবে iconv(foo, 2.5)যা অসীম পুনরাবৃত্তিতে সংকলক রাখবে।

Question 5

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

এখানে আপনার কাছে সমস্ত অপারেটিং সিস্টেমের আইডিস রয়েছে। আমার জন্য এই সিস্টেমটি পরীক্ষা না করে অপারেটিং সিস্টেমের উপর নির্ভর করে এমন কিছু করার চেষ্টা করার কোনও અર્થ নেই। এটি সবুজ ট্রাউজার কিনার মতো তবে তাদের দিকে না তাকিয়ে।

Question 6

আপনি নির্দেশ করেছেন যে আপনার নিজের র‍্যাপার ফাংশনটি গ্রহণযোগ্য। আপনিও সতর্কতার সাথে বাঁচতে ইচ্ছুক বলে মনে করছেন।

সুতরাং, আপনার মোড়কে সি ++ তে লেখার পরিবর্তে এটি সিতে লিখুন, যেখানে আপনি কেবল কয়েকটি সিস্টেমে একটি সতর্কতা পাবেন:

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

Question 7

কেমন

static void Test(char **)
{
}

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

সম্পাদনা: অবশ্যই, "প্ল্যাটফর্ম সনাক্ত না করে" কিছুটা সমস্যা is ওফস :-(

সম্পাদনা 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;
}

Question 8

কি সম্পর্কে:

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

আমি মনে করি এটি সি ++ 03 তে কঠোর আলিয়াজিং লঙ্ঘন করেছে, তবে সি ++ 11 এ নয় কারণ সি ++ 11 const char**এবং char**তথাকথিত "একই ধরণের" রয়েছে। আপনি কোনও তৈরির পরিবর্তে অন্যের মতো কঠোর আলিয়াজিংয়ের লঙ্ঘন এড়াতে পারবেন না 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;
}

এটি দৃ const়তা-নির্ভুলতার POV থেকে নিরাপদ, কারণ সব iconv এটি করেinbuf তা এতে সঞ্চারিত পয়েন্টার বৃদ্ধি করে। সুতরাং আমরা পয়েন্টার থেকে প্রাপ্ত পয়েন্টার থেকে "কাস্টিং দূরে ফেলে দিচ্ছি" যেটি প্রথম দেখলাম non

আমরা একজন জমিদার লিখতে পারে myconvএবং myconv_helperযে নিতে const char **inbufঅন্যান্য দিক সম্পর্কে এবং messes, যার দরুন আহ্বানকারী একটি মধ্যে পাস করা হবে কিনা তা পছন্দ হয়েছে const char**বা char**। কোনটি যুক্তিযুক্তভাবে iconvC ++ এ প্রথম স্থানে কলকারীকে দেওয়া উচিত ছিল, তবে অবশ্যই ইন্টারফেসটি কেবল সি থেকে অনুলিপি করা হয়েছিল যেখানে কোনও ফাংশন ওভারলোডিং নেই।

Question 9

আপডেট: এখন আমি দেখতে পাচ্ছি যে এটি অটোটুল ছাড়াই সি ++ এ পরিচালনা করা সম্ভব, তবুও আমি এটি সন্ধানকারী লোকদের জন্য অটোকনফ সমাধানটি রেখে দিচ্ছি।

আপনি iconv.m4যা সন্ধান করছেন তা হ'ল gettext প্যাকেজ দ্বারা ইনস্টল করা।

আফিক্স এটি ঠিক:

AM_ICONV

কনফিগার.একে, এবং এটির সঠিক প্রোটোটাইপ সনাক্ত করা উচিত।

তারপরে, আপনি যে কোডটি ব্যবহার করছেন তাতে:

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

Question 10

আমি এই পার্টিতে দেরি করেছি তবে এখনও, আমার সমাধানটি এখানে:

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