c++ অবজ একটি ফাংশন এর অস্তিত্ব পরীক্ষা করার জন্য একটি টেমপ্লেট লিখতে কি সম্ভব?




সি++ বই (20)

একটি নির্দিষ্ট টেমপ্লেট কোন শ্রেণীতে সংজ্ঞায়িত করা হয় কিনা তার উপর নির্ভর করে আচরণ পরিবর্তন করে এমন একটি টেমপ্লেট লিখতে পারে?

আমি যা লিখতে চাই তার একটি সহজ উদাহরণ এখানে দেওয়া হল:

template<class T>
std::string optionalToString(T* obj)
{
    if (FUNCTION_EXISTS(T->toString))
        return obj->toString();
    else
        return "toString not defined";
}

সুতরাং, যদি class T এর toString() সংজ্ঞায়িত থাকে তবে এটি ব্যবহার করে; অন্যথায়, এটা না। "FUNCTION_EXISTS" অংশটি কীভাবে করতে হবে তা আমি জানি না এমন ঐন্দ্রজালিক অংশ।


এখানে অনেকগুলি উত্তর রয়েছে, তবে একটি সংস্করণ খুঁজে বের করতে ব্যর্থ হয়েছে, যা বাস্তব পদ্ধতির রেজোলিউশন ক্রম সঞ্চালন করে , যখন কোনও নতুন সি ++ বৈশিষ্ট্যগুলি ব্যবহার করে না (কেবলমাত্র সি ++ 98 বৈশিষ্ট্যগুলি ব্যবহার করে)।
দ্রষ্টব্য: এই সংস্করণটি পরীক্ষা করা হয়েছে এবং ভিসি ++ 2013, জি ++ 5.2.0 এবং অনলাইন কম্পাইলারের সাথে কাজ করছে।

তাই আমি একটি সংস্করণ নিয়ে এসেছি, যা sizeof () ব্যবহার করে:

template<typename T> T declval(void);

struct fake_void { };
template<typename T> T &operator,(T &,fake_void);
template<typename T> T const &operator,(T const &,fake_void);
template<typename T> T volatile &operator,(T volatile &,fake_void);
template<typename T> T const volatile &operator,(T const volatile &,fake_void);

struct yes { char v[1]; };
struct no  { char v[2]; };
template<bool> struct yes_no:yes{};
template<> struct yes_no<false>:no{};

template<typename T>
struct has_awesome_member {
 template<typename U> static yes_no<(sizeof((
   declval<U>().awesome_member(),fake_void()
  ))!=0)> check(int);
 template<typename> static no check(...);
 enum{value=sizeof(check<T>(0)) == sizeof(yes)};
};


struct foo { int awesome_member(void); };
struct bar { };
struct foo_void { void awesome_member(void); };
struct wrong_params { void awesome_member(int); };

static_assert(has_awesome_member<foo>::value,"");
static_assert(!has_awesome_member<bar>::value,"");
static_assert(has_awesome_member<foo_void>::value,"");
static_assert(!has_awesome_member<wrong_params>::value,"");

লাইভ ডেমো (এক্সটেন্ডেড রিটার্ন টাইপ চেকিং এবং ভিসি ++ 2010 ওয়ার্কারাউন্ড সহ): http://cpp.sh/5b2vs

কোন উত্স, আমি নিজেকে সঙ্গে এসেছিলেন হিসাবে।

G ++ কম্পাইলারে লাইভ ডেমো চালানোর সময়, দয়া করে মনে রাখবেন যে 0 এর অ্যারে মাপ অনুমোদিত, অর্থাত যে static_assert ব্যবহৃত হয়, এটি ব্যর্থ হলে এমনকি একটি কম্পাইলার ত্রুটি ট্রিগার করবে না।
সাধারণভাবে ব্যবহৃত কাজটি প্রায় 'এক্সটার্ন' ম্যাক্রোতে 'টাইপডফ' প্রতিস্থাপন করা।


সি ++ 11 এর জন্য একটি সহজ সমাধান:

template<class T>
auto optionalToString(T* obj)
 -> decltype(  obj->toString()  )
{
    return     obj->toString();
}
auto optionalToString(...) -> string
{
    return "toString not defined";
}

আপডেট, 3 বছর পরে: (এবং এটি অনির্বাচিত)। অস্তিত্বের জন্য পরীক্ষা করার জন্য, আমি মনে করি এটি কাজ করবে:

template<class T>
constexpr auto test_has_toString_method(T* obj)
 -> decltype(  obj->toString() , std::true_type{} )
{
    return     obj->toString();
}
constexpr auto test_has_toString_method(...) -> std::false_type
{
    return "toString not defined";
}

সাধারণ সমস্যাটির জন্য এটি একটি সি ++ 11 সমাধান, যদি "আমি এক্স করি, এটি কম্পাইল হবে?"

template<class> struct type_sink { typedef void type; }; // consumes a type, and makes it `void`
template<class T> using type_sink_t = typename type_sink<T>::type;
template<class T, class=void> struct has_to_string : std::false_type {}; \
template<class T> struct has_to_string<
  T,
  type_sink_t< decltype( std::declval<T>().toString() ) >
>: std::true_type {};

Trait has_to_string যেমন has_to_string<T>::value যদি true হয় এবং শুধুমাত্র যদি T এর একটি পদ্ধতি থাকে। থেকে .toString যা এই প্রসঙ্গে 0 টি আর্গুমেন্ট সহ আহ্বান করা যেতে পারে।

পরবর্তী, আমি ট্যাগ প্রেরণ ব্যবহার করবো:

namespace details {
  template<class T>
  std::string optionalToString_helper(T* obj, std::true_type /*has_to_string*/) {
    return obj->toString();
  }
  template<class T>
  std::string optionalToString_helper(T* obj, std::false_type /*has_to_string*/) {
    return "toString not defined";
  }
}
template<class T>
std::string optionalToString(T* obj) {
  return details::optionalToString_helper( obj, has_to_string<T>{} );
}

যা জটিল SFINAE এক্সপ্রেশন বেশী রক্ষণযোগ্য হতে থাকে।

যদি আপনি নিজে নিজে এটি করছেন তবে আপনি এই বৈশিষ্ট্যগুলিকে একটি ম্যাক্রো দিয়ে লিখতে পারেন তবে তারা তুলনামূলকভাবে সহজ (প্রতিটি লাইন কয়েকটি) যাতে সম্ভবত এটি মূল্যহীন না হয়:

#define MAKE_CODE_TRAIT( TRAIT_NAME, ... ) \
template<class T, class=void> struct TRAIT_NAME : std::false_type {}; \
template<class T> struct TRAIT_NAME< T, type_sink_t< decltype( __VA_ARGS__ ) > >: std::true_type {};

MAKE_CODE_TRAIT কি একটি ম্যাক্রো MAKE_CODE_TRAIT তৈরি করে। আপনি এটির বৈশিষ্ট্যের নামটি আপনার কাছে প্রেরণ করেন এবং টাইপটি পরীক্ষা করতে পারেন এমন কিছু কোড। এভাবে:

MAKE_CODE_TRAIT( has_to_string, std::declval<T>().toString() )

উপরের বৈশিষ্ট্য ক্লাস তৈরি করে।

সরাইয়া হিসাবে, উপরের প্রযুক্তিটি এমএসকে "এক্সপ্রেশন SFINAE" বলে সম্বোধন করে, এবং তাদের ২013 সংকলকটি বেশ শক্ত করে ব্যর্থ হয়।

উল্লেখ্য যে C ++ 1y এ নিম্নলিখিত সিনট্যাক্স সম্ভব:

template<class T>
std::string optionalToString(T* obj) {
  return compiled_if< has_to_string >(*obj, [&](auto&& obj) {
    return obj.toString();
  }) *compiled_else ([&]{ 
    return "toString not defined";
  });
}

যা একটি ইনলাইন সংকলন শর্তাধীন শাখা যা প্রচুর সি ++ বৈশিষ্ট্যগুলি অপব্যবহার করে। এটি করার অর্থ সম্ভবত এটির মূল্য নয়, যেহেতু বেনিফিট (কোডটি ইনলাইন হচ্ছে) মূল্যের মূল্যহীন নয় (পরবর্তীতে কেউ এটি কীভাবে কাজ করে তা বুঝতে পারে না), তবে উপরের সমাধানটির অস্তিত্ব আগ্রহের হতে পারে।


আচ্ছা, এই প্রশ্নটি ইতিমধ্যে উত্তরগুলির একটি দীর্ঘ তালিকা আছে, তবে আমি মরভেনের মন্তব্যটি জোর দিতে চাই: সি ++ 17 এর প্রস্তাব রয়েছে যা এটি অনেক সহজ করে তোলে। বিস্তারিত N4502 জন্য N4502 দেখুন, কিন্তু একটি স্বনির্ধারিত উদাহরণ হিসাবে নিম্নলিখিত বিবেচনা।

এই অংশ ধ্রুব অংশ, একটি শিরোনাম এটি করা।

// See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4502.pdf.
template <typename...>
using void_t = void;

// Primary template handles all types not supporting the operation.
template <typename, template <typename> class, typename = void_t<>>
struct detect : std::false_type {};

// Specialization recognizes/validates only types supporting the archetype.
template <typename T, template <typename> class Op>
struct detect<T, Op, void_t<Op<T>>> : std::true_type {};

তারপরে পরিবর্তনশীল অংশ রয়েছে, যেখানে আপনি যা খুঁজছেন তা নির্দিষ্ট করুন (একটি ধরন, সদস্যের ধরন, একটি ফাংশন, সদস্য ফাংশন ইত্যাদি)। অপারেটিং সিস্টেমের ক্ষেত্রে:

template <typename T>
using toString_t = decltype(std::declval<T>().toString());

template <typename T>
using has_toString = detect<T, toString_t>;

N4502 থেকে নেওয়া নিম্নলিখিত উদাহরণটি আরও বিস্তৃত প্রোব দেখায়:

// Archetypal expression for assignment operation.
template <typename T>
using assign_t = decltype(std::declval<T&>() = std::declval<T const &>())

// Trait corresponding to that archetype.
template <typename T>
using is_assignable = detect<T, assign_t>;

উপরে বর্ণিত অন্যান্য বাস্তবায়নের তুলনায়, এটি একটি মোটামুটি সহজ: সরঞ্জামগুলির একটি হ্রাস করা সেট ( void_t এবং detect ) void_t , লোমশ ম্যাক্রোর কোন প্রয়োজন নেই। পাশাপাশি, এটি রিপোর্ট করা হয়েছে ( N4502 ) যে এটি পূর্ববর্তী পদ্ধতিগুলির চেয়ে পরিমাপযোগ্য (কম্পাইল-টাইম এবং কম্পাইলার মেমরি খরচ) পরিমাপযোগ্য।

এখানে একটি লাইভ উদাহরণ । এটি void_t সাথে সূক্ষ্ম কাজ করে, কিন্তু দুর্ভাগ্যবশত, 5.1 এর আগে GCC সংস্করণগুলি সি ++ 11 void_t একটি ভিন্ন ব্যাখ্যা অনুসরণ করে যা প্রত্যাশিত হিসাবে void_t কাজ করে না। ইয়াক্ক ইতিমধ্যে কাজের চারপাশে সরবরাহ করেছেন: void_t ( void_t প্যারামিটার তালিকায় কাজগুলি কিন্তু ফেরত টাইপ হিসাবে নয় ) এর নিম্নলিখিত সংজ্ঞাটি ব্যবহার করুন:

#if __GNUC__ < 5 && ! defined __clang__
// https://.com/a/28967049/1353549
template <typename...>
struct voider
{
  using type = void;
};
template <typename...Ts>
using void_t = typename voider<Ts...>::type;
#else
template <typename...>
using void_t = void;
#endif

আমারও একই সমস্যা ছিল:

একটি টেমপ্লেট ক্লাস যা কিছু বেস ক্লাস থেকে উদ্ভূত হতে পারে, এমন কিছু যা একটি নির্দিষ্ট সদস্য এবং অন্যরা না থাকে।

আমি এটি "টাইপফোফ" (নিকোলা বনেলির) এর উত্তরের অনুরূপ সমাধান করেছি, কিন্তু ডেলি টাইপের মাধ্যমে এটি এমএসভিএস-এ সঠিকভাবে কম্পাইল এবং রান করে:

#include <iostream>
#include <string>

struct Generic {};    
struct HasMember 
{
  HasMember() : _a(1) {};
  int _a;
};    

// SFINAE test
template <typename T>
class S : public T
{
public:
  std::string foo (std::string b)
  {
    return foo2<T>(b,0);
  }

protected:
  template <typename T> std::string foo2 (std::string b, decltype (T::_a))
  {
    return b + std::to_string(T::_a);
  }
  template <typename T> std::string foo2 (std::string b, ...)
  {
    return b + "No";
  }
};

int main(int argc, char *argv[])
{
  S<HasMember> d1;
  S<Generic> d2;

  std::cout << d1.foo("HasMember: ") << std::endl;
  std::cout << d2.foo("Generic: ") << std::endl;
  return 0;
}

C ++ এর জন্য SFINAE ব্যবহার করতে দেয় (লক্ষ্য করুন যে C ++ 11 বৈশিষ্ট্যগুলির সাথে এটি সহজতর কারণ এটি বর্ধিত SFINAE প্রায় আনুমানিক এক্সপ্রেশনগুলিতে সমর্থন করে - নীচে নিচের C ++ 03 কম্পাইলারগুলির সাথে কাজ করার জন্য তৈরি করা হয়েছে):

#define HAS_MEM_FUNC(func, name)                                        \
    template<typename T, typename Sign>                                 \
    struct name {                                                       \
        typedef char yes[1];                                            \
        typedef char no [2];                                            \
        template <typename U, U> struct type_check;                     \
        template <typename _1> static yes &chk(type_check<Sign, &_1::func > *); \
        template <typename   > static no  &chk(...);                    \
        static bool const value = sizeof(chk<T>(0)) == sizeof(yes);     \
    }

উপরে উল্লিখিত টেমপ্লেট এবং ম্যাক্রো একটি টেমপ্লেট তাত্ক্ষণিকভাবে চেষ্টা করে, এটি একটি সদস্য ফাংশন পয়েন্টার টাইপ, এবং প্রকৃত সদস্য ফাংশন পয়েন্টার প্রদান করে। যদি প্রকারগুলি উপযুক্ত না হয় তবে SFINAE টেমপ্লেটটিকে উপেক্ষা করা হতে পারে। এই মত ব্যবহার:

HAS_MEM_FUNC(toString, has_to_string);

template<typename T> void
doSomething() {
   if(has_to_string<T, std::string(T::*)()>::value) {
      ...
   } else {
      ...
   }
}

তবে মনে রাখবেন যে আপনি যদি সেই শাখা ফাংশনটি কল করতে না পারেন তবে শাখাটি। যেহেতু কম্পাইলার উভয় শাখায় বৈধতা যাচাই করবে, যে ক্ষেত্রে ফাংশন বিদ্যমান না ক্ষেত্রে ব্যর্থ হবে। এক উপায় আবার একবার SFINAE ব্যবহার করতে হয় (enable_if boost থেকেও অর্জিত হতে পারে):

template<bool C, typename T = void>
struct enable_if {
  typedef T type;
};

template<typename T>
struct enable_if<false, T> { };

HAS_MEM_FUNC(toString, has_to_string);

template<typename T> 
typename enable_if<has_to_string<T, 
                   std::string(T::*)()>::value, std::string>::type
doSomething(T * t) {
   /* something when T has toString ... */
   return t->toString();
}

template<typename T> 
typename enable_if<!has_to_string<T, 
                   std::string(T::*)()>::value, std::string>::type
doSomething(T * t) {
   /* something when T doesnt have toString ... */
   return "T::toString() does not exist.";
}

এটা ব্যবহার করে মজা আছে। এটির সুবিধা হল এটি ওভারলোড হওয়া সদস্য ফাংশনগুলির জন্য এবং কনস্ট সদস্য সদস্যের জন্যও কাজ করে ( std::string(T::*)() const ব্যবহার করে মনে রাখবেন সদস্য ফাংশন পয়েন্টার টাইপ হিসাবে!)।


MSVC এর __if_exists এবং __if_not_exists কীওয়ার্ড ( Doc ) আছে। নিকোলা এর টাইপফোফ-সফিনে পদ্ধতির সাথে আমি জিপিএস এবং এমএসভিসি-র জন্য একটি চেক তৈরি করতে পারি যেমন OP অপেক্ষায় ছিল।

আপডেট: উত্স Here পাওয়া যাবেHere


সনাক্তকরণ টুলকিট

N4502 সি ++ 17 স্ট্যান্ডার্ড লাইব্রেরির অন্তর্ভুক্তির জন্য একটি সনাক্তকরণ N4502 প্রস্তাব করে যা কিছুটা মার্জিতভাবে সমস্যার সমাধান করতে পারে। তাছাড়া, এটি কেবল লাইব্রেরি মৌলিক বিষয়গুলি TS v2 তে গৃহীত হয়েছে। এটি std::is_detected সহ কিছু std::is_detected যা এটি সহজে লিখতে টাইপ বা ফাংশন সনাক্তকরণ metafunctions লিখতে ব্যবহার করা যেতে পারে। এখানে আপনি কীভাবে এটি ব্যবহার করতে পারেন:

template<typename T>
using toString_t = decltype( std::declval<T&>().toString() );

template<typename T>
constexpr bool has_toString = std::is_detected_v<toString_t, T>;

উল্লেখ্য যে উপরে উল্লিখিত উদাহরণ নেই। সনাক্তকরণ টুলকিটটি এখনও আদর্শ লাইব্রেরিগুলিতে উপলব্ধ নয় তবে প্রস্তাবটি সম্পূর্ণ বাস্তবায়ন রয়েছে যা আপনি যদি সত্যিই এটির প্রয়োজনে সহজেই অনুলিপি করতে পারেন। if constexpr + 17 বৈশিষ্ট্যটি if constexpr :

template<class T>
std::string optionalToString(T* obj)
{
    if constexpr (has_toString<T>)
        return obj->toString();
    else
        return "toString not defined";
}

Boost.TTI

আরও কিছুটা ছদ্মবেশী টুলকিট যেমন একটি পরীক্ষা সঞ্চালন করতে - এমনকি কম মার্জিত - Boost.TTI , বুস্ট 1.54.0 এ উপস্থাপিত। আপনার উদাহরণের জন্য, আপনাকে ম্যাক্রো BOOST_TTI_HAS_MEMBER_FUNCTION ব্যবহার করতে হবে। এখানে আপনি কীভাবে এটি ব্যবহার করতে পারেন:

#include <boost/tti/has_member_function.hpp>

// Generate the metafunction
BOOST_TTI_HAS_MEMBER_FUNCTION(toString)

// Check whether T has a member function toString
// which takes no parameter and returns a std::string
constexpr bool foo = has_member_function_toString<T, std::string>::value;

তারপর, আপনি একটি SFINAE চেক তৈরি করতে bool ব্যবহার করতে পারে।

ব্যাখ্যা

ম্যাক্রো BOOST_TTI_HAS_MEMBER_FUNCTION তৈরি has_member_function_toString যা চেক has_member_function_toString তার প্রথম টেম্পলেট প্যারামিটার হিসাবে নেয়। দ্বিতীয় টেমপ্লেট প্যারামিটার সদস্য ফাংশনের রিটার্ন টাইপের সাথে সংশ্লিষ্ট, এবং নিম্নলিখিত পরামিতি ফাংশনের প্যারামিটারগুলির সাথে সম্পর্কিত। ক্লাস T সদস্যের std::string toString() থাকলে সদস্যের value true থাকে।

বিকল্পভাবে, has_member_function_toString একটি ফাংশন পয়েন্টারকে টেমপ্লেট প্যারামিটার হিসাবে গ্রহণ করতে পারে। অতএব, has_member_function_toString<T, std::string>::value has_member_function_toString<std::string T::* ()>::value দ্বারা প্রতিস্থাপন করা সম্ভব।


এখন এটি একটি চমৎকার সামান্য ধাঁধা ছিল - মহান প্রশ্ন!

এখানে নিকোলা বোনেলির সমাধানের বিকল্প যা অ-মানক typeofঅপারেটরের উপর নির্ভর করে না ।

দুর্ভাগ্যবশত, এটি GCC (MINGW) 3.4.5 বা ডিজিটাল মঙ্গল 8.42n তে কাজ করে না, তবে এটি MSVC এর সমস্ত সংস্করণগুলিতে (ভিসি 6 সহ) এবং কমও সি ++ এ কাজ করে।

আর মন্তব্য ব্লকটি কীভাবে কাজ করে (বা কাজ করার অনুমিত) তার বিশদ বিবরণ রয়েছে। যেমনটা বলে, আমি নিশ্চিত নই যে কোন আচরণ মানসম্পন্ন হয় - আমি তার উপর ভাষ্য স্বাগত জানাই।

আপডেট - 7 নভেম্বর 2008:

মনে হচ্ছে এটির কোডটি সংশ্লেষিকভাবে সঠিক, এমএসভিসি এবং কামাউ সি ++ শো এমন আচরণকে অনুসরণ করে না ( litbটিমার্মান এবং litb সঠিক দিক নির্দেশ করার জন্য ধন্যবাদ )। সি ++ 03 স্ট্যান্ডার্ড নিম্নলিখিত বলে:

14.6.2 নির্ভরশীল নাম [temp.dep]

অনুচ্ছেদ 3

ক্লাসের টেমপ্লেট বা ক্লাসের টেমপ্লেটের সদস্যের সংজ্ঞাতে, যদি ক্লাস টেমপ্লেটটির বেস বর্গ একটি টেমপ্লেট-পরামিতির উপর নির্ভর করে তবে বর্গ শ্রেণীর সুযোগটি যাচাইযোগ্য নাম সন্ধানের সময় ক্লাসের সংজ্ঞা অনুসারে পরীক্ষা করা হয় না টেমপ্লেট বা সদস্য বা ক্লাস টেম্পলেট বা সদস্য একটি তাত্ক্ষণিক সময়।

সুতরাং, মনে হচ্ছে যে যখন এমএমভিসি বা কমেও যখন টেম্পলেটটিকে তাত্ক্ষণিক করে তখন কল সাইটটিতে নাম সন্ধান করার toString()সদস্যের ফাংশন বিবেচনা করে T, doToString()তখন এটি ভুল (যদিও এটি প্রকৃতপক্ষে আমি এই ক্ষেত্রে যা খুঁজছি তা)।

জি সি সি এবং ডিজিটাল মঙ্গলের আচরণ সঠিক বলে মনে হচ্ছে - উভয় ক্ষেত্রেই নন-সদস্য toString()ফাংশন কলটিতে আবদ্ধ।

ইঁদুর - আমি ভেবেছিলাম আমি একটি চতুর সমাধান খুঁজে পেয়েছি, পরিবর্তে আমি একটি দম্পতি কম্পাইলার বাগ উন্মোচিত ...

#include <iostream>
#include <string>

struct Hello
{
    std::string toString() {
        return "Hello";
    }
};

struct Generic {};


// the following namespace keeps the toString() method out of
//  most everything - except the other stuff in this
//  compilation unit

namespace {
    std::string toString()
    {
        return "toString not defined";
    }

    template <typename T>
    class optionalToStringImpl : public T
    {
    public:
        std::string doToString() {

            // in theory, the name lookup for this call to 
            //  toString() should find the toString() in 
            //  the base class T if one exists, but if one 
            //  doesn't exist in the base class, it'll 
            //  find the free toString() function in 
            //  the private namespace.
            //
            // This theory works for MSVC (all versions
            //  from VC6 to VC9) and Comeau C++, but
            //  does not work with MinGW 3.4.5 or 
            //  Digital Mars 8.42n
            //
            // I'm honestly not sure what the standard says 
            //  is the correct behavior here - it's sort 
            //  of like ADL (Argument Dependent Lookup - 
            //  also known as Koenig Lookup) but without
            //  arguments (except the implied "this" pointer)

            return toString();
        }
    };
}

template <typename T>
std::string optionalToString(T & obj)
{
    // ugly, hacky cast...
    optionalToStringImpl<T>* temp = reinterpret_cast<optionalToStringImpl<T>*>( &obj);

    return temp->doToString();
}



int
main(int argc, char *argv[])
{
    Hello helloObj;
    Generic genericObj;

    std::cout << optionalToString( helloObj) << std::endl;
    std::cout << optionalToString( genericObj) << std::endl;
    return 0;
}

যদিও এই প্রশ্নটি দুই বছর বয়সী, আমি আমার উত্তর যোগ করার সাহস করব। আশা করি এটি পূর্ববর্তী, নির্বোধ চমৎকার, সমাধান ব্যাখ্যা করবে। আমি নিকোলা বোনেলি এবং জোহানেস শ্যাবের খুব সহায়ক উত্তরগুলি গ্রহণ করেছি এবং তাদের একটি সমাধান হিসাবে মিশিয়েছি, যা IMHO, আরও পঠনযোগ্য, স্পষ্ট এবং typeof এক্সটেনশানের প্রয়োজন হয় না:

template <class Type>
class TypeHasToString
{
    // This type won't compile if the second template parameter isn't of type T,
    // so I can put a function pointer type in the first parameter and the function
    // itself in the second thus checking that the function has a specific signature.
    template <typename T, T> struct TypeCheck;

    typedef char Yes;
    typedef long No;

    // A helper struct to hold the declaration of the function pointer.
    // Change it if the function signature changes.
    template <typename T> struct ToString
    {
        typedef void (T::*fptr)();
    };

    template <typename T> static Yes HasToString(TypeCheck< typename ToString<T>::fptr, &T::toString >*);
    template <typename T> static No  HasToString(...);

public:
    static bool const value = (sizeof(HasToString<Type>(0)) == sizeof(Yes));
};

আমি gcc 4.1.2 সঙ্গে এটি চেক। ক্রেডিট প্রধানত নিকোলা বোনেলি এবং জোহানেস শাউবের কাছে যায়, তাই যদি আমার উত্তর আপনাকে সাহায্য করে তবে তাদের ভোট দিতে দিন :)


অদ্ভুত কেউ এই সাইটে খুব একবার দেখেছেন যে নিম্নলিখিত চমৎকার কৌশল:

template <class T>
struct has_foo
{
    struct S { void foo(...); };
    struct derived : S, T {};

    template <typename V, V> struct W {};

    template <typename X>
    char (&test(W<void (X::*)(), &X::foo> *))[1];

    template <typename>
    char (&test(...))[2];

    static const bool value = sizeof(test<derived>(0)) == 1;
};

আপনি নিশ্চিত যে টি টি একটি বর্গ। মনে হচ্ছে Foo সন্ধানে অস্পষ্টতা একটি প্রতিস্থাপন ব্যর্থতা। আমি এটা GCC কাজ করে, যদিও এটা মান যদিও নিশ্চিত না।


একটি Has_fooধারণা চেক করে SFINAE এবং টেমপ্লেট আংশিক বিশেষজ্ঞ ব্যবহার করে একটি উদাহরণ :

#include <type_traits>
struct A{};

struct B{ int foo(int a, int b);};

struct C{void foo(int a, int b);};

struct D{int foo();};

struct E: public B{};

// available in C++17 onwards as part of <type_traits>
template<typename...>
using void_t = void;

template<typename T, typename = void> struct Has_foo: std::false_type{};

template<typename T> 
struct Has_foo<T, void_t<
    std::enable_if_t<
        std::is_same<
            int, 
            decltype(std::declval<T>().foo((int)0, (int)0))
        >::value
    >
>>: std::true_type{};


static_assert(not Has_foo<A>::value, "A does not have a foo");
static_assert(Has_foo<B>::value, "B has a foo");
static_assert(not Has_foo<C>::value, "C has a foo with the wrong return. ");
static_assert(not Has_foo<D>::value, "D has a foo with the wrong arguments. ");
static_assert(Has_foo<E>::value, "E has a foo since it inherits from B");

আমি https://.com/a/264088/2712152 প্রদত্ত সমাধানটি একটু বেশি সাধারণ করতে সংশোধন করেছি। যেহেতু এটি নতুন সি ++ 11 বৈশিষ্ট্যগুলি ব্যবহার করে না তাই আমরা পুরানো কম্পাইলারগুলির সাথে এটি ব্যবহার করতে পারি এবং এমএসভিসি-এর সাথেও কাজ করতে হবে। কিন্তু কম্পাইলারগুলি সি 99 ব্যবহার করতে সক্ষম হওয়া উচিত কারণ এটি ভেরিয়েডিক ম্যাক্রো ব্যবহার করে।

নিচের ম্যাক্রো ব্যবহার করা যেতে পারে কিনা কোন বিশেষ শ্রেণীর নির্দিষ্ট টাইপডেফ আছে কিনা তা যাচাই করতে।

/** 
 * @class      : HAS_TYPEDEF
 * @brief      : This macro will be used to check if a class has a particular
 * typedef or not.
 * @param typedef_name : Name of Typedef
 * @param name  : Name of struct which is going to be run the test for
 * the given particular typedef specified in typedef_name
 */
#define HAS_TYPEDEF(typedef_name, name)                           \
   template <typename T>                                          \
   struct name {                                                  \
      typedef char yes[1];                                        \
      typedef char no[2];                                         \
      template <typename U>                                       \
      struct type_check;                                          \
      template <typename _1>                                      \
      static yes& chk(type_check<typename _1::typedef_name>*);    \
      template <typename>                                         \
      static no& chk(...);                                        \
      static bool const value = sizeof(chk<T>(0)) == sizeof(yes); \
   }

নির্দিষ্ট ম্যাক্রো কোন নির্দিষ্ট সদস্যের কোনো নির্দিষ্ট সংখ্যক আর্গুমেন্টের সাথে কাজ করে কিনা তা পরীক্ষা করার জন্য ব্যবহার করা যেতে পারে।

/** 
 * @class      : HAS_MEM_FUNC
 * @brief      : This macro will be used to check if a class has a particular
 * member function implemented in the public section or not. 
 * @param func : Name of Member Function
 * @param name : Name of struct which is going to be run the test for
 * the given particular member function name specified in func
 * @param return_type: Return type of the member function
 * @param ellipsis(...) : Since this is macro should provide test case for every
 * possible member function we use variadic macros to cover all possibilities
 */
#define HAS_MEM_FUNC(func, name, return_type, ...)                \
   template <typename T>                                          \
   struct name {                                                  \
      typedef return_type (T::*Sign)(__VA_ARGS__);                \
      typedef char yes[1];                                        \
      typedef char no[2];                                         \
      template <typename U, U>                                    \
      struct type_check;                                          \
      template <typename _1>                                      \
      static yes& chk(type_check<Sign, &_1::func>*);              \
      template <typename>                                         \
      static no& chk(...);                                        \
      static bool const value = sizeof(chk<T>(0)) == sizeof(yes); \
   }

আমরা has_typedef এবং has_mem_func এর জন্য চেকগুলি সম্পাদন করতে উপরের 2 ম্যাক্রোগুলি ব্যবহার করতে পারি:

class A {
public:
  typedef int check;
  void check_function() {}
};

class B {
public:
  void hello(int a, double b) {}
  void hello() {}
};

HAS_MEM_FUNC(check_function, has_check_function, void, void);
HAS_MEM_FUNC(hello, hello_check, void, int, double);
HAS_MEM_FUNC(hello, hello_void_check, void, void);
HAS_TYPEDEF(check, has_typedef_check);

int main() {
  std::cout << "Check Function A:" << has_check_function<A>::value << std::endl;
  std::cout << "Check Function B:" << has_check_function<B>::value << std::endl;
  std::cout << "Hello Function A:" << hello_check<A>::value << std::endl;
  std::cout << "Hello Function B:" << hello_check<B>::value << std::endl;
  std::cout << "Hello void Function A:" << hello_void_check<A>::value << std::endl;
  std::cout << "Hello void Function B:" << hello_void_check<B>::value << std::endl;
  std::cout << "Check Typedef A:" << has_typedef_check<A>::value << std::endl;
  std::cout << "Check Typedef B:" << has_typedef_check<B>::value << std::endl;
}

কিভাবে এই সমাধান সম্পর্কে?

#include <type_traits>

template <typename U, typename = void> struct hasToString : std::false_type { };

template <typename U>
struct hasToString<U,
  typename std::enable_if<bool(sizeof(&U::toString))>::type
> : std::true_type { };

কিছু "বৈশিষ্ট্য" টাইপ দ্বারা সমর্থিত কিনা তা পরীক্ষা করার জন্য জেনারিক টেমপ্লেটটি ব্যবহার করা যেতে পারে:

#include <type_traits>

template <template <typename> class TypeChecker, typename Type>
struct is_supported
{
    // these structs are used to recognize which version
    // of the two functions was chosen during overload resolution
    struct supported {};
    struct not_supported {};

    // this overload of chk will be ignored by SFINAE principle
    // if TypeChecker<Type_> is invalid type
    template <typename Type_>
    static supported chk(typename std::decay<TypeChecker<Type_>>::type *);

    // ellipsis has the lowest conversion rank, so this overload will be
    // chosen during overload resolution only if the template overload above is ignored
    template <typename Type_>
    static not_supported chk(...);

    // if the template overload of chk is chosen during
    // overload resolution then the feature is supported
    // if the ellipses overload is chosen the the feature is not supported
    static constexpr bool value = std::is_same<decltype(chk<Type>(nullptr)),supported>::value;
};

fooস্বাক্ষর সঙ্গে সামঞ্জস্যপূর্ণ একটি পদ্ধতি আছে কিনা পরীক্ষা করে যে টেমপ্লেটdouble(const char*)

// if T doesn't have foo method with the signature that allows to compile the bellow
// expression then instantiating this template is Substitution Failure (SF)
// which Is Not An Error (INAE) if this happens during overload resolution
template <typename T>
using has_foo = decltype(double(std::declval<T>().foo(std::declval<const char*>())));

উদাহরণ

// types that support has_foo
struct struct1 { double foo(const char*); };            // exact signature match
struct struct2 { int    foo(const std::string &str); }; // compatible signature
struct struct3 { float  foo(...); };                    // compatible ellipsis signature
struct struct4 { template <typename T>
                 int    foo(T t); };                    // compatible template signature

// types that do not support has_foo
struct struct5 { void        foo(const char*); }; // returns void
struct struct6 { std::string foo(const char*); }; // std::string can't be converted to double
struct struct7 { double      foo(      int *); }; // const char* can't be converted to int*
struct struct8 { double      bar(const char*); }; // there is no foo method

int main()
{
    std::cout << std::boolalpha;

    std::cout << is_supported<has_foo, int    >::value << std::endl; // false
    std::cout << is_supported<has_foo, double >::value << std::endl; // false

    std::cout << is_supported<has_foo, struct1>::value << std::endl; // true
    std::cout << is_supported<has_foo, struct2>::value << std::endl; // true
    std::cout << is_supported<has_foo, struct3>::value << std::endl; // true
    std::cout << is_supported<has_foo, struct4>::value << std::endl; // true

    std::cout << is_supported<has_foo, struct5>::value << std::endl; // false
    std::cout << is_supported<has_foo, struct6>::value << std::endl; // false
    std::cout << is_supported<has_foo, struct7>::value << std::endl; // false
    std::cout << is_supported<has_foo, struct8>::value << std::endl; // false

    return 0;
}

http://coliru.stacked-crooked.com/a/83c6a631ed42cea4


আমি অন্য একটি থ্রেডে এই উত্তরটি লিখেছিলাম যে (উপরের সমাধানগুলির বিপরীতে) উত্তরাধিকারসূত্রে সদস্যের ফাংশনগুলি চেক করে:

SFINAE উত্তরাধিকারী সদস্য ফাংশন জন্য চেক

এখানে যে সমাধান থেকে কিছু উদাহরণ:

Example1:

আমরা নিম্নলিখিত স্বাক্ষর সঙ্গে একটি সদস্য জন্য চেক করা হয়: T::const_iterator begin() const

template<class T> struct has_const_begin
{
    typedef char (&Yes)[1];
    typedef char (&No)[2];

    template<class U> 
    static Yes test(U const * data, 
                    typename std::enable_if<std::is_same<
                             typename U::const_iterator, 
                             decltype(data->begin())
                    >::value>::type * = 0);
    static No test(...);
    static const bool value = sizeof(Yes) == sizeof(has_const_begin::test((typename std::remove_reference<T>::type*)0));
};

অনুগ্রহ করে লক্ষ্য করুন যে এটি এমনকি পদ্ধতির সংশ্লেষ পরীক্ষা করে এবং আদিম প্রকারের সাথেও কাজ করে। (আমি has_const_begin<int>::valueমিথ্যা বলি এবং কম্পাইল-টাইম ত্রুটি সৃষ্টি করে না।)

উদাহরণ 2

এখন আমরা স্বাক্ষর খুঁজছেন: void foo(MyClass&, unsigned)

template<class T> struct has_foo
{
    typedef char (&Yes)[1];
    typedef char (&No)[2];

    template<class U>
    static Yes test(U * data, MyClass* arg1 = 0,
                    typename std::enable_if<std::is_void<
                             decltype(data->foo(*arg1, 1u))
                    >::value>::type * = 0);
    static No test(...);
    static const bool value = sizeof(Yes) == sizeof(has_foo::test((typename std::remove_reference<T>::type*)0));
};

দয়া করে লক্ষ্য করুন যে MyClass ডিফল্ট গঠনযোগ্য বা কোন বিশেষ ধারণা সন্তুষ্ট করতে হবে না। কৌশল পাশাপাশি টেমপ্লেট সদস্যদের সাথে কাজ করে।

আমি আগ্রহীভাবে এই বিষয়ে মতামত অপেক্ষা করছি।


template<class T>
auto optionalToString(T* obj)
->decltype( obj->toString(), std::string() )
{
     return obj->toString();
}

template<class T>
auto optionalToString(T* obj)
->decltype( std::string() )
{
     throw "Error!";
}

এই জন্য কি ধরণের বৈশিষ্ট্য আছে। দুর্ভাগ্যবশত, তারা ম্যানুয়ালি সংজ্ঞায়িত করা আছে। আপনার ক্ষেত্রে, কল্পনা করুন:

template <typename T>
struct response_trait {
    static bool const has_tostring = false;
};

template <>
struct response_trait<your_type_with_tostring> {
    static bool const has_tostring = true;
}

এখানে আমার সংস্করণটি যা সকল সম্ভাব্য সদস্য ফাংশন ওভারলোডগুলিকে ইচ্ছাকৃতভাবে সীমাবদ্ধ করে, টেমপ্লেট সদস্য ফাংশন সহ, সম্ভবত ডিফল্ট আর্গুমেন্ট সহ। প্রদত্ত আর্গের ধরনগুলির সাথে সদস্যের ফাংশন কল করার সময় এটি 3 পারস্পরিক একচেটিয়া পরিস্থিতিগুলিকে আলাদা করে: (1) বৈধ, বা (2) দ্বিধাবোধক, বা (3) অ-কার্যকর। উদাহরণ ব্যবহার:

#include <string>
#include <vector>

HAS_MEM(bar)
HAS_MEM_FUN_CALL(bar)

struct test
{
   void bar(int);
   void bar(double);
   void bar(int,double);

   template < typename T >
   typename std::enable_if< not std::is_integral<T>::value >::type
   bar(const T&, int=0){}

   template < typename T >
   typename std::enable_if< std::is_integral<T>::value >::type
   bar(const std::vector<T>&, T*){}

   template < typename T >
   int bar(const std::string&, int){}
};

এখন আপনি এটি ব্যবহার করতে পারেন:

int main(int argc, const char * argv[])
{
   static_assert( has_mem_bar<test>::value , "");

   static_assert( has_valid_mem_fun_call_bar<test(char const*,long)>::value , "");
   static_assert( has_valid_mem_fun_call_bar<test(std::string&,long)>::value , "");

   static_assert( has_valid_mem_fun_call_bar<test(std::vector<int>, int*)>::value , "");
   static_assert( has_no_viable_mem_fun_call_bar<test(std::vector<double>, double*)>::value , "");

   static_assert( has_valid_mem_fun_call_bar<test(int)>::value , "");
   static_assert( std::is_same<void,result_of_mem_fun_call_bar<test(int)>::type>::value , "");

   static_assert( has_valid_mem_fun_call_bar<test(int,double)>::value , "");
   static_assert( not has_valid_mem_fun_call_bar<test(int,double,int)>::value , "");

   static_assert( not has_ambiguous_mem_fun_call_bar<test(double)>::value , "");
   static_assert( has_ambiguous_mem_fun_call_bar<test(unsigned)>::value , "");

   static_assert( has_viable_mem_fun_call_bar<test(unsigned)>::value , "");
   static_assert( has_viable_mem_fun_call_bar<test(int)>::value , "");

   static_assert( has_no_viable_mem_fun_call_bar<test(void)>::value , "");

   return 0;
}

এখানে সি ++ 11 এ লেখা কোডটি রয়েছে, তবে আপনি সহজেই এটি (ছোটখাট টুইভগুলি সহ) অ-সি ++ 11 এ পোর্ট করতে পারেন যা টাইপ এক্সটেনশানগুলির (যেমন GCC) থাকে। আপনি নিজের সাথে HAS_MEM ম্যাক্রো প্রতিস্থাপন করতে পারেন।

#pragma once

#if __cplusplus >= 201103

#include <utility>
#include <type_traits>

#define HAS_MEM(mem)                                                                                     \
                                                                                                     \
template < typename T >                                                                               \
struct has_mem_##mem                                                                                  \
{                                                                                                     \
  struct yes {};                                                                                     \
  struct no  {};                                                                                     \
                                                                                                     \
  struct ambiguate_seed { char mem; };                                                               \
  template < typename U > struct ambiguate : U, ambiguate_seed {};                                   \
                                                                                                     \
  template < typename U, typename = decltype(&U::mem) > static constexpr no  test(int);              \
  template < typename                                 > static constexpr yes test(...);              \
                                                                                                     \
  static bool constexpr value = std::is_same<decltype(test< ambiguate<T> >(0)),yes>::value ;         \
  typedef std::integral_constant<bool,value>    type;                                                \
};


#define HAS_MEM_FUN_CALL(memfun)                                                                         \
                                                                                                     \
template < typename Signature >                                                                       \
struct has_valid_mem_fun_call_##memfun;                                                               \
                                                                                                     \
template < typename T, typename... Args >                                                             \
struct has_valid_mem_fun_call_##memfun< T(Args...) >                                                  \
{                                                                                                     \
  struct yes {};                                                                                     \
  struct no  {};                                                                                     \
                                                                                                     \
  template < typename U, bool = has_mem_##memfun<U>::value >                                         \
  struct impl                                                                                        \
  {                                                                                                  \
     template < typename V, typename = decltype(std::declval<V>().memfun(std::declval<Args>()...)) > \
     struct test_result { using type = yes; };                                                       \
                                                                                                     \
     template < typename V > static constexpr typename test_result<V>::type test(int);               \
     template < typename   > static constexpr                            no test(...);               \
                                                                                                     \
     static constexpr bool value = std::is_same<decltype(test<U>(0)),yes>::value;                    \
     using type = std::integral_constant<bool, value>;                                               \
  };                                                                                                 \
                                                                                                     \
  template < typename U >                                                                            \
  struct impl<U,false> : std::false_type {};                                                         \
                                                                                                     \
  static constexpr bool value = impl<T>::value;                                                      \
  using type = std::integral_constant<bool, value>;                                                  \
};                                                                                                    \
                                                                                                     \
template < typename Signature >                                                                       \
struct has_ambiguous_mem_fun_call_##memfun;                                                           \
                                                                                                     \
template < typename T, typename... Args >                                                             \
struct has_ambiguous_mem_fun_call_##memfun< T(Args...) >                                              \
{                                                                                                     \
  struct ambiguate_seed { void memfun(...); };                                                       \
                                                                                                     \
  template < class U, bool = has_mem_##memfun<U>::value >                                            \
  struct ambiguate : U, ambiguate_seed                                                               \
  {                                                                                                  \
    using ambiguate_seed::memfun;                                                                    \
    using U::memfun;                                                                                 \
  };                                                                                                 \
                                                                                                     \
  template < class U >                                                                               \
  struct ambiguate<U,false> : ambiguate_seed {};                                                     \
                                                                                                     \
  static constexpr bool value = not has_valid_mem_fun_call_##memfun< ambiguate<T>(Args...) >::value; \
  using type = std::integral_constant<bool, value>;                                                  \
};                                                                                                    \
                                                                                                     \
template < typename Signature >                                                                       \
struct has_viable_mem_fun_call_##memfun;                                                              \
                                                                                                     \
template < typename T, typename... Args >                                                             \
struct has_viable_mem_fun_call_##memfun< T(Args...) >                                                 \
{                                                                                                     \
  static constexpr bool value = has_valid_mem_fun_call_##memfun<T(Args...)>::value                   \
                             or has_ambiguous_mem_fun_call_##memfun<T(Args...)>::value;              \
  using type = std::integral_constant<bool, value>;                                                  \
};                                                                                                    \
                                                                                                     \
template < typename Signature >                                                                       \
struct has_no_viable_mem_fun_call_##memfun;                                                           \
                                                                                                     \
template < typename T, typename... Args >                                                             \
struct has_no_viable_mem_fun_call_##memfun < T(Args...) >                                             \
{                                                                                                     \
  static constexpr bool value = not has_viable_mem_fun_call_##memfun<T(Args...)>::value;             \
  using type = std::integral_constant<bool, value>;                                                  \
};                                                                                                    \
                                                                                                     \
template < typename Signature >                                                                       \
struct result_of_mem_fun_call_##memfun;                                                               \
                                                                                                     \
template < typename T, typename... Args >                                                             \
struct result_of_mem_fun_call_##memfun< T(Args...) >                                                  \
{                                                                                                     \
  using type = decltype(std::declval<T>().memfun(std::declval<Args>()...));                          \
};

#endif

এখানে কাজের কোড একটি উদাহরণ।

template<typename T>
using toStringFn = decltype(std::declval<const T>().toString());

template <class T, toStringFn<T>* = nullptr>
std::string optionalToString(const T* obj, int)
{
    return obj->toString();
}

template <class T>
std::string optionalToString(const T* obj, long)
{
    return "toString not defined";
}

int main()
{
    A* a;
    B* b;

    std::cout << optionalToString(a, 0) << std::endl; // This is A
    std::cout << optionalToString(b, 0) << std::endl; // toString not defined
}

toStringFn<T>* = nullptrফাংশন যা অতিরিক্ত লাগে সক্ষম করবে intআমার যুক্তি, যা ফাংশন যা লাগে উপর একটি অগ্রাধিকার আছে longযখন সাথে কল 0

trueফাংশন বাস্তবায়িত হলে ফাংশনগুলির জন্য আপনি একই নীতি ব্যবহার করতে পারেন ।

template <typename T>
constexpr bool toStringExists(long)
{
    return false;
}

template <typename T, toStringFn<T>* = nullptr>
constexpr bool toStringExists(int)
{
    return true;
}


int main()
{
    A* a;
    B* b;

    std::cout << toStringExists<A>(0) << std::endl; // true
    std::cout << toStringExists<B>(0) << std::endl; // false
}




sfinae