আধুনিক সি ++ 11 / সি ++ 14 / সি ++ 17 এবং ভবিষ্যতের সি ++ 20 এ স্ট্রিং এ এনাম


354

অন্যান্য সমস্ত অনুরূপ প্রশ্নের বিপরীতে, এই প্রশ্নটি নতুন সি ++ বৈশিষ্ট্যগুলি ব্যবহার সম্পর্কে।

অনেক উত্তর পড়ার পরেও আমি এখনও কোনও খুঁজে পাইনি:

  • সি ++ 11 , সি ++ 14 বা সি ++ 17 নতুন বৈশিষ্ট্যগুলি ব্যবহার করে মার্জিত উপায়ে
  • বা বুস্টে ব্যবহারের জন্য প্রস্তুত কিছু
  • C ++ 20 এর জন্য অন্য কিছু পরিকল্পনা করা হয়েছে

উদাহরণ

দীর্ঘ বিবরণের চেয়ে একটি উদাহরণ প্রায়শই ভাল।
আপনি কলিরুতে এই স্নিপেটটি সংকলন এবং চালনা করতে পারেন ।
( অন্য একটি পূর্ববর্তী উদাহরণও পাওয়া যায়)

#include <map>
#include <iostream>

struct MyClass
{
    enum class MyEnum : char {
        AAA = -8,
        BBB = '8',
        CCC = AAA + BBB
    };
};

// Replace magic() by some faster compile-time generated code
// (you're allowed to replace the return type with std::string
// if that's easier for you)
const char* magic (MyClass::MyEnum e)
{
    const std::map<MyClass::MyEnum,const char*> MyEnumStrings {
        { MyClass::MyEnum::AAA, "MyClass::MyEnum::AAA" },
        { MyClass::MyEnum::BBB, "MyClass::MyEnum::BBB" },
        { MyClass::MyEnum::CCC, "MyClass::MyEnum::CCC" }
    };
    auto   it  = MyEnumStrings.find(e);
    return it == MyEnumStrings.end() ? "Out of range" : it->second;
}

int main()
{
   std::cout << magic(MyClass::MyEnum::AAA) <<'\n';
   std::cout << magic(MyClass::MyEnum::BBB) <<'\n';
   std::cout << magic(MyClass::MyEnum::CCC) <<'\n';
}

সীমাবদ্ধতাসমূহ

  • অন্যান্য উত্তর বা মৌলিক লিঙ্কের কোন মূল্যহীন সদৃশ ।
  • দয়া করে ফোলা ম্যাক্রো-ভিত্তিক উত্তর এড়িয়ে চলুন, বা #defineযতটা সম্ভব নূন্যতম ওভারহেড হ্রাস করার চেষ্টা করুন ।
  • দয়া করে কোনও ম্যানুয়াল enum-> stringম্যাপিং নেই।

আছে চমৎকার

  • enumশূন্য থেকে পৃথক সংখ্যা থেকে শুরু হওয়া সমর্থন মান
  • নেতিবাচক enumমানগুলিকে সমর্থন করুন
  • খণ্ডিত enumমানগুলিকে সমর্থন করুন
  • সমর্থন class enum(সি ++ 11)
  • class enum : <type>যে কোনও অনুমোদিত থাকার সমর্থন <type>(সি ++ 11)
  • সংকলন-সময় (রান-টাইম নয়) একটি স্ট্রিংতে রূপান্তরকরণ,
    বা রান-টাইমে অন্তত দ্রুত সম্পাদন (যেমন std::mapকোনও দুর্দান্ত ধারণা নয় ...)
  • constexpr (সি ++ ১১, তারপরে সি ++ 14/17/20 এ শিথিল)
  • noexcept (সি ++ 11)
  • সি ++ 17 / সি ++ 20 বন্ধুত্বপূর্ণ স্নিপেট

একটি সম্ভাব্য ধারণা হ'ল সংকলন সময়ে সি ++ কোড উত্পন্ন করতে সি ++ সংকলক ক্ষমতা ব্যবহার করে মেটা-প্রোগ্রামিং কৌশলগুলি variadic template classএবং constexprফাংশনগুলির উপর ভিত্তি করে ...


4
(সম্ভবত-বিষয়) এই কিউটি সম্পর্কিত ব্লগটি দেখুন। woboq.com/blog/reflection-in-cpp-and-qt-moc.html । সি ++ রিফ্লেকশন (প্রস্তাবিত মান) ব্যবহার করে কিউটির মক (মেটা-অবজেক্ট-সংকলক) প্রতিস্থাপনের সম্ভাবনা বর্ণনা করে।
ইব্রে 5041

10
N4113 :std::enumerator::identifier_v<MyEnum, MyEnum::AAA>
ইকামত্মার

1
আমি ব্যক্তিগতভাবে এই সমস্যাটি একটি ছোট প্রিপ্রোসেসর ইউটিলিটি লাইব্রেরি প্রয়োগ করে সমাধান করেছি যা আমাকে ভ্যারিয়েডিক ম্যাক্রো যুক্তিগুলি লুপ করতে এবং সেগুলির উপরে একটি কার্য সম্পাদন করতে দেয়। আমি এনাম মানগুলিকে ম্যাক্রো আর্গুমেন্ট হিসাবে পাস করি এবং আমি স্বয়ংক্রিয়ভাবে প্রিমোসেসরের মাধ্যমে এনাম এবং স্ট্রিং অ্যারে উত্পন্ন করি। আপনি সম্ভবত বুস্ট প্রিপ্রেসেসর ব্যবহার করে এটি করতে পারেন।
ভিটোরিও রোমিও

2
সব কি সি ++ দিয়ে সমাধান করতে হবে? স্ট্রিং প্রতিনিধিত্বের জন্য কোডটি কেবল কয়েক লাইনের স্বয়ংক্রিয়ভাবে কোড উত্পন্ন করা এত সহজ।
করলি হরভথ

2
ভাল "দয়া করে, সম্ভব হলে সি ম্যাক্রো-ভিত্তিক উত্তর না", যদি না আপনি সি জন্য অপেক্ষা করতে ইচ্ছুক ++, 17 সেখানে কষ্টসহকারে কিছু ব্যবহারযোগ্য, এবং এটা নয় যে খারাপ আপনার enums ডিক্লেয়ার যেমন DEC_ENUM(enumname, (a,b,c,(d,b),(e,42))), যদি না আপনি maintaint আছে ম্যাক্রো উত্পন্ন হচ্ছে ... এবং এ জাতীয় কেসগুলিকে ভাষার মধ্যে ফেলা আরও শক্তিশালী টেম্পলেট / ম্যাক্রো হাইব্রিডের পরিবর্তে হ্যাকের মতো অন্য ধরণের। ম্যাক্রোগুলির আর কোনও ব্যবহার নেই বলে বলতে সক্ষম হবার জন্য আমাদের ম্যাক্রোগুলির সেই সমস্ত দরকারী ব্যবহারের কেসগুলি ভাষায় যুক্ত করা উচিত নয়।
প্লাজমাএইচ

উত্তর:


42

ম্যাজিক এনুম কেবল শিরোনামের পাঠাগারটি এন ++ (স্ট্রিং থেকে স্ট্রিং, পুনরাবৃত্তিতে) সি ++ 17 এর জন্য স্ট্যাটিক প্রতিবিম্ব সরবরাহ করে।

#include <magic_enum.hpp>

enum Color { RED = 2, BLUE = 4, GREEN = 8 };

Color color = Color::RED;
auto color_name = magic_enum::enum_name(color);
// color_name -> "RED"

std::string color_name{"GREEN"};
auto color = magic_enum::enum_cast<Color>(color_name)
if (color.has_value()) {
  // color.value() -> Color::GREEN
};

আরও উদাহরণের জন্য হোম রিপোজিটরি https://github.com/Neargye/magic_enum দেখুন

ত্রুটি কোথায়?

এই লাইব্রেরিতে একটি সংকলক-নির্দিষ্ট হ্যাক ব্যবহার করা হয়েছে ( __PRETTY_FUNCTION__/ এর উপর ভিত্তি করে __FUNCSIG__), যা কলঙ্ক> = 5, এমএসভিসি> = 15.3 এবং জিসিসি> = 9 এ কাজ করে।

এনাম মান অবশ্যই সীমার মধ্যে থাকা উচিত [MAGIC_ENUM_RANGE_MIN, MAGIC_ENUM_RANGE_MAX]

  • ডিফল্টরূপে MAGIC_ENUM_RANGE_MIN = -128, MAGIC_ENUM_RANGE_MAX = 128

  • যদি ডিফল্টরূপে সমস্ত এনাম ধরণের জন্য অন্য একটি ব্যাপ্তির প্রয়োজন হয় তবে ম্যাক্রো MAGIC_ENUM_RANGE_MINএবং নতুন সংজ্ঞা দিন MAGIC_ENUM_RANGE_MAX

  • MAGIC_ENUM_RANGE_MINএর চেয়ে কম বা সমান 0হতে হবে এবং এর চেয়ে বড় হতে হবে INT16_MIN

  • MAGIC_ENUM_RANGE_MAXএর চেয়ে বড় হতে হবে 0এবং কম হতে হবে INT16_MAX

  • নির্দিষ্ট এনাম ধরণের জন্য যদি অন্য পরিসরের প্রয়োজন হয় তবে প্রয়োজনীয় এনাম টাইপের জন্য বিশেষায়িত এনুম_আরঞ্জ যোগ করুন।

    #include <magic_enum.hpp>
    
    enum number { one = 100, two = 200, three = 300 };
    
    namespace magic_enum {
    template <>
      struct enum_range<number> {
        static constexpr int min = 100;
        static constexpr int max = 300;
    };
    }

কেন সীমা সীমা? এটি কি কোনও ধরণের পুনরাবৃত্তির গভীরতা সীমাবদ্ধ করার জন্য, বা কোনও ধরণের সংকলন-টাইম রৈখিক অনুসন্ধানের কারণে?
এমিল কর্মিয়ার

এটা চমৎকার. ধন্যবাদ! এটি সম্ভবত এমনকি দক্ষ যদি কম্পাইলার কেবলমাত্র একবারের কনস্টেক্সপ্রড স্ট্যান্ড :: অ্যারের মূল্যায়নের জন্য যথেষ্ট স্মার্ট হয়। খুব খুব চমৎকার.
আইসটিন

87

( উন্নত_মেনু লাইব্রেরির পদ্ধতির )

বর্তমান সি ++ তে স্ট্রিং থেকে এনুম করার একটি উপায় রয়েছে যা দেখতে এরকম দেখাচ্ছে:

ENUM(Channel, char, Red = 1, Green, Blue)

// "Same as":
// enum class Channel : char { Red = 1, Green, Blue };

ব্যবহার:

Channel     c = Channel::_from_string("Green");  // Channel::Green (2)
c._to_string();                                  // string "Green"

for (Channel c : Channel::_values())
    std::cout << c << std::endl;

// And so on...

সমস্ত অপারেশন করা যেতে পারে constexpr। আপনি @ কেটমুরের উত্তরে উল্লিখিত সি ++ 17 প্রতিবিম্ব প্রস্তাবও বাস্তবায়ন করতে পারেন।

  • একটি মাত্র ম্যাক্রো আছে। আমি বিশ্বাস করি এটি ন্যূনতম সম্ভব, কারণ প্রিপ্রসেসর স্ট্রিংাইজেশন ( #) হ'ল বর্তমান সি ++ এ টোকেনকে স্ট্রিংয়ে রূপান্তর করার একমাত্র উপায়।
  • ম্যাক্রো বেশ বিস্মৃতহীন - প্রারম্ভিক সহ ধ্রুবক ঘোষণাগুলি একটি অন্তর্নির্মিত এনাম ঘোষণায় আটকে দেওয়া হয়। এর অর্থ তাদের অন্তর্নির্মিত এনামের মতো একই বাক্য গঠন এবং অর্থ রয়েছে।
  • পুনরাবৃত্তি দূর হয়।
  • বাস্তবায়ন সবচেয়ে প্রাকৃতিক এবং অন্তত সি ++ 11 দরকারী, কারণে constexpr। এটি সি ++ 98 + এর সাথেও কাজ করা যায় __VA_ARGS__। এটি অবশ্যই আধুনিক সি ++।

ম্যাক্রোর সংজ্ঞা কিছুটা জড়িত, তাই আমি এর বিভিন্ন দিক দিয়ে উত্তর দিচ্ছি।

  • এই উত্তরের বেশিরভাগ অংশটি এমন একটি বাস্তবায়ন যা আমি মনে করি স্ট্যাক ওভারফ্লোতে স্থান সীমাবদ্ধতার জন্য উপযুক্ত।
  • দীর্ঘ-ফর্ম টিউটোরিয়ালে বাস্তবায়নের বেসিকগুলি বর্ণনা করে একটি কোডপোজেক্ট নিবন্ধও রয়েছে । [ আমি কি এখানে এটি স্থানান্তর করা উচিত? আমি মনে করি এটি একটি এসও উত্তরের জন্য খুব বেশি ]।
  • একটি পূর্ণ বৈশিষ্ট্যযুক্ত লাইব্রেরি "বেটার এনামস" রয়েছে যা একটি একক শিরোলেখ ফাইলটিতে ম্যাক্রো প্রয়োগ করে। এটি N4428 ধরণের সম্পত্তি প্রশ্নগুলিও প্রয়োগ করে , C ++ 17 প্রতিবিম্ব প্রস্তাব N4113 এর বর্তমান সংশোধন। সুতরাং, অন্তত এই ম্যাক্রোর মাধ্যমে ঘোষিত এনামগুলির জন্য, আপনি এখন সি ++ 11 / সি ++ 14 এ প্রস্তাবিত সি ++ 17 এনাম প্রতিবিম্বন করতে পারেন।

এই উত্তরটি লাইব্রেরির বৈশিষ্ট্যগুলির জন্য প্রসারিত করা সহজ - এখানে "গুরুত্বপূর্ণ" কিছুই বাদ নেই। এটি অবশ্য বেশ ক্লান্তিকর এবং সংকলক বহনযোগ্যতার উদ্বেগ রয়েছে।

দাবি অস্বীকার : আমি কোডপ্রজেক্ট নিবন্ধ এবং গ্রন্থাগার উভয়েরই লেখক।

আপনি এই উত্তরে কোডটি , লাইব্রেরি এবং এন 444428 লাইভ ওয়াণ্ডবক্সে লাইভের মাধ্যমে চেষ্টা করতে পারেন । লাইব্রেরির ডকুমেন্টেশনে এটিকে N4428 হিসাবে কীভাবে ব্যবহার করা যায় তার একটি সংক্ষিপ্তসার রয়েছে , যা সেই প্রস্তাবের এনাম অংশটি ব্যাখ্যা করে।


ব্যাখ্যা

নীচের কোডটি এনাম এবং স্ট্রিংয়ের মধ্যে রূপান্তর কার্যকর করে। তবে এটি পুনরুক্তির মতো অন্যান্য কাজগুলিতেও বাড়ানো যেতে পারে। এই উত্তরটি একটি একটি enum গোপন structstructপরিবর্তে এনামের পাশাপাশি আপনি একটি বৈশিষ্ট্যও তৈরি করতে পারেন ।

কৌশলটি হ'ল এরকম কিছু উত্পন্ন করা:

struct Channel {
    enum _enum : char { __VA_ARGS__ };
    constexpr static const Channel          _values[] = { __VA_ARGS__ };
    constexpr static const char * const     _names[] = { #__VA_ARGS__ };

    static const char* _to_string(Channel v) { /* easy */ }
    constexpr static Channel _from_string(const char *s) { /* easy */ }
};

সমস্যাগুলি হ'ল:

  1. আমরা {Red = 1, Green, Blue}মান অ্যারের জন্য আরম্ভকারীর মতো কিছু দিয়ে শেষ করব । এটি বৈধ সি ++ নয়, কারণ Redএকটি নির্ধারিত এক্সপ্রেশন নয়। এই ধরনের প্রতিটি ধ্রুবক ভোটদান দ্বারা মীমাংসিত হয় Tএকটি কাজ অপারেটর আছে, কিন্তু নিয়োগ ড্রপ হবে: {(T)Red = 1, (T)Green, (T)Blue}
  2. একইভাবে, আমরা {"Red = 1", "Green", "Blue"}নামের অ্যারের জন্য আরম্ভকারী হিসাবে শেষ করব । আমাদের এটিকে ছাঁটাই করতে হবে " = 1"। সংকলনের সময় এটি করার দুর্দান্ত উপায় সম্পর্কে আমি অবগত নই, সুতরাং সময় চালানোর জন্য আমরা এটিকে পিছিয়ে দেব। ফলস্বরূপ, _to_stringহবে না constexpr, কিন্তু_from_string এখনও হতে পারে constexpr, কারণ আমরা গোপনক্ষেত্রের চিকিত্সা করতে পারি এবং নিরপেক্ষ স্ট্রিংয়ের সাথে তুলনা করার সময় টার্মিনেটর হিসাবে চিহ্নগুলির সমান।
  3. উপরের উভয়কেই একটি "ম্যাপিং" ম্যাক্রো দরকার যা প্রতিটি উপাদানকে অন্য ম্যাক্রো প্রয়োগ করতে পারে __VA_ARGS__ । এটি বেশ মান। এই উত্তরে একটি সাধারণ সংস্করণ রয়েছে যা 8 টি উপাদান পর্যন্ত পরিচালনা করতে পারে।
  4. যদি ম্যাক্রোটিকে সত্যিকার অর্থে স্বয়ংসম্পূর্ণ করতে হয় তবে এটিকে কোনও পৃথক সংজ্ঞা প্রয়োজন এমন কোনও স্থিতিশীল ডেটা ঘোষণা করার দরকার নেই। অনুশীলনে, এর অর্থ অ্যারেগুলির বিশেষ চিকিত্সা প্রয়োজন। দুটি সম্ভাব্য সমাধান রয়েছে: constexpr(অথবা কেবলমাত্র const) নাম স্থানের সুযোগে অ্যারে, বা constexprস্থিতিশীল ইনলাইন ফাংশনে নিয়মিত অ্যারে । এই উত্তরের কোডটি সি ++ 11 এর জন্য এবং পূর্বের পদ্ধতির গ্রহণ করে। কোডপ্রজেক্ট নিবন্ধটি সি ++ 98 এর জন্য এবং পরেটি গ্রহণ করে।

কোড

#include <cstddef>      // For size_t.
#include <cstring>      // For strcspn, strncpy.
#include <stdexcept>    // For runtime_error.



// A "typical" mapping macro. MAP(macro, a, b, c, ...) expands to
// macro(a) macro(b) macro(c) ...
// The helper macro COUNT(a, b, c, ...) expands to the number of
// arguments, and IDENTITY(x) is needed to control the order of
// expansion of __VA_ARGS__ on Visual C++ compilers.
#define MAP(macro, ...) \
    IDENTITY( \
        APPLY(CHOOSE_MAP_START, COUNT(__VA_ARGS__)) \
            (macro, __VA_ARGS__))

#define CHOOSE_MAP_START(count) MAP ## count

#define APPLY(macro, ...) IDENTITY(macro(__VA_ARGS__))

#define IDENTITY(x) x

#define MAP1(m, x)      m(x)
#define MAP2(m, x, ...) m(x) IDENTITY(MAP1(m, __VA_ARGS__))
#define MAP3(m, x, ...) m(x) IDENTITY(MAP2(m, __VA_ARGS__))
#define MAP4(m, x, ...) m(x) IDENTITY(MAP3(m, __VA_ARGS__))
#define MAP5(m, x, ...) m(x) IDENTITY(MAP4(m, __VA_ARGS__))
#define MAP6(m, x, ...) m(x) IDENTITY(MAP5(m, __VA_ARGS__))
#define MAP7(m, x, ...) m(x) IDENTITY(MAP6(m, __VA_ARGS__))
#define MAP8(m, x, ...) m(x) IDENTITY(MAP7(m, __VA_ARGS__))

#define EVALUATE_COUNT(_1, _2, _3, _4, _5, _6, _7, _8, count, ...) \
    count

#define COUNT(...) \
    IDENTITY(EVALUATE_COUNT(__VA_ARGS__, 8, 7, 6, 5, 4, 3, 2, 1))



// The type "T" mentioned above that drops assignment operations.
template <typename U>
struct ignore_assign {
    constexpr explicit ignore_assign(U value) : _value(value) { }
    constexpr operator U() const { return _value; }

    constexpr const ignore_assign& operator =(int dummy) const
        { return *this; }

    U   _value;
};



// Prepends "(ignore_assign<_underlying>)" to each argument.
#define IGNORE_ASSIGN_SINGLE(e) (ignore_assign<_underlying>)e,
#define IGNORE_ASSIGN(...) \
    IDENTITY(MAP(IGNORE_ASSIGN_SINGLE, __VA_ARGS__))

// Stringizes each argument.
#define STRINGIZE_SINGLE(e) #e,
#define STRINGIZE(...) IDENTITY(MAP(STRINGIZE_SINGLE, __VA_ARGS__))



// Some helpers needed for _from_string.
constexpr const char    terminators[] = " =\t\r\n";

// The size of terminators includes the implicit '\0'.
constexpr bool is_terminator(char c, size_t index = 0)
{
    return
        index >= sizeof(terminators) ? false :
        c == terminators[index] ? true :
        is_terminator(c, index + 1);
}

constexpr bool matches_untrimmed(const char *untrimmed, const char *s,
                                 size_t index = 0)
{
    return
        is_terminator(untrimmed[index]) ? s[index] == '\0' :
        s[index] != untrimmed[index] ? false :
        matches_untrimmed(untrimmed, s, index + 1);
}



// The macro proper.
//
// There are several "simplifications" in this implementation, for the
// sake of brevity. First, we have only one viable option for declaring
// constexpr arrays: at namespace scope. This probably should be done
// two namespaces deep: one namespace that is likely to be unique for
// our little enum "library", then inside it a namespace whose name is
// based on the name of the enum to avoid collisions with other enums.
// I am using only one level of nesting.
//
// Declaring constexpr arrays inside the struct is not viable because
// they will need out-of-line definitions, which will result in
// duplicate symbols when linking. This can be solved with weak
// symbols, but that is compiler- and system-specific. It is not
// possible to declare constexpr arrays as static variables in
// constexpr functions due to the restrictions on such functions.
//
// Note that this prevents the use of this macro anywhere except at
// namespace scope. Ironically, the C++98 version of this, which can
// declare static arrays inside static member functions, is actually
// more flexible in this regard. It is shown in the CodeProject
// article.
//
// Second, for compilation performance reasons, it is best to separate
// the macro into a "parametric" portion, and the portion that depends
// on knowing __VA_ARGS__, and factor the former out into a template.
//
// Third, this code uses a default parameter in _from_string that may
// be better not exposed in the public interface.

#define ENUM(EnumName, Underlying, ...)                               \
namespace data_ ## EnumName {                                         \
    using _underlying = Underlying;                                   \
    enum { __VA_ARGS__ };                                             \
                                                                      \
    constexpr const size_t           _size =                          \
        IDENTITY(COUNT(__VA_ARGS__));                                 \
                                                                      \
    constexpr const _underlying      _values[] =                      \
        { IDENTITY(IGNORE_ASSIGN(__VA_ARGS__)) };                     \
                                                                      \
    constexpr const char * const     _raw_names[] =                   \
        { IDENTITY(STRINGIZE(__VA_ARGS__)) };                         \
}                                                                     \
                                                                      \
struct EnumName {                                                     \
    using _underlying = Underlying;                                   \
    enum _enum : _underlying { __VA_ARGS__ };                         \
                                                                      \
    const char * _to_string() const                                   \
    {                                                                 \
        for (size_t index = 0; index < data_ ## EnumName::_size;      \
             ++index) {                                               \
                                                                      \
            if (data_ ## EnumName::_values[index] == _value)          \
                return _trimmed_names()[index];                       \
        }                                                             \
                                                                      \
        throw std::runtime_error("invalid value");                    \
    }                                                                 \
                                                                      \
    constexpr static EnumName _from_string(const char *s,             \
                                           size_t index = 0)          \
    {                                                                 \
        return                                                        \
            index >= data_ ## EnumName::_size ?                       \
                    throw std::runtime_error("invalid identifier") :  \
            matches_untrimmed(                                        \
                data_ ## EnumName::_raw_names[index], s) ?            \
                    (EnumName)(_enum)data_ ## EnumName::_values[      \
                                                            index] :  \
            _from_string(s, index + 1);                               \
    }                                                                 \
                                                                      \
    EnumName() = delete;                                              \
    constexpr EnumName(_enum value) : _value(value) { }               \
    constexpr operator _enum() const { return (_enum)_value; }        \
                                                                      \
  private:                                                            \
    _underlying     _value;                                           \
                                                                      \
    static const char * const * _trimmed_names()                      \
    {                                                                 \
        static char     *the_names[data_ ## EnumName::_size];         \
        static bool     initialized = false;                          \
                                                                      \
        if (!initialized) {                                           \
            for (size_t index = 0; index < data_ ## EnumName::_size;  \
                 ++index) {                                           \
                                                                      \
                size_t  length =                                      \
                    std::strcspn(data_ ## EnumName::_raw_names[index],\
                                 terminators);                        \
                                                                      \
                the_names[index] = new char[length + 1];              \
                                                                      \
                std::strncpy(the_names[index],                        \
                             data_ ## EnumName::_raw_names[index],    \
                             length);                                 \
                the_names[index][length] = '\0';                      \
            }                                                         \
                                                                      \
            initialized = true;                                       \
        }                                                             \
                                                                      \
        return the_names;                                             \
    }                                                                 \
};

এবং

// The code above was a "header file". This is a program that uses it.
#include <iostream>
#include "the_file_above.h"

ENUM(Channel, char, Red = 1, Green, Blue)

constexpr Channel   channel = Channel::_from_string("Red");

int main()
{
    std::cout << channel._to_string() << std::endl;

    switch (channel) {
        case Channel::Red:   return 0;
        case Channel::Green: return 1;
        case Channel::Blue:  return 2;
    }
}

static_assert(sizeof(Channel) == sizeof(char), "");

প্রিন্টের উপরের প্রোগ্রামটি Red, যেমনটি আপনি আশা করবেন would এক ধরণের সুরক্ষা রয়েছে, যেহেতু আপনি এনাম শুরু না করে এনাম তৈরি করতে পারবেন না, এবং এর মধ্যে একটির কেস মুছে ফেলার switchফলে সংকলকটি (আপনার সংকলক এবং পতাকাগুলির উপর নির্ভর করে) থেকে একটি সতর্কতা তৈরি করবে। এছাড়াও, নোট করুন যে "Red"সংকলনের সময় একটি এনামে রূপান্তরিত হয়েছিল।


হিয়া @ মিঃথপি, দুঃখিত যে আপনার সম্পাদনা বাতিল হয়ে গেছে। আমি এটি সম্পর্কে ইমেল দেখেছি। আমি এটি উত্তরে অন্তর্ভুক্ত করতে যাচ্ছি - বাগফিক্সের জন্য ধন্যবাদ!
এন্ট্রন

এটা অসাধারণ. আমি কি বিটগুলির একটি এনাম চাইলে এটিও কাজ করবে? আমি যেমন বিটফ্ল্যাগসের এনাম চাই, প্রত্যেককে 1Uকিছু পরিমাণে স্থানান্তরিত করা যায়?
ব্যবহারকারী 3240688

1
_trimmed_names()আপনার এখানে পোস্ট করা কোডটিতে একটি মেমরি ফাঁস বলে মনে হচ্ছে ( new char[length + 1]তবে আপনি initializedসত্যে সেট করেন না)। আমি কিছু অনুপস্থিত করছি? আমি আপনার গিথব কোডে একই সমস্যা দেখছি না।
ব্যবহারকারী 3240688

1
এটি সেট করা আছে true, তবে ifশাখার বাইরে (মেমরি ফাঁস মূলত @ মিঃথেপি দ্বারা ধরা পড়ে)। এটিকে ভিতরে নিয়ে যাওয়া উচিত ... সম্পাদনা করা। এই এবং জিএইচ কোড উভয় ঘনিষ্ঠ চেহারা জন্য ধন্যবাদ।
19

1
to_stringstring_viewসি ++ 17 থেকে কোনও ফিরে আসতে পারে , যার নাল সমাপ্তির প্রয়োজন হয় না এবং কনস্টেক্সপ্রে পরিণত হয়।
ইয়াক্ক - অ্যাডাম নেভ্রামুমন্ট

74

জন্য সি ++ 17 সি ++ 20, আপনি প্রতিফলন স্টাডি গ্রুপ (SG7) কাজে আগ্রহী হতে হবে। ওয়ার্ডিং ( P0194 ) এবং যুক্তি, নকশা এবং বিবর্তন ( P0385 ) কভার করার একটি সমান্তরাল সিরিজ রয়েছে (প্রতিটি সিরিজের সর্বশেষতম কাগজে লিঙ্কগুলি সমাধান করুন))

P0194r2 (2016-10-15) হিসাবে সিনট্যাক্স প্রস্তাবিত reflexprকীওয়ার্ডটি ব্যবহার করবে :

meta::get_base_name_v<
  meta::get_element_m<
    meta::get_enumerators_m<reflexpr(MyEnum)>,
    0>
  >

উদাহরণস্বরূপ ( ম্যাটাস চোকলিকের ঝনঝন এর রিফ্লেক্সপ্রিফ শাখা থেকে অভিযোজিত ):

#include <reflexpr>
#include <iostream>

enum MyEnum { AAA = 1, BBB, CCC = 99 };

int main()
{
  auto name_of_MyEnum_0 = 
    std::meta::get_base_name_v<
      std::meta::get_element_m<
        std::meta::get_enumerators_m<reflexpr(MyEnum)>,
        0>
    >;

  // prints "AAA"
  std::cout << name_of_MyEnum_0 << std::endl;
}

স্থিতিশীল প্রতিচ্ছবি এটিকে সি ++ ১ into এ পরিণত করতে ব্যর্থ হয়েছিল (বরং, সম্ভবত ২০১ Iss সালের নভেম্বরে ইসকাওয়ায় স্ট্যান্ডার্ড সভায় উপস্থাপিত সম্ভবত-চূড়ান্ত খসড়াটিতে) তবে আত্মবিশ্বাস আছে যে এটি এটিকে সি ++ ২০-এ পরিণত করবে; থেকে ঔষধি Sutter সফর রিপোর্ট :

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


2
@ এন্ট্রন দুঃখিত আপনার সম্পাদনা বাতিল হয়ে গেছে; আমি যদি সময়মতো এটি দেখতে পেতাম তবে আমি তা অনুমোদন করতাম। আমি N4428 দেখিনি তাই মাথা আপ দেওয়ার জন্য ধন্যবাদ।
ইকামত্মর

3
কোনও সমস্যা নেই, এটি অন্তর্ভুক্ত করার জন্য ধন্যবাদ। কেন আমি তা প্রত্যাখ্যান করলাম তা আমি ভাবছি। আমি বয়লারপ্লেটের কারণে "এটি আরও সঠিক করে না" দেখছি, তবে এটি বর্তমান সময়ের জন্য আরও স্পষ্টভাবে আরও সঠিক।
অ্যান্ট্রন

1
ধন্যবাদ :-) অনুভূমিক স্ক্রোল বারটি এড়ানোর জন্য আমি চূড়ান্ত উদাহরণটি বিভক্ত করেছি। কত MyEnum::AAAstd::meta::get_enumerators_m
আক্ষেপের মানটি

1
এই ধরণের ধারণাগতভাবে সহজ কাজটির জন্য নেস্টেড টেম্পলেট আর্গুমেন্টগুলির 3 স্তরের প্রয়োজন হয় তা খুব বিবেচ্য। আমি নিশ্চিত যে এর নির্দিষ্ট, প্রযুক্তিগত কারণ রয়েছে। তবে এর অর্থ এই নয় যে শেষ ফলাফলটি ব্যবহারকারী বান্ধব। আমি সি ++ পছন্দ করি এবং কোডটি আমার কাছে উপলব্ধি করে। কিন্তু অন্যান্য প্রোগ্রামারদের 90% আমি একটি দৈনিক ভিত্তিতে Shun সি ++ ভালো কোড কারণ সঙ্গে কাজ করি। এর চেয়ে সহজতর অন্তর্নির্মিত সমাধান না দেখে আমি হতাশ।
void.pointer

2
স্ট্যান্ডার্ডে আসন্ন প্রতিচ্ছবি টিএস অন্তর্ভুক্ত করার বর্তমান অনুমানটি সি ++ 23 : herbsutter.com/2018/04/02/…
টিম

25

এটি ইউরি ফিনকেলস্টেইনের মতো; তবে বুস্টের প্রয়োজন হয় না। আমি একটি মানচিত্র ব্যবহার করছি যাতে আপনি এনামগুলিকে কোনও মান অর্ডার করতে পারেন, যে কোনও আদেশ।

এনাম শ্রেণীর ঘোষণা যেমন:

DECLARE_ENUM_WITH_TYPE(TestEnumClass, int32_t, ZERO = 0x00, TWO = 0x02, ONE = 0x01, THREE = 0x03, FOUR);

নিম্নলিখিত কোডটি স্বয়ংক্রিয়ভাবে এনাম শ্রেণি তৈরি করবে এবং ওভারলোড:

  • স্ট্যান্ড :: স্ট্রিংয়ের জন্য '+' '+ ='
  • স্রোতের জন্য '<<'
  • '~' কেবল স্ট্রিংয়ে রূপান্তর করতে (যে কোনও ইউনিারি অপারেটর করবে, তবে স্বচ্ছতার জন্য আমি ব্যক্তিগতভাবে এটি পছন্দ করি না)
  • এনামগুলির গণনা পেতে '*'

কোনও বুস্টের প্রয়োজন নেই, সমস্ত প্রয়োজনীয় ফাংশন সরবরাহ করা হয়েছে।

কোড:

#include <algorithm>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>

#define STRING_REMOVE_CHAR(str, ch) str.erase(std::remove(str.begin(), str.end(), ch), str.end())

std::vector<std::string> splitString(std::string str, char sep = ',') {
    std::vector<std::string> vecString;
    std::string item;

    std::stringstream stringStream(str);

    while (std::getline(stringStream, item, sep))
    {
        vecString.push_back(item);
    }

    return vecString;
}

#define DECLARE_ENUM_WITH_TYPE(E, T, ...)                                                                     \
    enum class E : T                                                                                          \
    {                                                                                                         \
        __VA_ARGS__                                                                                           \
    };                                                                                                        \
    std::map<T, std::string> E##MapName(generateEnumMap<T>(#__VA_ARGS__));                                    \
    std::ostream &operator<<(std::ostream &os, E enumTmp)                                                     \
    {                                                                                                         \
        os << E##MapName[static_cast<T>(enumTmp)];                                                            \
        return os;                                                                                            \
    }                                                                                                         \
    size_t operator*(E enumTmp) { (void) enumTmp; return E##MapName.size(); }                                 \
    std::string operator~(E enumTmp) { return E##MapName[static_cast<T>(enumTmp)]; }                          \
    std::string operator+(std::string &&str, E enumTmp) { return str + E##MapName[static_cast<T>(enumTmp)]; } \
    std::string operator+(E enumTmp, std::string &&str) { return E##MapName[static_cast<T>(enumTmp)] + str; } \
    std::string &operator+=(std::string &str, E enumTmp)                                                      \
    {                                                                                                         \
        str += E##MapName[static_cast<T>(enumTmp)];                                                           \
        return str;                                                                                           \
    }                                                                                                         \
    E operator++(E &enumTmp)                                                                                  \
    {                                                                                                         \
        auto iter = E##MapName.find(static_cast<T>(enumTmp));                                                 \
        if (iter == E##MapName.end() || std::next(iter) == E##MapName.end())                                  \
            iter = E##MapName.begin();                                                                        \
        else                                                                                                  \
        {                                                                                                     \
            ++iter;                                                                                           \
        }                                                                                                     \
        enumTmp = static_cast<E>(iter->first);                                                                \
        return enumTmp;                                                                                       \
    }                                                                                                         \
    bool valid##E(T value) { return (E##MapName.find(value) != E##MapName.end()); }

#define DECLARE_ENUM(E, ...) DECLARE_ENUM_WITH_TYPE(E, int32_t, __VA_ARGS__)
template <typename T>
std::map<T, std::string> generateEnumMap(std::string strMap)
{
    STRING_REMOVE_CHAR(strMap, ' ');
    STRING_REMOVE_CHAR(strMap, '(');

    std::vector<std::string> enumTokens(splitString(strMap));
    std::map<T, std::string> retMap;
    T inxMap;

    inxMap = 0;
    for (auto iter = enumTokens.begin(); iter != enumTokens.end(); ++iter)
    {
        // Token: [EnumName | EnumName=EnumValue]
        std::string enumName;
        T enumValue;
        if (iter->find('=') == std::string::npos)
        {
            enumName = *iter;
        }
        else
        {
            std::vector<std::string> enumNameValue(splitString(*iter, '='));
            enumName = enumNameValue[0];
            //inxMap = static_cast<T>(enumNameValue[1]);
            if (std::is_unsigned<T>::value)
            {
                inxMap = static_cast<T>(std::stoull(enumNameValue[1], 0, 0));
            }
            else
            {
                inxMap = static_cast<T>(std::stoll(enumNameValue[1], 0, 0));
            }
        }
        retMap[inxMap++] = enumName;
    }

    return retMap;
}

উদাহরণ:

DECLARE_ENUM_WITH_TYPE(TestEnumClass, int32_t, ZERO = 0x00, TWO = 0x02, ONE = 0x01, THREE = 0x03, FOUR);

int main(void) {
    TestEnumClass first, second;
    first = TestEnumClass::FOUR;
    second = TestEnumClass::TWO;

    std::cout << first << "(" << static_cast<uint32_t>(first) << ")" << std::endl; // FOUR(4)

    std::string strOne;
    strOne = ~first;
    std::cout << strOne << std::endl; // FOUR

    std::string strTwo;
    strTwo = ("Enum-" + second) + (TestEnumClass::THREE + "-test");
    std::cout << strTwo << std::endl; // Enum-TWOTHREE-test

    std::string strThree("TestEnumClass: ");
    strThree += second;
    std::cout << strThree << std::endl; // TestEnumClass: TWO
    std::cout << "Enum count=" << *first << std::endl;
}

You can run the code here


1
আমরা কি এই ম্যাক্রো সংজ্ঞাটির ভিতরে লাইন বিরতি রাখতে পারি?
einpoklum


1
এই বাস্তবায়ন (ও (1) সূচক) এর std::mapপরিবর্তে (ও (লগ (এন)) সূচক ব্যবহার করার কোনও কারণ আছে কি std::unordered_map?
নদীর

1
এছাড়াও, আমি মনে করি যে পদ্ধতিগুলি চিহ্নিত করা উচিত inlineযাতে আপনি লিঙ্কারের কাছ থেকে "একাধিক সংজ্ঞা" ত্রুটি না পেয়ে স্বাভাবিকের মতো হেডার ফাইলগুলিতে এনামগুলি ঘোষণা করতে পারেন declared (যদিও এটি আসলে সবচেয়ে পরিষ্কার / সেরা সমাধান কিনা তা নিশ্চিত নয়)
নদীর

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

19

২০১১ সালে ফিরে আমি একটি ম্যাক্রো-ভিত্তিক সমাধানকে সূক্ষ্ম সুরকরণে একটি সপ্তাহান্তে কাটিয়েছি এবং এটি কখনও ব্যবহার না করে শেষ করেছি।

আমার বর্তমান পদ্ধতিটি হ'ল ভিম শুরু করা, খালি স্যুইচ বডিতে গণনাকারীদের অনুলিপি করা, একটি নতুন ম্যাক্রো শুরু করা, প্রথম তালিকাটিকে কেস স্টেটমেন্টে রূপান্তর করা, কার্সারটিকে পরবর্তী লাইনের শুরুতে সরিয়ে নেওয়া, ম্যাক্রো বন্ধ করা এবং বাকী কেস উত্পন্ন করা অন্যান্য গণকের উপর ম্যাক্রো চালিয়ে বিবৃতি।

ভি + ম্যাক্রোগুলি সি ++ ম্যাক্রোর চেয়ে বেশি মজাদার।

বাস্তব জীবনের উদাহরণ:

enum class EtherType : uint16_t
{
    ARP   = 0x0806,
    IPv4  = 0x0800,
    VLAN  = 0x8100,
    IPv6  = 0x86DD
};

আমি এটি তৈরি করব:

std::ostream& operator<< (std::ostream& os, EtherType ethertype)
{
    switch (ethertype)
    {
        case EtherType::ARP : return os << "ARP" ;
        case EtherType::IPv4: return os << "IPv4";
        case EtherType::VLAN: return os << "VLAN";
        case EtherType::IPv6: return os << "IPv6";
        // omit default case to trigger compiler warning for missing cases
    };
    return os << static_cast<std::uint16_t>(ethertype);
}

এবং এইভাবেই আমি পেরেছি।

এনাম স্ট্রিংয়ের জন্য নেটিভ সমর্থন যদিও আরও ভাল হবে। আমি C ++ 17 এর প্রতিবিম্ব ওয়ার্কগ্রপের ফলাফলগুলি দেখতে খুব আগ্রহী।

এটি করার একটি বিকল্প উপায় @ মন্তব্যে পোস্ট করেছেন ।


1
আমি ঠিক এই কাজ। যদিও আমি সাধারণত রাস্তার পাশে
ভিউ

পছন্দ করুন আমার কাছে "চারপাশে" নজর রাখা উচিত কারণ বর্তমানে আমার কাছে অনেকগুলি কিস্ট্রোকের পথ প্রয়োজন।
স্ট্যাকড ক্রুকড

এখানে এটি সম্পূর্ণ উদ্বেগের সাথে রয়েছে , কোনও ম্যাক্রো নেই (যতক্ষণ না .গণনা করা হয়): i.imgur.com/gY4ZhBE.gif
sehe

1
অ্যানিমেটেড জিআইএফ খুব সুন্দর, তবে এটি কখন শুরু হয় এবং শেষ হয় এবং আমরা কতটা দূরে আছি তা বলা মুশকিল difficult ... আসলে, এটি স্ক্র্যাচ করুন যে এটি সুন্দর নয়, এটি বিভ্রান্ত করছে। আমি বলি এটা মেরে ফেল।
einpoklum

ভিমে এই ব্লক-নির্বাচনের পদ্ধতিরটি দুর্দান্ত এবং সমস্ত, তবে কেন এমন কিছু ব্যবহার করবেন না :'<,'>s/ *\(.*\)=.*/case EtherType::\1: return os << "\1";/?
রুসলান

14

আমি জানি না আপনি এটি পছন্দ করতে চলেছেন বা করবেন না, আমি এই সমাধানটি নিয়ে বেশ খুশি নই তবে এটি একটি সি ++ 14 বন্ধুত্বপূর্ণ পদ্ধতির কারণ এটি টেম্পলেট ভেরিয়েবলগুলি ব্যবহার করছে এবং টেম্পলেট বিশেষায়িত ব্যবহার করছে:

enum class MyEnum : std::uint_fast8_t {
   AAA,
   BBB,
   CCC,
};

template<MyEnum> const char MyEnumName[] = "Invalid MyEnum value";
template<> const char MyEnumName<MyEnum::AAA>[] = "AAA";
template<> const char MyEnumName<MyEnum::BBB>[] = "BBB";
template<> const char MyEnumName<MyEnum::CCC>[] = "CCC";

int main()
{
    // Prints "AAA"
    std::cout << MyEnumName<MyEnum::AAA> << '\n';
    // Prints "Invalid MyEnum value"
    std::cout << MyEnumName<static_cast<MyEnum>(0x12345678)> << '\n';
    // Well... in fact it prints "Invalid MyEnum value" for any value
    // different of MyEnum::AAA, MyEnum::BBB or MyEnum::CCC.

    return 0;
}

এই পদ্ধতির সবচেয়ে খারাপটি এটি বজায় রাখার জন্য একটি ব্যথা, তবে এটির মতো অন্যান্য কিছু অ্যাপ্রোচগুলি বজায় রাখতেও ব্যথা হয়, তাই না?

এই অগ্রাহ্য সম্পর্কে ভাল পয়েন্ট:

  • ভেরিয়েবল টেম্পেটস (সি ++ 14 বৈশিষ্ট্য) ব্যবহার করা হচ্ছে
  • টেমপ্লেট বিশেষায়িতকরণের মাধ্যমে আমরা যখন একটি অবৈধ মান ব্যবহার করা হয় তখন "সনাক্ত" করতে পারি (তবে আমি নিশ্চিত নই যে এটি আদৌ কার্যকর হতে পারে কিনা)।
  • দেখতে অনেকটা ঝরঝরে।
  • নাম অনুসন্ধান সংকলন সময়ে সম্পন্ন করা হয়।

Live example

সম্পাদন করা

Misterious user673679 আপনি ঠিক; সি ++ ১৪ ভেরিয়েবল টেম্পলেট পদ্ধতির রানটাইম কেস পরিচালনা করে না, এটি ভুলে যাওয়া আমার দোষ ছিল :(

তবে আমরা এখনও কিছু আধুনিক সি ++ বৈশিষ্ট্য এবং ভেরিয়েবল টেম্পলেট প্লাস ভ্যারিয়্যাডিক টেম্পলেট ট্র্যাকারি ব্যবহার করতে পারি একটি এনটাইম মান থেকে স্ট্রিংয়ের একটি রানটাইম অনুবাদ অর্জন করার জন্য ... এটি অন্যের মতো বিরক্তিকর তবে এখনও উল্লেখ করার মতো মূল্য রয়েছে।

একটি এনাম-টু-স্ট্রিং মানচিত্রে অ্যাক্সেসকে সংক্ষিপ্ত করতে একটি টেম্পলেট ওরফে ব্যবহার শুরু করা যাক:

// enum_map contains pairs of enum value and value string for each enum
// this shortcut allows us to use enum_map<whatever>.
template <typename ENUM>
using enum_map = std::map<ENUM, const std::string>;

// This variable template will create a map for each enum type which is
// instantiated with.
template <typename ENUM>
enum_map<ENUM> enum_values{};

তারপরে, বৈকল্পিক টেম্পলেট কৌশল:

template <typename ENUM>
void initialize() {}

template <typename ENUM, typename ... args>
void initialize(const ENUM value, const char *name, args ... tail)
{
    enum_values<ENUM>.emplace(value, name);
    initialize<ENUM>(tail ...);
}

এখানে " সেরা কৌশল " হ'ল মানচিত্রের জন্য পরিবর্তনশীল টেম্পলেট ব্যবহার যা প্রতিটি এনাম প্রবেশের মান এবং নাম রাখে; এই মানচিত্রটি প্রতিটি অনুবাদ ইউনিটে একই হবে এবং সর্বত্র একই নাম থাকবে তাই আমরা খুব সহজবোধ্য এবং ঝরঝরে, যদি আমরা এই initializeফাংশনটিকে কল করি :

initialize
(
    MyEnum::AAA, "AAA",
    MyEnum::BBB, "BBB",
    MyEnum::CCC, "CCC"
);

আমরা প্রতিটি MyEnumপ্রবেশের জন্য নাম স্বাক্ষর করছি এবং রানটাইম ব্যবহার করা যেতে পারে:

std::cout << enum_values<MyEnum>[MyEnum::AAA] << '\n';

তবে এসএফআইএনএই ও ওভারলোডিং <<অপারেটরের মাধ্যমে উন্নত করা যেতে পারে :

template<typename ENUM, class = typename std::enable_if<std::is_enum<ENUM>::value>::type>
std::ostream &operator <<(std::ostream &o, const ENUM value)
{
    static const std::string Unknown{std::string{typeid(ENUM).name()} + " unknown value"};
    auto found = enum_values<ENUM>.find(value);

    return o << (found == enum_values<ENUM>.end() ? Unknown : found->second);
}

সঠিক সঙ্গে operator <<এখন আমরা এইভাবে এনাম ব্যবহার করতে পারি:

std::cout << MyEnum::AAA << '\n';

এটি বজায় রাখাও বিরক্তিকর এবং উন্নত করা যেতে পারে, তবে আশা করি আপনি ধারণাটি পাবেন।

Live example


এটি বেশ ঝরঝরে দেখাচ্ছে (কেবলমাত্র বিশেষায়িত ভেরিয়েবলটি সংজ্ঞায়িত করা কি সম্ভব?) সম্ভবত আমি কিছু মিস করছি, যদিও এটি রানটাইম কেসটি কীভাবে পরিচালনা করে তা আমি দেখতে পাই না।
ব্যবহারকারী 673679

@ পলা_প্লাস_প্লাস: আপনার অতিরোধ্য std::arrayমানচিত্রের পরিবর্তে কেবল একটি ব্যবহার করা উচিত নয় ? এটি কেবল এনামদের থেকে শুরু করে দেওয়া ভাল হবে ... কী, 2 ^ 10 মান? সম্ভবত আরও কিছু।
einpoklum

@ আইনপোকলুম এটি আশ্চর্যজনক হবে যদি আমরা রানটাইমে নিশ্চিত করতে পারি যে কতগুলি উপাদান enumরয়েছে। দুর্ভাগ্যজনকভাবে, আমরা পারি না। এবং মানচিত্রের পুরো পয়েন্টটি কেবলমাত্র মূল্যগুলির সাথে নামগুলি সংযুক্ত করা, std::mapএটিই ভাল।
পেপারবার্ডমাস্টার

@ পলা_প্লাস_প্লাস: আপনি ইতিমধ্যে একটি initialize()ফাংশন কল করছেন যার আর্গুমেন্টের সংখ্যা এনাম মান সংখ্যা, তাই আপনি সংকলন-সময় মানগুলির সংখ্যা জানেন। আপনাকে কেবল মুদ্রণ করতে বলা সেই নির্দিষ্ট মান যা কেবলমাত্র রান-টাইমে পরিচিত। এছাড়াও, আপনি যদি এই সংখ্যাটি না জানতেন তবে প্রায় সমস্ত বাস্তব ক্ষেত্রে আবার একটি স্ট্যান্ড :: ভেক্টর একটি স্ট্যান্ড :: মানচিত্রের চেয়ে দ্রুততর হবে।
einpoklum

@ আইনপোকলুম এটি খুব ভাল একটি বিষয়, আমি এটি সম্পর্কে চিন্তা করব, ধন্যবাদ! কেবলমাত্র আমাকে চিন্তিত করে তোলে তা std::arrayহ'ল কোনও মূলমূল্যের ধারক নয় এবং অতএব অনুসন্ধানের পদ্ধতিগুলির অভাব রয়েছে; যাইহোক আমি এটি একটি চিন্তা দিতে হবে।
পেপারবার্ডমাস্টার

7

আপনার enumচেহারা মত যদি

enum MyEnum
{
  AAA = -8,
  BBB = '8',
  CCC = AAA + BBB
};

আপনি এর সামগ্রীটি enumএকটি নতুন ফাইলে স্থানান্তর করতে পারেন :

AAA = -8,
BBB = '8',
CCC = AAA + BBB

এবং তারপরে মানগুলি একটি ম্যাক্রো দ্বারা ঘিরে থাকতে পারে:

// default definition
#ifned ITEM(X,Y)
#define ITEM(X,Y)
#endif

// Items list
ITEM(AAA,-8)
ITEM(BBB,'8')
ITEM(CCC,AAA+BBB)

// clean up
#undef ITEM

পরবর্তী পদক্ষেপে আইটেমগুলিকে enumআবার অন্তর্ভুক্ত করা যেতে পারে :

enum MyEnum
{
  #define ITEM(X,Y) X=Y,
  #include "enum_definition_file"
};

এবং অবশেষে আপনি এই সম্পর্কে ইউটিলিটি ফাংশন তৈরি করতে পারেন enum:

std::string ToString(MyEnum value)
{
  switch( value )
  {
    #define ITEM(X,Y) case X: return #X;
    #include "enum_definition_file"
  }

  return "";
}

MyEnum FromString(std::string const& value)
{
  static std::map<std::string,MyEnum> converter
  {
    #define ITEM(X,Y) { #X, X },
    #include "enum_definition_file"
  };

  auto it = converter.find(value);
  if( it != converter.end() )
    return it->second;
  else
    throw std::runtime_error("Value is missing");
}

সমাধানটি পুরানো সি ++ স্ট্যান্ডার্ডগুলিতে প্রয়োগ করা যেতে পারে এবং এটি আধুনিক সি ++ উপাদান ব্যবহার করে না তবে এটি খুব বেশি প্রচেষ্টা এবং রক্ষণাবেক্ষণ ছাড়াই প্রচুর কোড উত্পন্ন করতে ব্যবহৃত হতে পারে।


3
আলাদা ফাইলের দরকার নেই। এটি মূলত একটি এক্স-ম্যাক্রো
হলি ব্ল্যাককিট

@ হোলিব্ল্যাকগ্যাট যদি আপনি কিছু ফাইলগুলিতে সমাধানটি বিভক্ত করেন তবে আপনি এনাম মানগুলি বিভিন্ন উদ্দেশ্যে পুনরায় ব্যবহার করতে পারেন
ইফেরিয়ন

আমি আপনাকে বলার চেষ্টা করছি যে আপনি একটি শিরোনামে এনাম সংজ্ঞা পাশাপাশি মানগুলি তালিকাকে একটি ম্যাক্রোতে রাখলে আপনি একই জিনিসটি করতে পারেন।
হলিব্ল্যাকট্যাগ

@ হলি ব্ল্যাকগ্যাট হ্যাঁ আমি আপনাকে বুঝতে পারি তবে আমি এই সমাধানটি পছন্দ করি। অন্যদিকে এই সমাধানটি
ঝাঁকুনির

যথেষ্ট ফর্সা। এটি অনুমান করা উচিত নয়, কারণ এটির কিছু ব্যবহার থাকতে পারে। (ডামি সম্পাদনা ক্ষমা করুন, সিস্টেমটি অন্যথায় আমার ভোট লক করে।)
হলিব্ল্যাকগেট 20

6

দু'দিন আগেও আমার একই সমস্যা ছিল। কিছু অদ্ভুত ম্যাক্রো যাদু ছাড়া আমি কোনও সি ++ সমাধান খুঁজে পাইনি, তাই আমি সিএমকে কোড জেনারেটর লেখার সিদ্ধান্ত নিয়েছি সাধারণ স্যুইচ কেস স্টেটমেন্টগুলি তৈরি করতে ।

ব্যবহার:

enum2str_generate(
  PATH          <path to place the files in>
  CLASS_NAME    <name of the class (also prefix for the files)>
  FUNC_NAME     <name of the (static) member function>
  NAMESPACE     <the class will be inside this namespace>
  INCLUDES      <LIST of files where the enums are defined>
  ENUMS         <LIST of enums to process>
  BLACKLIST     <LIST of constants to ignore>
  USE_CONSTEXPR <whether to use constexpr or not (default: off)>
  USE_C_STRINGS <whether to use c strings instead of std::string or not (default: off)>
)

ফাংশনটি ফাইল সিস্টেমে অন্তর্ভুক্ত ফাইলগুলি অনুসন্ধান করে (অন্তর্ভুক্ত ডিরেক্টরিগুলি অন্তর্ভুক্ত ডিরেক্টরিগুলি ব্যবহার করে), সেগুলি পড়ে এবং ক্লাস এবং ফাংশন (গুলি) উত্পন্ন করার জন্য কিছু রেইগেক্স করে।

দ্রষ্টব্য: কনটেক্সপ্রেস সি ++ তে ইনলাইনটি বোঝায়, সুতরাং USE_CONSTEXPR বিকল্পটি ব্যবহার করে কেবল একটি শিরোনাম শ্রেণি উৎপন্ন হবে!

উদাহরণ:

./includes/ah:

enum AAA : char { A1, A2 };

typedef enum {
   VAL1          = 0,
   VAL2          = 1,
   VAL3          = 2,
   VAL_FIRST     = VAL1,    // Ignored
   VAL_LAST      = VAL3,    // Ignored
   VAL_DUPLICATE = 1,       // Ignored
   VAL_STRANGE   = VAL2 + 1 // Must be blacklisted
} BBB;

./CMakeLists.txt:

include_directories( ${PROJECT_SOURCE_DIR}/includes ...)

enum2str_generate(
   PATH       "${PROJECT_SOURCE_DIR}"
   CLASS_NAME "enum2Str"
   NAMESPACE  "abc"
   FUNC_NAME  "toStr"
   INCLUDES   "a.h" # WITHOUT directory
   ENUMS      "AAA" "BBB"
   BLACKLIST  "VAL_STRANGE")

উত্পন্ন:

./enum2Str.hpp:

/*!
  * \file enum2Str.hpp
  * \warning This is an automatically generated file!
  */

#ifndef ENUM2STR_HPP
#define ENUM2STR_HPP

#include <string>
#include <a.h>

namespace abc {

class enum2Str {
 public:
   static std::string toStr( AAA _var ) noexcept;
   static std::string toStr( BBB _var ) noexcept;
};

}

#endif // ENUM2STR_HPP

./enum2Str.cpp:

/*!
  * \file enum2Str.cpp
  * \warning This is an automatically generated file!
  */

#include "enum2Str.hpp"

namespace abc {

/*!
 * \brief Converts the enum AAA to a std::string
 * \param _var The enum value to convert
 * \returns _var converted to a std::string
 */
std::string enum2Str::toStr( AAA _var ) noexcept {
   switch ( _var ) {
      case A1: return "A1";
      case A2: return "A2";
      default: return "<UNKNOWN>";
   }
}

/*!
 * \brief Converts the enum BBB to a std::string
 * \param _var The enum value to convert
 * \returns _var converted to a std::string
 */
std::string enum2Str::toStr( BBB _var ) noexcept {
   switch ( _var ) {
      case VAL1: return "VAL1";
      case VAL2: return "VAL2";
      case VAL3: return "VAL3";
      default: return "<UNKNOWN>";
   }
}
}

হালনাগাদ:

স্ক্রিপ্ট এখন স্কোপযুক্ত গণনাগুলি (এনাম ক্লাস | স্ট্রাক্ট) সমর্থন করে এবং আমি প্রায়শই ব্যবহার করি এমন অন্যান্য স্ক্রিপ্টগুলির সাথে এটি একটি পৃথক রেপোতে স্থানান্তরিত করেছি: https://github.com/mensinda/cmakeBuildTools


কি দারুন! খুব আসল এবং উদ্ভাবনী ধারণা :-) আমি আশা করি আপনার জেনারেটরটি একটি constexprএবং noexceptসংস্করণ সরবরাহ করার জন্য আপগ্রেড করার সাহস পাবে ;-) আমি আপনার গিটহাব প্রকল্পটিও
স্রেফ দেখেছি

1
জেনারেটর আপডেট হয়েছে। ফাংশনগুলি এখন সর্বদা কনসেক্সট্রপ এবং এনাম হবে: <টাইপ> এখন সমর্থিত। তারার জন্য ধন্যবাদ :)
Mense

লিঙ্কটি ভাঙা হয়েছে ... -.--
ইয়োমন

লিঙ্কটি এখন ঠিক করা হয়েছে।
Mense

4

কেবল আপনার এনাম তৈরি করুন। সে উদ্দেশ্যে জেনারেটর লেখা প্রায় পাঁচ মিনিটের কাজ।

জাভা এবং পাইথনে জেনারেটর কোড, সি ++ সহ আপনার পছন্দ মতো যে কোনও ভাষায় পোর্ট করা সহজ।

আপনি যে কোনও কার্যকারিতা চান তা দ্বারা প্রসারিত করা খুব সহজ।

উদাহরণ ইনপুট:

First = 5
Second
Third = 7
Fourth
Fifth=11

উত্পন্ন শিরোনাম:

#include <iosfwd>

enum class Hallo
{
    First = 5,
    Second = 6,
    Third = 7,
    Fourth = 8,
    Fifth = 11
};

std::ostream & operator << (std::ostream &, const Hallo&);

উত্পন্ন সিপিপি ফাইল

#include <ostream>

#include "Hallo.h"

std::ostream & operator << (std::ostream &out, const Hallo&value)
{
    switch(value)
    {
    case Hallo::First:
        out << "First";
        break;
    case Hallo::Second:
        out << "Second";
        break;
    case Hallo::Third:
        out << "Third";
        break;
    case Hallo::Fourth:
        out << "Fourth";
        break;
    case Hallo::Fifth:
        out << "Fifth";
        break;
    default:
        out << "<unknown>";
    }

    return out;
}

এবং জেনারেটর, পোর্টিং এবং এক্সটেনশনের টেমপ্লেট হিসাবে খুব সংক্ষিপ্ত আকারে। এই উদাহরণ কোডটি আসলে কোনও ফাইলকে ওভাররাইট করা এড়াতে চেষ্টা করে তবে এটি নিজের ঝুঁকিতে ব্যবহার করে।

package cppgen;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.nio.charset.Charset;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class EnumGenerator
{
    static void fail(String message)
    {
        System.err.println(message);
        System.exit(1);
    }

    static void run(String[] args)
    throws Exception
    {
        Pattern pattern = Pattern.compile("\\s*(\\w+)\\s*(?:=\\s*(\\d+))?\\s*", Pattern.UNICODE_CHARACTER_CLASS);
        Charset charset = Charset.forName("UTF8");
        String tab = "    ";

        if (args.length != 3)
        {
            fail("Required arguments: <enum name> <input file> <output dir>");
        }

        String enumName = args[0];

        File inputFile = new File(args[1]);

        if (inputFile.isFile() == false)
        {
            fail("Not a file: [" + inputFile.getCanonicalPath() + "]");
        }

        File outputDir = new File(args[2]);

        if (outputDir.isDirectory() == false)
        {
            fail("Not a directory: [" + outputDir.getCanonicalPath() + "]");
        }

        File headerFile = new File(outputDir, enumName + ".h");
        File codeFile = new File(outputDir, enumName + ".cpp");

        for (File file : new File[] { headerFile, codeFile })
        {
            if (file.exists())
            {
                fail("Will not overwrite file [" + file.getCanonicalPath() + "]");
            }
        }

        int nextValue = 0;

        Map<String, Integer> fields = new LinkedHashMap<>();

        try
        (
            BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(inputFile), charset));
        )
        {
            while (true)
            {
                String line = reader.readLine();

                if (line == null)
                {
                    break;
                }

                if (line.trim().length() == 0)
                {
                    continue;
                }

                Matcher matcher = pattern.matcher(line);

                if (matcher.matches() == false)
                {
                    fail("Syntax error: [" + line + "]");
                }

                String fieldName = matcher.group(1);

                if (fields.containsKey(fieldName))
                {
                    fail("Double fiend name: " + fieldName);
                }

                String valueString = matcher.group(2);

                if (valueString != null)
                {
                    int value = Integer.parseInt(valueString);

                    if (value < nextValue)
                    {
                        fail("Not a monotonous progression from " + nextValue + " to " + value + " for enum field " + fieldName);
                    }

                    nextValue = value;
                }

                fields.put(fieldName, nextValue);

                ++nextValue;
            }
        }

        try
        (
            PrintWriter headerWriter = new PrintWriter(new OutputStreamWriter(new FileOutputStream(headerFile), charset));
            PrintWriter codeWriter = new PrintWriter(new OutputStreamWriter(new FileOutputStream(codeFile), charset));
        )
        {
            headerWriter.println();
            headerWriter.println("#include <iosfwd>");
            headerWriter.println();
            headerWriter.println("enum class " + enumName);
            headerWriter.println('{');
            boolean first = true;
            for (Entry<String, Integer> entry : fields.entrySet())
            {
                if (first == false)
                {
                    headerWriter.println(",");
                }

                headerWriter.print(tab + entry.getKey() + " = " + entry.getValue());

                first = false;
            }
            if (first == false)
            {
                headerWriter.println();
            }
            headerWriter.println("};");
            headerWriter.println();
            headerWriter.println("std::ostream & operator << (std::ostream &, const " + enumName + "&);");
            headerWriter.println();

            codeWriter.println();
            codeWriter.println("#include <ostream>");
            codeWriter.println();
            codeWriter.println("#include \"" + enumName + ".h\"");
            codeWriter.println();
            codeWriter.println("std::ostream & operator << (std::ostream &out, const " + enumName + "&value)");
            codeWriter.println('{');
            codeWriter.println(tab + "switch(value)");
            codeWriter.println(tab + '{');
            first = true;
            for (Entry<String, Integer> entry : fields.entrySet())
            {
                codeWriter.println(tab + "case " + enumName + "::" + entry.getKey() + ':');
                codeWriter.println(tab + tab + "out << \"" + entry.getKey() + "\";");
                codeWriter.println(tab + tab + "break;");

                first = false;
            }
            codeWriter.println(tab + "default:");
            codeWriter.println(tab + tab + "out << \"<unknown>\";");
            codeWriter.println(tab + '}');
            codeWriter.println();
            codeWriter.println(tab + "return out;");
            codeWriter.println('}');
            codeWriter.println();
        }
    }

    public static void main(String[] args)
    {
        try
        {
            run(args);
        }
        catch(Exception exc)
        {
            exc.printStackTrace();
            System.exit(1);
        }
    }
}

পাইথন ৩.৫-তে একটি বন্দর কারণ এটি সম্ভাব্য সহায়ক হিসাবে যথেষ্ট

import re
import collections
import sys
import io
import os

def fail(*args):
    print(*args)
    exit(1)

pattern = re.compile(r'\s*(\w+)\s*(?:=\s*(\d+))?\s*')
tab = "    "

if len(sys.argv) != 4:
    n=0
    for arg in sys.argv:
        print("arg", n, ":", arg, " / ", sys.argv[n])
        n += 1
    fail("Required arguments: <enum name> <input file> <output dir>")

enumName = sys.argv[1]

inputFile = sys.argv[2]

if not os.path.isfile(inputFile):
    fail("Not a file: [" + os.path.abspath(inputFile) + "]")

outputDir = sys.argv[3]

if not os.path.isdir(outputDir):
    fail("Not a directory: [" + os.path.abspath(outputDir) + "]")

headerFile = os.path.join(outputDir, enumName + ".h")
codeFile = os.path.join(outputDir, enumName + ".cpp")

for file in [ headerFile, codeFile ]:
    if os.path.exists(file):
        fail("Will not overwrite file [" + os.path.abspath(file) + "]")

nextValue = 0

fields = collections.OrderedDict()

for line in open(inputFile, 'r'):
    line = line.strip()

    if len(line) == 0:
        continue

    match = pattern.match(line)

    if match == None:
        fail("Syntax error: [" + line + "]")

    fieldName = match.group(1)

    if fieldName in fields:
        fail("Double field name: " + fieldName)

    valueString = match.group(2)

    if valueString != None:
        value = int(valueString)

        if value < nextValue:
            fail("Not a monotonous progression from " + nextValue + " to " + value + " for enum field " + fieldName)

        nextValue = value

    fields[fieldName] = nextValue

    nextValue += 1

headerWriter = open(headerFile, 'w')
codeWriter = open(codeFile, 'w')

try:
    headerWriter.write("\n")
    headerWriter.write("#include <iosfwd>\n")
    headerWriter.write("\n")
    headerWriter.write("enum class " + enumName + "\n")
    headerWriter.write("{\n")
    first = True
    for fieldName, fieldValue in fields.items():
        if not first:
            headerWriter.write(",\n")

        headerWriter.write(tab + fieldName + " = " + str(fieldValue))

        first = False
    if not first:
        headerWriter.write("\n")
    headerWriter.write("};\n")
    headerWriter.write("\n")
    headerWriter.write("std::ostream & operator << (std::ostream &, const " + enumName + "&);\n")
    headerWriter.write("\n")

    codeWriter.write("\n")
    codeWriter.write("#include <ostream>\n")
    codeWriter.write("\n")
    codeWriter.write("#include \"" + enumName + ".h\"\n")
    codeWriter.write("\n")
    codeWriter.write("std::ostream & operator << (std::ostream &out, const " + enumName + "&value)\n")
    codeWriter.write("{\n")
    codeWriter.write(tab + "switch(value)\n")
    codeWriter.write(tab + "{\n")
    for fieldName in fields.keys():
        codeWriter.write(tab + "case " + enumName + "::" + fieldName + ":\n")
        codeWriter.write(tab + tab + "out << \"" + fieldName + "\";\n")
        codeWriter.write(tab + tab + "break;\n")
    codeWriter.write(tab + "default:\n")
    codeWriter.write(tab + tab + "out << \"<unknown>\";\n")
    codeWriter.write(tab + "}\n")
    codeWriter.write("\n")
    codeWriter.write(tab + "return out;\n")
    codeWriter.write("}\n")
    codeWriter.write("\n")
finally:
    headerWriter.close()
    codeWriter.close()

1
আপনার জেনারেটরটি দুটি ভাষায় ভাগ করে নেওয়ার জন্য আপনাকে অনেক ধন্যবাদ :-) তবে সংকলন-সময়ে কীভাবে উত্পন্ন করা যায় সে সম্পর্কে আপনার কোনও ধারণা আছে? উদাহরণস্বরূপ, আমরা যখন ইনপুট ডেটা পরিবর্তন করা হয় তখন সি ++ উত্পন্ন কোডটি রিফ্রেশ করতে সিএমকে স্টেটমেন্ট ব্যবহার করে আপনার জেনারেটরের অনুবাদ করতে পারি? আমার স্বপ্ন হ'ল সি ++ সংকলককে মেটা-প্রোগ্রামিং ( variadic template classএবং constexprফাংশন) ব্যবহার করে সংকলনে এনাম তৈরি করতে বাধ্য করা ।
অলিবরে

ওওহ, যদি কাস্টম সিমেক কমান্ডটি যোগ করা খুব জটিল হয় তবে আপনি নিজের আইডিই স্বয়ংক্রিয়ভাবে বা গিরিরেটরটিকে নিজে কল করতে পারেন এবং উত্স নিয়ন্ত্রণে আউটপুট রাখতে পারেন। কখনও কখনও উত্স নিয়ন্ত্রণে কোড উত্পন্ন করা খুব ভাল ধারণা, যতক্ষণ না এটি অত্যধিক না হয় এবং লোকেরা বুঝতে পারে যে তারা ম্যানুয়াল পরিবর্তনগুলি করার কথা নয়, কারণ আপনি যখন উত্পন্ন ফাইলগুলির ইতিহাসের দিকে তাকান কখনও কখনও আকর্ষণীয় হন 'অদ্ভুত কিছু ডিবাগ করছি এবং সন্দেহ হয় যে জেনারেটরে সাম্প্রতিক পরিবর্তনের ফলে কোনও কিছু ভেঙে গেছে :)
ইয়োমন

সংকলনের সময়ে জিনিস উত্পন্ন করার বিষয়ে, এটি LISP তে খুব সহজ কারণ বাক্য গঠনটি অত্যন্ত পরিষ্কার এবং সহজ। এটি এটিকে গতিশীলভাবে টাইপ করা দ্বারা সহায়তা করেছে, যা এটিকে সংশ্লেষ ছাড়াই বিশিষ্ট এবং পাঠযোগ্য হতে দেয়। সি ++ তে থাকা LISP ম্যাক্রোগুলির সমপরিমাণের জন্য আপনি কী উত্পন্ন করার চেষ্টা করছেন তার এএসটি বর্ণনা করার জন্য খুব জটিল উপায় প্রয়োজন। এবং সি ++ এর জন্য একটি এএসটি কখনও সুন্দর নয় :(
ইয়েমেন

সরাসরি চক্রের পরিবর্তে মেক করুন, এটি সুপার ইজি বিটিডব্লিউ। সন্ধানের মাধ্যমে প্রতিটি .enum ফাইলের জন্য .h এবং .cpp লক্ষ্যমাত্রা উত্পন্ন করুন এবং এই লক্ষ্যগুলি এনাম ডিফগুলির উপর নির্ভরশীল থাকুন, তাই .enum Def ফাইল পরিবর্তন হয়ে গেলে সেগুলি স্বয়ংক্রিয়ভাবে পুনরায় উত্পন্ন হয়। এটা সম্ভবত অনেক সহজ cmake আছে কারণ এটি কিছু এই ধরনের যাদু পূর্ণ কিন্তু আমি নিয়মিত করতে, পিপীলিকা, এবং gradle ব্যবহার করেন, কিন্তু শুধুমাত্র ম্যাভেন, cmake এবং ঘোঁৎ ঘোঁৎ এর :) সীমিত জ্ঞান আছে
ইঔম্যান্

আপনার উত্তরের জন্য ধন্যবাদ :-) আমি মনে করি যে আপনার জেনারেটর সরাসরি সি ++ কোডের মতো enum class Hallo{ First=5, Second=6, Third=7, Fourth=8};অথবা বিভিন্ন লাইনে এনামগুলি সনাক্ত করতে পারলে বেশিরভাগ সি ++ বিকাশকারীরা প্রশংসা করবে :- ডি আপনি কি মনে করেন যে আপনি enumএকটি সি ++ এর মধ্যে সনাক্ত করার জন্য আপনার জেনারেটরটি খাপ খাইয়ে নিতে পারেন? ফাইল? সর্বোত্তম হতে পারে কেবল কোনও ট্যাগ শনাক্ত করার জন্য কোড উত্পন্ন করা /*<Generate enum to string here>*/। তারপরে আপনার জেনারেটর সংশ্লিষ্ট সি ++ উত্পন্ন কোড (পূর্ববর্তী উত্পন্ন কোডের পরিবর্তে) লিখুন। ^ _ ^ কী দুর্দান্ত জেনারেটর তা না? চিয়ার্স :-)
অলিবরে

3

ওপি থেকে অনুরোধ অনুসারে, এখানে বুস্ট প্রিপ্রোসেসর এবং ভারিয়াদিক ম্যাক্রোসের উপর ভিত্তি করে কুরুচিপূর্ণ ম্যাক্রো সমাধানের একটি স্ট্রপ ডাউন সংস্করণ

এটি নির্দিষ্ট উপাদানের জন্য মান নির্ধারণের সাথে সাথে গণকের উপাদানগুলির সিনট্যাক্সের মতো একটি সাধারণ তালিকার অনুমতি দেয়

XXX_ENUM(foo,(a,b,(c,42)));

প্রসারিত হয়

enum foo {
    a,
    b,
    c=42
};

আউটপুট এবং কিছু রূপান্তর ফিরে করতে প্রয়োজনীয় ফাংশনগুলির পাশাপাশি। এই ম্যাক্রো প্রায় যুগ ধরে এখানে রয়েছে এবং আমি নিশ্চিত যে এটির সবচেয়ে কার্যকর উপায়, বা এটি একটি অনুকূল উপায়, তবে এটি তখন থেকেই কাজ করে চলেছে but

পুরো কোডটি আইডিয়োন এবং কলিরু উভয়ই ক্রিয়াকলাপে দেখা যাবে

এর প্রচুর কদর্যতা উপরে; আমি কীভাবে জানতাম তবে মার্কডাউন আমার পছন্দ না করে আমি আপনার চোখগুলি সুরক্ষার জন্য এটি স্পয়লারদের পিছনে রেখে দিতাম।

লাইব্রেরি (একটি একক শিরোলেখ ফাইলের মধ্যে একীভূত)

#include <boost/preprocessor.hpp>
#include <string>
#include <unordered_map>

namespace xxx
{

template<class T>
struct enum_cast_adl_helper { };

template<class E>
E enum_cast( const std::string& s )
{
    return do_enum_cast(s,enum_cast_adl_helper<E>());
}

template<class E>
E enum_cast( const char* cs )
{
    std::string s(cs);
    return enum_cast<E>(s);
}

} // namespace xxx

#define XXX_PP_ARG_N(                             \
          _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
         _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
         _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
         _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
         _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
         _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
         _61,_62,_63,N,...) N

#define XXX_PP_RSEQ_N()                 \
         63,62,61,60,                   \
         59,58,57,56,55,54,53,52,51,50, \
         49,48,47,46,45,44,43,42,41,40, \
         39,38,37,36,35,34,33,32,31,30, \
         29,28,27,26,25,24,23,22,21,20, \
         19,18,17,16,15,14,13,12,11,10, \
         9,8,7,6,5,4,3,2,1,0 

#define XXX_PP_NARG_(...) XXX_PP_ARG_N(__VA_ARGS__)
#define XXX_PP_NARG(...)  XXX_PP_NARG_(__VA_ARGS__,XXX_PP_RSEQ_N())
#define XXX_TUPLE_SIZE_INTERNAL(TUPLE) XXX_PP_NARG TUPLE

#define XXX_TUPLE_CHOICE(i)                            \
  BOOST_PP_APPLY(                                      \
    BOOST_PP_TUPLE_ELEM(                               \
      25, i, (                                         \
        (0), (1), (2), (3), (4), (5), (6), (7), (8),   \
        (9), (10), (11), (12), (13), (14), (15), (16), \
        (17), (18), (19), (20), (21), (22), (23), (24) \
  ) ) )

#define BOOST_PP_BOOL_00  BOOST_PP_BOOL_0
#define BOOST_PP_BOOL_01  BOOST_PP_BOOL_1
#define BOOST_PP_BOOL_02  BOOST_PP_BOOL_2
#define BOOST_PP_BOOL_03  BOOST_PP_BOOL_3
#define BOOST_PP_BOOL_04  BOOST_PP_BOOL_4
#define BOOST_PP_BOOL_05  BOOST_PP_BOOL_5
#define BOOST_PP_BOOL_06  BOOST_PP_BOOL_6
#define BOOST_PP_BOOL_07  BOOST_PP_BOOL_7
#define BOOST_PP_BOOL_08  BOOST_PP_BOOL_8
#define BOOST_PP_BOOL_09  BOOST_PP_BOOL_9
#define BOOST_PP_BOOL_010 BOOST_PP_BOOL_10
#define BOOST_PP_BOOL_011 BOOST_PP_BOOL_11
#define BOOST_PP_BOOL_012 BOOST_PP_BOOL_12
#define BOOST_PP_BOOL_013 BOOST_PP_BOOL_13
#define BOOST_PP_BOOL_014 BOOST_PP_BOOL_14
#define BOOST_PP_BOOL_015 BOOST_PP_BOOL_15
#define BOOST_PP_BOOL_016 BOOST_PP_BOOL_16
#define BOOST_PP_BOOL_017 BOOST_PP_BOOL_17
#define BOOST_PP_BOOL_018 BOOST_PP_BOOL_18
#define BOOST_PP_BOOL_019 BOOST_PP_BOOL_19
#define BOOST_PP_BOOL_020 BOOST_PP_BOOL_20
#define BOOST_PP_BOOL_021 BOOST_PP_BOOL_21
#define BOOST_PP_BOOL_022 BOOST_PP_BOOL_22
#define BOOST_PP_BOOL_023 BOOST_PP_BOOL_23
#define BOOST_PP_BOOL_024 BOOST_PP_BOOL_24
#define BOOST_PP_BOOL_025 BOOST_PP_BOOL_25
#define BOOST_PP_BOOL_026 BOOST_PP_BOOL_26
#define BOOST_PP_BOOL_027 BOOST_PP_BOOL_27
#define BOOST_PP_BOOL_028 BOOST_PP_BOOL_28
#define BOOST_PP_BOOL_029 BOOST_PP_BOOL_29
#define BOOST_PP_BOOL_030 BOOST_PP_BOOL_30
#define BOOST_PP_BOOL_031 BOOST_PP_BOOL_31
#define BOOST_PP_BOOL_032 BOOST_PP_BOOL_32
#define BOOST_PP_BOOL_033 BOOST_PP_BOOL_33
#define BOOST_PP_BOOL_034 BOOST_PP_BOOL_34
#define BOOST_PP_BOOL_035 BOOST_PP_BOOL_35
#define BOOST_PP_BOOL_036 BOOST_PP_BOOL_36
#define BOOST_PP_BOOL_037 BOOST_PP_BOOL_37
#define BOOST_PP_BOOL_038 BOOST_PP_BOOL_38
#define BOOST_PP_BOOL_039 BOOST_PP_BOOL_39
#define BOOST_PP_BOOL_040 BOOST_PP_BOOL_40
#define BOOST_PP_BOOL_041 BOOST_PP_BOOL_41
#define BOOST_PP_BOOL_042 BOOST_PP_BOOL_42
#define BOOST_PP_BOOL_043 BOOST_PP_BOOL_43
#define BOOST_PP_BOOL_044 BOOST_PP_BOOL_44
#define BOOST_PP_BOOL_045 BOOST_PP_BOOL_45
#define BOOST_PP_BOOL_046 BOOST_PP_BOOL_46
#define BOOST_PP_BOOL_047 BOOST_PP_BOOL_47
#define BOOST_PP_BOOL_048 BOOST_PP_BOOL_48
#define BOOST_PP_BOOL_049 BOOST_PP_BOOL_49
#define BOOST_PP_BOOL_050 BOOST_PP_BOOL_50
#define BOOST_PP_BOOL_051 BOOST_PP_BOOL_51
#define BOOST_PP_BOOL_052 BOOST_PP_BOOL_52
#define BOOST_PP_BOOL_053 BOOST_PP_BOOL_53
#define BOOST_PP_BOOL_054 BOOST_PP_BOOL_54
#define BOOST_PP_BOOL_055 BOOST_PP_BOOL_55
#define BOOST_PP_BOOL_056 BOOST_PP_BOOL_56
#define BOOST_PP_BOOL_057 BOOST_PP_BOOL_57
#define BOOST_PP_BOOL_058 BOOST_PP_BOOL_58
#define BOOST_PP_BOOL_059 BOOST_PP_BOOL_59
#define BOOST_PP_BOOL_060 BOOST_PP_BOOL_60
#define BOOST_PP_BOOL_061 BOOST_PP_BOOL_61
#define BOOST_PP_BOOL_062 BOOST_PP_BOOL_62
#define BOOST_PP_BOOL_063 BOOST_PP_BOOL_63

#define BOOST_PP_DEC_00  BOOST_PP_DEC_0
#define BOOST_PP_DEC_01  BOOST_PP_DEC_1
#define BOOST_PP_DEC_02  BOOST_PP_DEC_2
#define BOOST_PP_DEC_03  BOOST_PP_DEC_3
#define BOOST_PP_DEC_04  BOOST_PP_DEC_4
#define BOOST_PP_DEC_05  BOOST_PP_DEC_5
#define BOOST_PP_DEC_06  BOOST_PP_DEC_6
#define BOOST_PP_DEC_07  BOOST_PP_DEC_7
#define BOOST_PP_DEC_08  BOOST_PP_DEC_8
#define BOOST_PP_DEC_09  BOOST_PP_DEC_9
#define BOOST_PP_DEC_010 BOOST_PP_DEC_10
#define BOOST_PP_DEC_011 BOOST_PP_DEC_11
#define BOOST_PP_DEC_012 BOOST_PP_DEC_12
#define BOOST_PP_DEC_013 BOOST_PP_DEC_13
#define BOOST_PP_DEC_014 BOOST_PP_DEC_14
#define BOOST_PP_DEC_015 BOOST_PP_DEC_15
#define BOOST_PP_DEC_016 BOOST_PP_DEC_16
#define BOOST_PP_DEC_017 BOOST_PP_DEC_17
#define BOOST_PP_DEC_018 BOOST_PP_DEC_18
#define BOOST_PP_DEC_019 BOOST_PP_DEC_19
#define BOOST_PP_DEC_020 BOOST_PP_DEC_20
#define BOOST_PP_DEC_021 BOOST_PP_DEC_21
#define BOOST_PP_DEC_022 BOOST_PP_DEC_22
#define BOOST_PP_DEC_023 BOOST_PP_DEC_23
#define BOOST_PP_DEC_024 BOOST_PP_DEC_24
#define BOOST_PP_DEC_025 BOOST_PP_DEC_25
#define BOOST_PP_DEC_026 BOOST_PP_DEC_26
#define BOOST_PP_DEC_027 BOOST_PP_DEC_27
#define BOOST_PP_DEC_028 BOOST_PP_DEC_28
#define BOOST_PP_DEC_029 BOOST_PP_DEC_29
#define BOOST_PP_DEC_030 BOOST_PP_DEC_30
#define BOOST_PP_DEC_031 BOOST_PP_DEC_31
#define BOOST_PP_DEC_032 BOOST_PP_DEC_32
#define BOOST_PP_DEC_033 BOOST_PP_DEC_33
#define BOOST_PP_DEC_034 BOOST_PP_DEC_34
#define BOOST_PP_DEC_035 BOOST_PP_DEC_35
#define BOOST_PP_DEC_036 BOOST_PP_DEC_36
#define BOOST_PP_DEC_037 BOOST_PP_DEC_37
#define BOOST_PP_DEC_038 BOOST_PP_DEC_38
#define BOOST_PP_DEC_039 BOOST_PP_DEC_39
#define BOOST_PP_DEC_040 BOOST_PP_DEC_40
#define BOOST_PP_DEC_041 BOOST_PP_DEC_41
#define BOOST_PP_DEC_042 BOOST_PP_DEC_42
#define BOOST_PP_DEC_043 BOOST_PP_DEC_43
#define BOOST_PP_DEC_044 BOOST_PP_DEC_44
#define BOOST_PP_DEC_045 BOOST_PP_DEC_45
#define BOOST_PP_DEC_046 BOOST_PP_DEC_46
#define BOOST_PP_DEC_047 BOOST_PP_DEC_47
#define BOOST_PP_DEC_048 BOOST_PP_DEC_48
#define BOOST_PP_DEC_049 BOOST_PP_DEC_49
#define BOOST_PP_DEC_050 BOOST_PP_DEC_50
#define BOOST_PP_DEC_051 BOOST_PP_DEC_51
#define BOOST_PP_DEC_052 BOOST_PP_DEC_52
#define BOOST_PP_DEC_053 BOOST_PP_DEC_53
#define BOOST_PP_DEC_054 BOOST_PP_DEC_54
#define BOOST_PP_DEC_055 BOOST_PP_DEC_55
#define BOOST_PP_DEC_056 BOOST_PP_DEC_56
#define BOOST_PP_DEC_057 BOOST_PP_DEC_57
#define BOOST_PP_DEC_058 BOOST_PP_DEC_58
#define BOOST_PP_DEC_059 BOOST_PP_DEC_59
#define BOOST_PP_DEC_060 BOOST_PP_DEC_60
#define BOOST_PP_DEC_061 BOOST_PP_DEC_61
#define BOOST_PP_DEC_062 BOOST_PP_DEC_62
#define BOOST_PP_DEC_063 BOOST_PP_DEC_63

#define XXX_TO_NUMx(x) 0 ## x
#define XXX_TO_NUM(x) BOOST_PP_ADD(0,XXX_TO_NUMx(x))
#define XXX_STRINGIZEX(x) # x
#define XXX_VSTRINGIZE_SINGLE(a,b,x) XXX_STRINGIZE(x)
#define XXX_VSTRINGIZE_TUPLE(tpl) XXX_TUPLE_FOR_EACH(XXX_VSTRINGIZE_SINGLE,,tpl)
#define XXX_TUPLE_SIZE(TUPLE) XXX_TO_NUM(XXX_TUPLE_CHOICE(XXX_TUPLE_SIZE_INTERNAL(TUPLE)))
#define XXX_TUPLE_FOR_EACH(MACRO,DATA,TUPLE) BOOST_PP_LIST_FOR_EACH(MACRO,DATA,BOOST_PP_TUPLE_TO_LIST(XXX_TUPLE_SIZE(TUPLE),TUPLE))
#define XXX_STRINGIZE(x) XXX_STRINGIZEX(x)
#define XXX_VSTRINGIZE(...) XXX_VSTRINGIZE_TUPLE((__VA_ARGS__))
#define XXX_CAST_TO_VOID_ELEMENT(r,data,elem) (void)(elem);
#define XXX_CAST_TO_VOID_INTERNAL(TUPLE) XXX_TUPLE_FOR_EACH(XXX_CAST_TO_VOID_ELEMENT,,TUPLE)    
#define XXX_CAST_TO_VOID(...) XXX_CAST_TO_VOID_INTERNAL((__VA_ARGS__))
#define XXX_ENUM_EXTRACT_SP(en) BOOST_PP_TUPLE_ELEM(XXX_TUPLE_SIZE(en),0,en) = BOOST_PP_TUPLE_ELEM(XXX_TUPLE_SIZE(en),1,en)
#define XXX_ENUM_ELEMENT(r,data,elem) BOOST_PP_IF( XXX_TUPLE_SIZE(elem), XXX_ENUM_EXTRACT_SP(elem), elem) ,
#define XXX_ENUM_EXTRACT_ELEMENT(en) BOOST_PP_TUPLE_ELEM(XXX_TUPLE_SIZE(en),0,en)
#define XXX_ENUM_CASE_ELEMENT(en) BOOST_PP_IF( XXX_TUPLE_SIZE(en), XXX_ENUM_EXTRACT_ELEMENT(en), en )
#define XXX_ENUM_CASE(r,data,elem) case data :: XXX_ENUM_CASE_ELEMENT(elem) : return #data "::" XXX_STRINGIZE(XXX_ENUM_CASE_ELEMENT(elem));
#define XXX_ENUM_IFELSE(r,data,elem) else if( en == data :: XXX_ENUM_CASE_ELEMENT(elem)) { return #data "::" XXX_STRINGIZE(XXX_ENUM_CASE_ELEMENT(elem)); }
#define XXX_ENUM_CASTLIST(r,data,elem) { XXX_STRINGIZE(XXX_ENUM_CASE_ELEMENT(elem)), data :: XXX_ENUM_CASE_ELEMENT(elem) },
#define XXX_ENUM_QUALIFIED_CASTLIST(r,data,elem) { #data "::" XXX_STRINGIZE(XXX_ENUM_CASE_ELEMENT(elem)), data :: XXX_ENUM_CASE_ELEMENT(elem) },

#define XXX_ENUM_INTERNAL(TYPE,NAME,TUPLE)                       \
enum TYPE                                                        \
{                                                                \
   XXX_TUPLE_FOR_EACH(XXX_ENUM_ELEMENT,,TUPLE)                   \
   BOOST_PP_CAT(last_enum_,NAME)                                 \
};                                                               \
                                                                 \
inline                                                           \
const char* to_string( NAME en )                                 \
{                                                                \
   if(false)                                                     \
   {                                                             \
   }                                                             \
   XXX_TUPLE_FOR_EACH(XXX_ENUM_IFELSE,NAME,TUPLE)                \
   else if( en == NAME :: BOOST_PP_CAT(last_enum_,NAME) )        \
   {                                                             \
     return XXX_VSTRINGIZE(NAME,::,BOOST_PP_CAT(last_enum_,NAME));  \
   }                                                             \
   else                                                          \
   {                                                             \
     return "Invalid enum value specified for " # NAME;          \
   }                                                             \
}                                                                \
                                                                 \
inline                                                           \
std::ostream& operator<<( std::ostream& os, const NAME& en )     \
{                                                                \
   os << to_string(en);                                          \
   return os;                                                    \
}                                                                \
                                                                 \
inline                                                           \
NAME do_enum_cast( const std::string& s, const ::xxx::enum_cast_adl_helper<NAME>& ) \
{                                                                \
  static const std::unordered_map<std::string,NAME> map =        \
  {                                                              \
    XXX_TUPLE_FOR_EACH(XXX_ENUM_CASTLIST,NAME,TUPLE)             \
    XXX_TUPLE_FOR_EACH(XXX_ENUM_QUALIFIED_CASTLIST,NAME,TUPLE)   \
  };                                                             \
                                                                 \
  auto cit = map.find(s);                                        \
  if( cit == map.end() )                                         \
  {                                                              \
    throw std::runtime_error("Invalid value to cast to enum");   \
  }                                                              \
  return cit->second;                                            \
}

#define XXX_ENUM(NAME,TUPLE) XXX_ENUM_INTERNAL(NAME,NAME,TUPLE)
#define XXX_ENUM_CLASS(NAME,TUPLE) XXX_ENUM_INTERNAL(class NAME,NAME,TUPLE)
#define XXX_ENUM_CLASS_TYPE(NAME,TYPE,TUPLE) XXX_ENUM_INTERNAL(class NAME : TYPE,NAME,TUPLE)
#define XXX_ENUM_TYPE(NAME,TYPE,TUPLE) XXX_ENUM_INTERNAL(NAME : TYPE,NAME,TUPLE)

ব্যবহার

#include "xxx_enum.h"  // the above lib
#include <iostream>

XXX_ENUM(foo,(a,b,(c,42)));

int main()
{
  std::cout << "foo::a = "            << foo::a            <<'\n';
  std::cout << "(int)foo::c = "       << (int)foo::c       <<'\n';
  std::cout << "to_string(foo::b) = " << to_string(foo::b) <<'\n';
  std::cout << "xxx::enum_cast<foo>(\"b\") = " << xxx::enum_cast<foo>("b") <<'\n';
}

সংকলন (এর মধ্যে কপি পেস্ট শিরোনাম main.cpp)

> g++ --version | sed 1q
g++ (GCC) 4.9.2

> g++ -std=c++14 -pedantic -Wall -Wextra main.cpp
main.cpp:268:31: warning: extra ';' [-Wpedantic]
     XXX_ENUM(foo,(a,b,(c,42)));
                               ^

আউটপুট

foo::a = foo::a
(int)foo::c = 42
to_string(foo::b) = foo::b
xxx::enum_cast<foo>("b") = foo::b

5
এই কোড ব্লকটি রূপকথিত কালো যাদুটির বিস্ময়কর ল্যান্ডস্কেপের মধ্য দিয়ে একটি উন্মাদ যাত্রা। আমি পৌঁছে আসলে স্বস্তি অনুভব করেছি main- হোম, মিষ্টি বাড়ি!
কোয়ান্টিন

আউটপুট চেক করতে সবেমাত্র কলিরুতে একটি লিঙ্ক যুক্ত করেছেন (কিছু সতর্কতা রয়েছে, আপনার উত্তরের লিঙ্কটিতে ক্লিক করুন)। আমিও লিবি / ব্যবহারে বিভক্ত হয়েছি। স্টাফগুলি কি namespace xxxশিরোনামের জায়গায় চলে যেতে পারে? আপনি আপনার ব্যবহারের ভূমিকাতে বলতে পারেন boost/preprocessor.hppএবং অতএব উত্তরটি আধুনিক সি ++ এর সাথে সামঞ্জস্যপূর্ণ । সতর্কতাগুলি ঠিক করুন এবং আরও ভাল মানের জন্য উত্স কোডটি কিছুটা সাফ করুন।
অলিব্রে

@ অলিব্রে: আমার লাইব্রেরিতে 5 টি ভিন্ন ভিন্ন শিরোনাম বলে মনে হয় এটি কপিপাস্টড। এনাম_কাস্টটি অন্য একটি সাধারণ অংশ থেকে এসেছে তবে আমি ম্যাক্রোতে do_enum_cast কী জন্য তা দেখার জন্য এটিও যুক্ত করার চিন্তা করলাম .. সতর্কতাগুলি কেবলমাত্র আমার ব্যবহারকারীর আর্গুমেন্ট সহ ভিআইমের পক্ষ থেকে main<tab>। আমি মনে করি না যে এই কোডটি সত্যিই পরিষ্কার করা যায়, এটি কেবল কী করা যায় এবং কী করা উচিত নয় তা দেখানোর জন্য;) এবং আমি যদি এটি এখানে পরিবর্তন করি তবে আমি আর কোডটি প্রযোজনায় ব্যবহার করি না ... এটি সেই নাজুক জিনিসের একটি is এটি একবারে আপনার কাজ করার পরে আরও ভালভাবে স্পর্শ না করে যেহেতু এটি কোনওভাবেই ভবিষ্যদ্বাণী করতে পারে না এমনভাবে ধসে যায়।
প্লাজমাএইচ

ঠিক আছে প্লাজমা, আমি দেখি এটি ধারণার প্রমাণ হিসাবে দেখা যেতে পারে । তবে ভোট গ্রহণের জন্য অনেক বেশি ম্যাক্রো ওভারহেড রয়েছে। তবুও ভাগ করে নেওয়ার জন্য ধন্যবাদ। চিয়ার্স
অলিবরে

হাই প্লাজমা আমি একটি গভীর উত্স কোড সাফাই + সম্পাদনা করেছি সংকলন এবং রান আউটপুট দ্বারা সম্পূর্ণ। আমার সম্পাদনা পরীক্ষা করুন । আমি আশা করি এটি আপনার পক্ষে ঠিক আছে। উত্তরটি কি আরও মূল্যবান? তবে ম্যাক্রো ওভারহেড এখনও ভয়ঙ্কর! আপনার দিনটি
শুভ হোক

2

নিম্নলিখিত সমাধানটি a এর উপর ভিত্তি করে তৈরি std::array<std::string,N> প্রদত্ত এনামের জন্য ।

জন্য enumকরতে std::stringরূপান্তর আমরা শুধু enum কাস্ট করতে পারেন size_tএবং অ্যারে থেকে স্ট্রিং অনুসন্ধান। অপারেশনটি হ'ল (1) এবং কোনও গাদা বরাদ্দ প্রয়োজন।

#include <boost/preprocessor/seq/transform.hpp>
#include <boost/preprocessor/seq/enum.hpp>
#include <boost/preprocessor/stringize.hpp>

#include <string>
#include <array>
#include <iostream>

#define STRINGIZE(s, data, elem) BOOST_PP_STRINGIZE(elem)

// ENUM
// ============================================================================
#define ENUM(X, SEQ) \
struct X {   \
    enum Enum {BOOST_PP_SEQ_ENUM(SEQ)}; \
    static const std::array<std::string,BOOST_PP_SEQ_SIZE(SEQ)> array_of_strings() { \
        return {{BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(STRINGIZE, 0, SEQ))}}; \
    } \
    static std::string to_string(Enum e) { \
        auto a = array_of_strings(); \
        return a[static_cast<size_t>(e)]; \
    } \
}

জন্য std::stringকরতে enumরূপান্তর আমরা অ্যারের উপর একটি রৈখিক অনুসন্ধান করতে হবে এবং অ্যারের সূচক তাড়িয়ে দেনenum

ব্যবহারের উদাহরণগুলির সাথে এখানে এটি ব্যবহার করে দেখুন: http://coliru.stacked-crooked.com/a/e4212f93bee65076

সম্পাদনা করুন: আমার সমাধানটি পুনরায় কাজ করেছে যাতে কাস্টম এনুম কোনও শ্রেণীর অভ্যন্তরে ব্যবহার করা যায়।


আপনার আকর্ষণীয় উত্তরের জন্য আপনাকে ধন্যবাদ। একটি শ্রেণীর মধ্যে আপনার ম্যাক্রো ব্যবহার করার জন্য দয়া করে আপনার প্রস্তাবটি পুনরায় কাজ করুন। Coliru.stacked-crooked.com/a/00d362eba836d04b দেখুন constexprএবং noexeptসম্ভব হলে কীওয়ার্ডগুলি ব্যবহার করার চেষ্টা করুন । চিয়ার্স :-)
অলিব্রে

প্রশ্নটি এই প্রয়োজনীয়টি নির্দিষ্ট করে নি।
এফকারিয়া

প্রশ্ন আপডেট হয়েছে (উদাহরণ দেখুন)। অন্য দুটি প্রয়োজনীয়তা: (১) এনামের প্রকারের প্রকার এবং (২) মানগুলি ক্রম 0, 1, 2 থেকে আলাদা হতে পারে ...
অলিবার

আমি আমার সমাধানটিকে পুনরায় কাজ করেছিলাম এটি কোনও শ্রেণীর অভ্যন্তরে ব্যবহার করা যেতে পারে। যদিও মানগুলি 0,1,2 থেকে আলাদা করা যায় তা আমি খুঁজে পাইনি, যদিও।
এফকারিয়া

হাই এফকারিয়া আপনার পুনর্নির্মাণের জন্য আপনাকে অনেক ধন্যবাদ। একই শ্রেণীর বেশ কয়েকটি এনামকে সমর্থন করার জন্য এবং enum class X : Typeফর্ম্যাটটি সমর্থন করার জন্য আমি কিছু পরিবর্তন করেছি । দয়া করে আমার অবদানটি পর্যালোচনা করুন: coliru.stacked-crooked.com/a/b02db9190d3491a3 আমার পরিবর্তনগুলি সম্পর্কে আপনার কী ধারণা? এনামের মধ্যে সেট মানগুলি সমর্থন করার কোনও ধারণা কি আপনার আছে? enum E{A=3, B=6, C=A-B};চিয়ার্স উদাহরণ
ওলিব্রে

2

এই সারকথা সি ++ variadic টেমপ্লেট উপর ভিত্তি করে একটি সহজ ম্যাপিং প্রদান করে।

এটি গিস্ট থেকে টাইপ-ভিত্তিক মানচিত্রের একটি সি ++ 17-সরলিকৃত সংস্করণ :

#include <cstring> // http://stackoverflow.com/q/24520781

template<typename KeyValue, typename ... RestOfKeyValues>
struct map {
  static constexpr typename KeyValue::key_t get(const char* val) noexcept {
    if constexpr (sizeof...(RestOfKeyValues)==0)  // C++17 if constexpr
      return KeyValue::key; // Returns last element
    else {
      static_assert(KeyValue::val != nullptr,
                  "Only last element may have null name");
      return strcmp(val, KeyValue::val()) 
            ? map<RestOfKeyValues...>::get(val) : KeyValue::key;
    }
  }
  static constexpr const char* get(typename KeyValue::key_t key) noexcept {
    if constexpr (sizeof...(RestOfKeyValues)==0)
      return (KeyValue::val != nullptr) && (key == KeyValue::key)
            ? KeyValue::val() : "";
    else
      return (key == KeyValue::key) 
            ? KeyValue::val() : map<RestOfKeyValues...>::get(key);
  }
};

template<typename Enum, typename ... KeyValues>
class names {
  typedef map<KeyValues...> Map;
public:
  static constexpr Enum get(const char* nam) noexcept {
    return Map::get(nam);
  }
  static constexpr const char* get(Enum key) noexcept {
    return Map::get(key);
  }
};

একটি উদাহরণ ব্যবহার:

enum class fasion {
    fancy,
    classic,
    sporty,
    emo,
    __last__ = emo,
    __unknown__ = -1
};

#define NAME(s) static inline constexpr const char* s() noexcept {return #s;}
namespace name {
    NAME(fancy)
    NAME(classic)
    NAME(sporty)
    NAME(emo)
}

template<auto K, const char* (*V)()>  // C++17 template<auto>
struct _ {
    typedef decltype(K) key_t;
    typedef decltype(V) name_t;
    static constexpr key_t  key = K; // enum id value
    static constexpr name_t val = V; // enum id name
};

typedef names<fasion,
    _<fasion::fancy, name::fancy>,
    _<fasion::classic, name::classic>,
    _<fasion::sporty, name::sporty>,
    _<fasion::emo, name::emo>,
    _<fasion::__unknown__, nullptr>
> fasion_names;

map<KeyValues...>উভয় নির্দেশাবলী মধ্যে ব্যবহার করা যেতে পারে:

  • fasion_names::get(fasion::emo)
  • fasion_names::get("emo")

এই উদাহরণটি গডবোল্ট.অর্গ.এতে উপলব্ধ

int main ()
{
  constexpr auto str = fasion_names::get(fasion::emo);
  constexpr auto fsn = fasion_names::get(str);
  return (int) fsn;
}

থেকে ফলাফল gcc-7 -std=c++1z -Ofast -S

main:
        mov     eax, 3
        ret

1
খুব আকর্ষণীয় মেটা-প্রোগ্রামিং উপায়। আমি স্বায়ত্তশাসিত হওয়ার জন্য উত্তরটি কিছুটা সহজ করার চেষ্টা করেছি (জিস্টের লিঙ্কের উপর নির্ভরতা ছাড়াই) সংক্ষিপ্ত এবং বোধগম্য হওয়ার জন্য অবশেষে আমি আপনার উত্তরটি অনেক সম্পাদনা করেছি। আপনি কি এখনও আমার পরিবর্তনের সাথে একমত? চিয়ার্স ;-)
অলিব্রে

2

সঠিকভাবে স্ট্রিংয়ে টাইপ রূপান্তরিত করার সমস্যাটি সহ আমিও দীর্ঘকাল ধরে এই সমস্যা থেকে হতাশ হয়েছি। যাইহোক, শেষ সমস্যার জন্য, আমি সমাধানটি ব্যাখ্যা করে বিস্মিত হয়েছি কি স্ট্যান্ডার্ড সি ++ এ ভেরিয়েবলের ধরণটি ছাপানো সম্ভব? , আমি কি কনসেক্সট্রপ উপায়ে সি ++ টাইপের নাম পেতে পারি? । এই কৌশলটি ব্যবহার করে, স্ট্রিং হিসাবে এনাম মান পাওয়ার জন্য একটি অ্যানালগাস ফাংশন তৈরি করা যেতে পারে:

#include <iostream>
using namespace std;

class static_string
{
    const char* const p_;
    const std::size_t sz_;

public:
    typedef const char* const_iterator;

    template <std::size_t N>
    constexpr static_string(const char(&a)[N]) noexcept
        : p_(a)
        , sz_(N - 1)
    {}

    constexpr static_string(const char* p, std::size_t N) noexcept
        : p_(p)
        , sz_(N)
    {}

    constexpr const char* data() const noexcept { return p_; }
    constexpr std::size_t size() const noexcept { return sz_; }

    constexpr const_iterator begin() const noexcept { return p_; }
    constexpr const_iterator end()   const noexcept { return p_ + sz_; }

    constexpr char operator[](std::size_t n) const
    {
        return n < sz_ ? p_[n] : throw std::out_of_range("static_string");
    }
};

inline std::ostream& operator<<(std::ostream& os, static_string const& s)
{
    return os.write(s.data(), s.size());
}

/// \brief Get the name of a type
template <class T>
static_string typeName()
{
#ifdef __clang__
    static_string p = __PRETTY_FUNCTION__;
    return static_string(p.data() + 30, p.size() - 30 - 1);
#elif defined(_MSC_VER)
    static_string p = __FUNCSIG__;
    return static_string(p.data() + 37, p.size() - 37 - 7);
#endif

}

namespace details
{
    template <class Enum>
    struct EnumWrapper
    {
        template < Enum enu >
        static static_string name()
        {
#ifdef __clang__
            static_string p = __PRETTY_FUNCTION__;
            static_string enumType = typeName<Enum>();
            return static_string(p.data() + 73 + enumType.size(), p.size() - 73 - enumType.size() - 1);
#elif defined(_MSC_VER)
            static_string p = __FUNCSIG__;
            static_string enumType = typeName<Enum>();
            return static_string(p.data() + 57 + enumType.size(), p.size() - 57 - enumType.size() - 7);
#endif
        }
    };
}

/// \brief Get the name of an enum value
template <typename Enum, Enum enu>
static_string enumName()
{
    return details::EnumWrapper<Enum>::template name<enu>();
}

enum class Color
{
    Blue = 0,
    Yellow = 1
};


int main() 
{
    std::cout << "_" << typeName<Color>() << "_"  << std::endl;
    std::cout << "_" << enumName<Color, Color::Blue>() << "_"  << std::endl;
    return 0;
}

উপরের কোডটি কেবল ক্ল্যাং ( https://ideone.com/je5Quv দেখুন ) এবং VS2015 এ পরীক্ষা করা হয়েছে , তবে পূর্ণসংখ্যার ধ্রুবকগুলির সাথে কিছুটা ফিড করে অন্যান্য সংকলকগুলির সাথে মানিয়ে নেওয়া উচিত। অবশ্যই এটি হুডের অধীনে এখনও ম্যাক্রোগুলি ব্যবহার করে তবে কমপক্ষে একটি এনাম বাস্তবায়নে অ্যাক্সেসের প্রয়োজন হয় না।


এটি g ++ 6.3.0 এবং C ++ 14 দিয়ে ব্যর্থ হয়।
einpoklum

আকর্ষণীয় কারণ এনাম এটিকে ম্যাক্রোতে আবদ্ধ না করেই সাধারণভাবে ঘোষণা করা যেতে পারে। যদিও আমি সংকলক-নির্ভরতা এবং যাদু স্থির পছন্দ করি না।
zett42

2

আমি @ এন্ট্রন থেকে ধারণাটি নিয়েছি এবং এটি আলাদাভাবে প্রয়োগ করেছি: একটি সত্য এনুম ক্লাস তৈরি করছি

এই প্রয়োগটি মূল প্রশ্নে তালিকাভুক্ত সমস্ত প্রয়োজনীয়তা পূরণ করে তবে বর্তমানে কেবল একটি আসল সীমাবদ্ধতা রয়েছে : এটি ধরে নেয় এনুম মানগুলি সরবরাহ করা হয় না বা সরবরাহ করা হয় তবে অবশ্যই 0 দিয়ে শুরু করতে হবে এবং ফাঁক ছাড়াই ধারাবাহিকভাবে এগিয়ে যেতে হবে।

এটি কোনও অভ্যন্তরীণ সীমাবদ্ধতা নয় - কেবলমাত্র আমি অ্যাড-হক এনুম মান ব্যবহার করি না। যদি এটির প্রয়োজন হয় তবে কেউ traditionalতিহ্যবাহী স্যুইচ / কেস প্রয়োগের সাথে ভেক্টর লুকআপ প্রতিস্থাপন করতে পারেন।

সমাধান ইনলাইন ভেরিয়েবলের জন্য কিছু সি ++ 17 ব্যবহার করে তবে প্রয়োজনে এটি সহজেই এড়ানো যায়। এটি বুস্ট ব্যবহার করে: সরলতার কারণে ছাঁটাই করে

সর্বাধিক গুরুত্বপূর্ণভাবে, এটি কোডের 30 টি লাইন এবং কোনও কালো যাদু ম্যাক্রোগুলি নেয়। কোডটি নীচে রয়েছে। এটি শিরোনামে রাখা এবং একাধিক সংকলন মডিউলগুলিতে অন্তর্ভুক্ত বোঝানো হয়েছে।

এটি এই থ্রেডের আগে যেমন পরামর্শ দেওয়া হয়েছিল তেমনভাবে ব্যবহার করা যেতে পারে:

ENUM(Channel, int, Red, Green = 1, Blue)
std::out << "My name is " << Channel::Green;
//prints My name is Green

এটি দরকারী কিনা এবং কীভাবে এটি আরও উন্নত করা যায় তা দয়া করে আমাকে জানান P


#include <boost/algorithm/string.hpp>   
struct EnumSupportBase {
  static std::vector<std::string> split(const std::string s, char delim) {
    std::stringstream ss(s);
    std::string item;
    std::vector<std::string> tokens;
    while (std::getline(ss, item, delim)) {
        auto pos = item.find_first_of ('=');
        if (pos != std::string::npos)
            item.erase (pos);
        boost::trim (item);
        tokens.push_back(item);
    }
    return tokens;
  }
};
#define ENUM(EnumName, Underlying, ...) \
    enum class EnumName : Underlying { __VA_ARGS__, _count }; \
    struct EnumName ## Support : EnumSupportBase { \
        static inline std::vector<std::string> _token_names = split(#__VA_ARGS__, ','); \
        static constexpr const char* get_name(EnumName enum_value) { \
            int index = (int)enum_value; \
            if (index >= (int)EnumName::_count || index < 0) \
               return "???"; \
            else \
               return _token_names[index].c_str(); \
        } \
    }; \
    inline std::ostream& operator<<(std::ostream& os, const EnumName & es) { \
        return os << EnumName##Support::get_name(es); \
    } 

2

যতক্ষণ আপনি .h/.cppপ্রতিটি প্রশ্নের যোগ্য এনামের জন্য পৃথক জুটি লেখার বিষয়ে ঠিক আছেন , এই সমাধানটি প্রায় একই সিনট্যাক্স এবং নিয়মিত সি ++ এনাম হিসাবে দক্ষতার সাথে কাজ করে:

// MyEnum.h
#include <EnumTraits.h>
#ifndef ENUM_INCLUDE_MULTI
#pragma once
#end if

enum MyEnum : int ETRAITS
{
    EDECL(AAA) = -8,
    EDECL(BBB) = '8',
    EDECL(CCC) = AAA + BBB
};

.cppফাইল boilerplate, 3 লাইন হল:

// MyEnum.cpp
#define ENUM_DEFINE MyEnum
#define ENUM_INCLUDE <MyEnum.h>
#include <EnumTraits.inl>

ব্যবহারের উদাহরণ:

for (MyEnum value : EnumTraits<MyEnum>::GetValues())
    std::cout << EnumTraits<MyEnum>::GetName(value) << std::endl;

কোড

এই সমাধানটির জন্য 2 উত্স ফাইলের প্রয়োজন:

// EnumTraits.h
#pragma once
#include <string>
#include <unordered_map>
#include <vector>

#define ETRAITS
#define EDECL(x) x

template <class ENUM>
class EnumTraits
{
public:
    static const std::vector<ENUM>& GetValues()
    {
        return values;
    }

    static ENUM GetValue(const char* name)
    {
        auto match = valueMap.find(name);
        return (match == valueMap.end() ? ENUM() : match->second);
    }

    static const char* GetName(ENUM value)
    {
        auto match = nameMap.find(value);
        return (match == nameMap.end() ? nullptr : match->second);
    }

public:
    EnumTraits() = delete;

    using vector_type = std::vector<ENUM>;
    using name_map_type = std::unordered_map<ENUM, const char*>;
    using value_map_type = std::unordered_map<std::string, ENUM>;

private:
    static const vector_type values;
    static const name_map_type nameMap;
    static const value_map_type valueMap;
};

struct EnumInitGuard{ constexpr const EnumInitGuard& operator=(int) const { return *this; } };
template <class T> constexpr T& operator<<=(T&& x, const EnumInitGuard&) { return x; }

...এবং

// EnumTraits.inl
#define ENUM_INCLUDE_MULTI

#include ENUM_INCLUDE
#undef ETRAITS
#undef EDECL

using EnumType = ENUM_DEFINE;
using TraitsType = EnumTraits<EnumType>;
using VectorType = typename TraitsType::vector_type;
using NameMapType = typename TraitsType::name_map_type;
using ValueMapType = typename TraitsType::value_map_type;
using NamePairType = typename NameMapType::value_type;
using ValuePairType = typename ValueMapType::value_type;

#define ETRAITS ; const VectorType TraitsType::values
#define EDECL(x) EnumType::x <<= EnumInitGuard()
#include ENUM_INCLUDE
#undef ETRAITS
#undef EDECL

#define ETRAITS ; const NameMapType TraitsType::nameMap
#define EDECL(x) NamePairType(EnumType::x, #x) <<= EnumInitGuard()
#include ENUM_INCLUDE
#undef ETRAITS
#undef EDECL

#define ETRAITS ; const ValueMapType TraitsType::valueMap
#define EDECL(x) ValuePairType(#x, EnumType::x) <<= EnumInitGuard()
#include ENUM_INCLUDE
#undef ETRAITS
#undef EDECL

ব্যাখ্যা

এই বাস্তবায়নটি এই সত্যটি কাজে লাগায় যে এনাম সংজ্ঞাটির উপাদানগুলির ব্রেসড তালিকাটি বর্গ সদস্যের আরম্ভের জন্য ব্রেসড ইনিশিয়ালাইজার তালিকা হিসাবেও ব্যবহার করা যেতে পারে।

যখন ETRAITSপ্রসঙ্গে মূল্যায়ন করা হয় EnumTraits.inl, এটি স্থিতিশীল সদস্য সংজ্ঞাতে প্রসারিত হয়EnumTraits<> শ্রেণীর ।

EDECLসূচনাকারী তালিকা মান মধ্যে ম্যাক্রো রূপান্তর প্রতিটি enum সদস্য যা পরবর্তীতে অনুক্রমে সদস্য কন্সট্রাকটর হস্তান্তর করতে enum তথ্য পূরণ করতে।

EnumInitGuardEnum ডেটার একটি বিশুদ্ধ তালিকা যাব - শ্রেণী মান সূচনাকারী enum গ্রাস আবার সংকুচিত হতে ডিজাইন করা হয়েছে।

উপকারিতা

  • c++মত সিনট্যাক্স
  • উভয়ের জন্য অভিন্নভাবে কাজ করে enumএবং enum class(* প্রায়)
  • যে enumকোনও সংখ্যার অন্তর্নিহিত টাইপ সহ ধরণের জন্য কাজ করে
  • enumস্বয়ংক্রিয়, সুস্পষ্ট এবং খণ্ডিত আরম্ভকারী মানগুলির সাথে প্রকারের জন্য কাজ করে
  • ভর পুনঃনামকরণের জন্য কাজ করে (ইনটেলিসেন্স লিঙ্কিং সংরক্ষিত)
  • শুধুমাত্র 5 প্রিপ্রোসেসর প্রতীক (3 গ্লোবাল)

* বিপরীতে enums, enum classএকই এনাম থেকে অন্যান্য মানগুলি উল্লেখ করে এমন প্রারম্ভিকদের অবশ্যই সেই মানগুলি অবশ্যই পুরোপুরি যোগ্যতা অর্জন করতে হবে

Disbenefits

  • .h/.cppপ্রতিটি জিজ্ঞাসাবলীর জন্য পৃথক জুড়ি প্রয়োজনenum
  • সংশ্লেষিত macroএবং includeযাদুবিদ্যার উপর নির্ভর করে
  • মাইনর সিনট্যাক্স ত্রুটিগুলি অনেক বড় ত্রুটিতে বিস্ফোরিত হয়
  • এনাম সংজ্ঞায়িত classবা namespaceস্কোপযুক্ত এনট্রিভায়াল
  • কোন সংকলন সময় সূচনা

মন্তব্য

ইন্টেলিজেন্স খোলার সময় ব্যক্তিগত সদস্য অ্যাক্সেস সম্পর্কে কিছুটা অভিযোগ করবে EnumTraits.inl, তবে যেহেতু প্রসারিত ম্যাক্রোগুলি আসলে শ্রেণীর সদস্যদের সংজ্ঞা দিচ্ছে, এটি আসলে কোনও সমস্যা নয়।

#ifndef ENUM_INCLUDE_MULTIহেডার ফাইলটি উপরের ব্লক একটি ছোটখাট বিরক্তি যে সম্ভবত একটি ম্যাক্রো বা কিছু ডাউন কাঁচুমাচু যেতে পারে, কিন্তু এটা ছোট তার বর্তমান আকারে সঙ্গে বসবাস করতে যথেষ্ট।

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

namespace ns { enum MyEnum : int; }
enum ns::MyEnum : int ETRAITS
{
    EDECL(AAA) = -8,
    EDECL(BBB) = '8',
    EDECL(CCC) = ns::MyEnum::AAA + ns::MyEnum::BBB
}

2

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

আমি যা সক্ষম করতে চাই তার সমতুল্য

enum class test1 { ONE, TWO = 13, SIX };

std::string toString(const test1& e) { ... }

int main() {
    test1 x;
    std::cout << toString(x) << "\n";
    std::cout << toString(test1::TWO) << "\n";
    std::cout << static_cast<std::underlying_type<test1>::type>(test1::TWO) << "\n";
    //std::cout << toString(123);// invalid
}

যা মুদ্রণ করা উচিত

ONE
TWO
13

আমি ম্যাক্রোর অনুরাগী নই। যাইহোক, সি ++ স্থানীয়ভাবে এনামগুলিকে স্ট্রিংয়ে রূপান্তরিত করতে সমর্থন না করা না হলে কারও কারও এক প্রকারের কোড জেনারেশন এবং / অথবা ম্যাক্রো ব্যবহার করতে হবে (এবং আমি সন্দেহ করি এটি খুব শীঘ্রই ঘটবে)। আমি একটি এক্স-ম্যাক্রো ব্যবহার করছি :

// x_enum.h
#include <string>
#include <map>
#include <type_traits>
#define x_begin enum class x_name {
#define x_val(X) X
#define x_value(X,Y) X = Y
#define x_end };
x_enum_def
#undef x_begin
#undef x_val
#undef x_value
#undef x_end

#define x_begin inline std::string toString(const x_name& e) { \
                static std::map<x_name,std::string> names = { 
#define x_val(X)      { x_name::X , #X }
#define x_value(X,Y)  { x_name::X , #X }
#define x_end }; return names[e]; }
x_enum_def
#undef x_begin
#undef x_val
#undef x_value
#undef x_end
#undef x_name
#undef x_enum_def

এর বেশিরভাগটি প্রতীকগুলি সংজ্ঞায়িত ও অপরিবর্তিত করে যা ব্যবহারকারী একটি মার্কের মাধ্যমে এক্স-মার্কোতে প্যারামিটার হিসাবে পাস করবে। ব্যবহারটি এরকম

#define x_name test1
#define x_enum_def x_begin x_val(ONE) , \
                           x_value(TWO,13) , \
                           x_val(SIX) \
                   x_end
#include "x_enum.h"

সরাসরি নমুনা

মনে রাখবেন যে আমি অন্তর্নিহিত ধরণটি এখনও নির্বাচন করে নি। আমার এখনও পর্যন্ত এটির প্রয়োজন নেই, তবে এটি সক্ষম করার জন্য কোডটি সংশোধন করার জন্য এটি সরাসরি হওয়া উচিত।

কেবল এটি লেখার পরে আমি বুঝতে পেরেছিলাম যে এটি এফেরিয়েন্স উত্তরের সাথে অনুরূপ । সম্ভবত আমি এটি আগে পড়েছি এবং সম্ভবত এটি অনুপ্রেরণার মূল উত্স ছিল। আমি নিজের লেখা না হওয়া পর্যন্ত আমি এক্স-ম্যাক্রোগুলি বোঝার ক্ষেত্রে সর্বদা ব্যর্থ ছিলাম;)।


1

শ্রেণি / কাঠামোর মধ্যে এনাম ব্যবহারের সমাধান (জনসাধারণের সাথে স্ট্রাক্ট ডিফল্ট) এবং অতিরিক্ত লোড অপারেটরগুলি:

struct Color
{
    enum Enum { RED, GREEN, BLUE };
    Enum e;

    Color() {}
    Color(Enum e) : e(e) {}

    Color operator=(Enum o) { e = o; return *this; }
    Color operator=(Color o) { e = o.e; return *this; }
    bool operator==(Enum o) { return e == o; }
    bool operator==(Color o) { return e == o.e; }
    operator Enum() const { return e; }

    std::string toString() const
    {
        switch (e)
        {
        case Color::RED:
            return "red";
        case Color::GREEN:
            return "green";
        case Color::BLUE:
            return "blue";
        default:
            return "unknown";
        }
    }
};

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

Color red;
red = Color::RED;
Color blue = Color::BLUE;

cout << red.toString() << " " << Color::GREEN << " " << blue << endl;

এটি "লাল 1 2" আউটপুট দেবে। নীল আউটপুটটিকে স্ট্রিং তৈরি করতে আপনি সম্ভবত ওভারলোড করতে পারেন (যদিও এটি অস্পষ্টতার কারণ হতে পারে তাই সম্ভব নয়) তবে এটি রঙ :: গ্রিনের সাথে কাজ করবে না কারণ এটি স্বয়ংক্রিয়ভাবে রঙে রূপান্তরিত হয় না।

এনুমে অন্তর্নিহিত রূপান্তর করার উদ্দেশ্য (যা প্রদত্তভাবে অন্তর্নিহিত বা প্রদত্ত প্রকারে রূপান্তরিত হয়) তা করতে সক্ষম হবেন:

Color color;
switch (color) ...

এটি কাজ করে, তবে এর অর্থ এটিও এই কাজ:

int i = color;

একটি এনাম ক্লাসের সাথে এটি সংকলন করবে না। আপনি এনাম এবং একটি পূর্ণসংখ্যা গ্রহণ করে দুটি ক্রিয়াকলাপ অতিরিক্ত চাপিয়ে ফেলেছেন বা অন্তর্নিহিত রূপান্তরটি সরিয়ে দিলে আপনার সাবধান হওয়া উচিত ...

অন্য সমাধানটিতে প্রকৃত এনাম শ্রেণি এবং স্থির সদস্যগুলি ব্যবহার করা জড়িত:

struct Color
{
    enum class Enum { RED, GREEN, BLUE };
    static const Enum RED = Enum::RED, GREEN = Enum::GREEN, BLUE = Enum::BLUE;

    //same as previous...
};

এটি সম্ভবত আরও স্থান নেয়, এবং এটি তৈরি করতে আরও বেশি সময় লাগে তবে অন্তর্নিহিত ইনট রূপান্তরগুলির জন্য একটি সংকলন ত্রুটির কারণ ঘটায়। আমি এই কারণে এটি ব্যবহার করব!

যদিও এর সাথে অবশ্যই ওভারহেড রয়েছে তবে আমি মনে করি এটি কেবল সহজ এবং আমি অন্যান্য কোডগুলি দেখেছি তার চেয়ে ভাল দেখাচ্ছে। কার্যকারিতা যুক্ত করার সম্ভাবনাও রয়েছে, যা সমস্ত শ্রেণীর মধ্যেই বিস্তৃত হতে পারে।

সম্পাদনা করুন : এটি কার্যকর করে এবং বেশিরভাগ কার্যকর করার আগে সংকলিত হতে পারে:

class Color
{
public:
    enum class Enum { RED, GREEN, BLUE };
    static const Enum RED = Enum::RED, GREEN = Enum::GREEN, BLUE = Enum::BLUE;

    constexpr Color() : e(Enum::RED) {}
    constexpr Color(Enum e) : e(e) {}

    constexpr bool operator==(Enum o) const { return e == o; }
    constexpr bool operator==(Color o) const { return e == o.e; }
    constexpr operator Enum() const { return e; }

    Color& operator=(Enum o) { const_cast<Enum>(this->e) = o; return *this; }
    Color& operator=(Color o) { const_cast<Enum>(this->e) = o.e; return *this; }

    std::string toString() const
    {
        switch (e)
        {
        case Enum::RED:
            return "red";
        case Enum::GREEN:
            return "green";
        case Enum::BLUE:
            return "blue";
        default:
            return "unknown";
        }
    }
private:
    const Enum e;
};

এটি অত্যন্ত আকর্ষণীয় :-) তবে আপনার বর্তমান সংস্করণে বোঝা যাচ্ছে আপনাকে ম্যানুয়ালি স্টাফটি লিখতে হবে case Enum::RED: return "red";। প্রশ্নটি কম্পাইলার (সংকলনের সময়) দ্বারা এই স্টাফকে স্বয়ংক্রিয়করণ সম্পর্কে। প্রশ্নের ধারণাটি কেবল স্টাফ আপডেট না করেই এনাম মানগুলি পরিবর্তন বা যুক্ত করা toString()। তুমি কি দেখছ? ধন্যবাদ
অলিব্রে

1

একটি বড় প্রতিবন্ধকতা সহ খুব সাধারণ সমাধান: আপনি মানগুলিতে কাস্টম মানগুলি বরাদ্দ করতে পারবেন না enum, তবে সঠিক রেজেক্সের সাহায্যে আপনি এটি করতে পারেন। আপনি enumআরও বেশি প্রচেষ্টা ছাড়াই মানগুলিতে আবার অনুবাদ করতে একটি মানচিত্র যুক্ত করতে পারেন :

#include <vector>
#include <string>
#include <regex>
#include <iterator>

std::vector<std::string> split(const std::string& s, 
                               const std::regex& delim = std::regex(",\\s*"))
{
    using namespace std;
    vector<string> cont;
    copy(regex_token_iterator<string::const_iterator>(s.begin(), s.end(), delim, -1), 
         regex_token_iterator<string::const_iterator>(),
         back_inserter(cont));
    return cont;
}

#define EnumType(Type, ...)     enum class Type { __VA_ARGS__ }

#define EnumStrings(Type, ...)  static const std::vector<std::string> \
                                Type##Strings = split(#__VA_ARGS__);

#define EnumToString(Type, ...) EnumType(Type, __VA_ARGS__); \
                                EnumStrings(Type, __VA_ARGS__)

ব্যবহারের উদাহরণ:

EnumToString(MyEnum, Red, Green, Blue);

আপনার উদ্ভাবনী ধারণার জন্য আপনাকে ম্যালেমকে ধন্যবাদ। পাঠযোগ্যতা উন্নত করতে আমি আপনার উত্তর সম্পাদনা করেছি। আমি আশা করি আপনি আমার পরিবর্তন পছন্দ করবেন। দয়া করে আপনার উত্তরটির উন্নতি অবিরত করুন: (1) "ব্যবহারের উদাহরণ" বিভাগটি এমন কিছু দিয়ে প্রসারিত করুন auto name = MyEnumStrings["Red"];- (২) আপনি কেন ব্যবহার করেন enum class? - (3) আপনি কি সমর্থন করেন enum class MyEnum : char { Red, Green, Blue };? - (4) ফাংশনটি ব্যাখ্যা করুন split()- (5) আপনার কি প্যারামিটার দরকার const std::regex& delim? - ()) MyEnumStringsসংকলনের সময়ে উত্পন্ন সম্পর্কে কী ? => আপনি কি ব্যবহার করতে পারেন constexpr? ... চিয়ার্স :-)
অলিবার

আমি সত্যিই এই পদ্ধতির পছন্দ। সত্যিই সংক্ষিপ্ত এবং বুঝতে সহজ।
আন্তন হলবার্গ

1

সম্পাদনা: আরও নতুন সংস্করণের জন্য নীচে চেক করুন

উপরে উল্লিখিত হিসাবে, N4113 হ'ল এই বিষয়টির চূড়ান্ত সমাধান, তবে এটি বের হয়ে আসার জন্য আমাদের এক বছরেরও বেশি অপেক্ষা করতে হবে।

এদিকে, আপনি যদি এই জাতীয় বৈশিষ্ট্য চান তবে আপনাকে "সিম্পল" টেম্পলেট এবং কিছু প্রাকপ্রসেসর যাদু ব্যবহার করতে হবে।

গণনাকারী

template<typename T>
class Enum final
{
    const char* m_name;
    const T m_value;
    static T m_counter;

public:
    Enum(const char* str, T init = m_counter) : m_name(str), m_value(init) {m_counter = (init + 1);}

    const T value() const {return m_value;}
    const char* name() const {return m_name;}
};

template<typename T>
T Enum<T>::m_counter = 0;

#define ENUM_TYPE(x)      using Enum = Enum<x>;
#define ENUM_DECL(x,...)  x(#x,##__VA_ARGS__)
#define ENUM(...)         const Enum ENUM_DECL(__VA_ARGS__);

ব্যবহার

#include <iostream>

//the initialization order should be correct in all scenarios
namespace Level
{
    ENUM_TYPE(std::uint8)
    ENUM(OFF)
    ENUM(SEVERE)
    ENUM(WARNING)
    ENUM(INFO, 10)
    ENUM(DEBUG)
    ENUM(ALL)
}

namespace Example
{
    ENUM_TYPE(long)
    ENUM(A)
    ENUM(B)
    ENUM(C, 20)
    ENUM(D)
    ENUM(E)
    ENUM(F)
}

int main(int argc, char** argv)
{
    Level::Enum lvl = Level::WARNING;
    Example::Enum ex = Example::C;
    std::cout << lvl.value() << std::endl; //2
    std::cout << ex.value() << std::endl; //20
}

সহজ ব্যাখ্যা

Enum<T>::m_counterপ্রতিটি নামস্থান ঘোষণার ভিতরে 0 তে সেট করা হয়।
( কেউ কি আমাকে নির্দেশ করতে পারে যেখানে ^^ এই আচরণ the স্ট্যান্ডার্ডে উল্লেখ করা হয়েছে? )
প্রিপ্রসেসর যাদুটি গণনারগণের ঘোষণাকে স্বয়ংক্রিয় করে দেয়।

অসুবিধেও

  • এটি সত্যিকারের enumধরণের নয়, অতএব ইনট প্রচারযোগ্য নয়
  • সুইচ ক্ষেত্রে ব্যবহার করা যাবে না

বিকল্প সমাধান

এই এক বলিদান লাইন নম্বরিং (সত্যিই নয়) তবে সুইচ ক্ষেত্রে ব্যবহার করা যেতে পারে

#define ENUM_TYPE(x) using type = Enum<x>
#define ENUM(x)      constexpr type x{__LINE__,#x}

template<typename T>
struct Enum final
{
    const T value;
    const char* name;

    constexpr operator const T() const noexcept {return value;}
    constexpr const char* operator&() const noexcept {return name;}
};

ত্রুটি-বিচ্যুতি

#line 0-pedanticজিসিসি এবং বিড়ম্বনার সাথে বিরোধগুলি

কার্যসংক্রান্ত

হয় এ থেকে শুরু করুন #line 1এবং 1 থেকে বিয়োগ করুন __LINE__
বা, ব্যবহার করবেন না -pedantic
এবং যখন আমরা এটি করছি, উপাচার্য ++ এড়ান সর্বদা, এটি সর্বদা একটি সংকলকটির রসিক।

ব্যবহার

#include <iostream>

namespace Level
{
    ENUM_TYPE(short);
    #line 0
    ENUM(OFF);
    ENUM(SEVERE);
    ENUM(WARNING);
    #line 10
    ENUM(INFO);
    ENUM(DEBUG);
    ENUM(ALL);
    #line <next line number> //restore the line numbering
};

int main(int argc, char** argv)
{
    std::cout << Level::OFF << std::endl;   // 0
    std::cout << &Level::OFF << std::endl;  // OFF

    std::cout << Level::INFO << std::endl;  // 10
    std::cout << &Level::INFO << std::endl; // INFO

    switch(/* any integer or integer-convertible type */)
    {
    case Level::OFF:
        //...
        break;

    case Level::SEVERE:
        //...
        break;

    //...
    }

    return 0;
}

বাস্তব জীবনের বাস্তবায়ন এবং ব্যবহার

r3dVoxel -
এনাম r3dVoxel - ELoggingLevel

দ্রুত রেফারেন্স

# লাইন লিনেনো - cppreferences.com


0

আমি এই সমস্যাটি সমাধানের জন্য একটি লাইব্রেরি লিখেছি, বার্তাটি পাওয়া ব্যতীত সবকিছুই সংকলনের সময় ঘটে।

ব্যবহার:

DEF_MSGম্যাক্রো এবং বার্তা জুটির সংজ্ঞা দিতে ম্যাক্রো ব্যবহার করুন :

DEF_MSG(CODE_OK,   "OK!")
DEF_MSG(CODE_FAIL, "Fail!")

CODE_OKব্যবহার করার জন্য ম্যাক্রো এবং "OK!"এটি সম্পর্কিত বার্তা।

বার্তাটি পেতে get_message()বা কেবল ব্যবহার gm()করুন:

get_message(CODE_FAIL);  // will return "Fail!"
gm(CODE_FAIL);           // works exactly the same as above

MSG_NUMকতটি ম্যাক্রো সংজ্ঞায়িত করা হয়েছে তা জানতে ব্যবহার করুন । এটি স্বয়ংক্রিয়ভাবে বৃদ্ধি পাবে, আপনাকে কিছু করার দরকার নেই।

পূর্বনির্ধারিত বার্তা:

MSG_OK:     OK
MSG_BOTTOM: Message bottom

প্রকল্প: libcodemsg


গ্রন্থাগারটি অতিরিক্ত ডেটা তৈরি করে না। সংকলন সময়ে সবকিছু ঘটে। ইন message_def.h, এটি একটি উত্পন্ন enumনামক MSG_CODE; ইন message_def.c, এটি একটি ভেরিয়েবল উত্পন্ন করে যা সমস্ত স্ট্রিংগুলিকে ধারণ করে static const char* _g_messages[]

এই ক্ষেত্রে, গ্রন্থাগারটি enumকেবল একটি তৈরি করতে সীমাবদ্ধ । এটি প্রত্যাবর্তনের মানগুলির জন্য আদর্শ, উদাহরণস্বরূপ:

MSG_CODE foo(void) {
    return MSG_OK; // or something else
}

MSG_CODE ret = foo();

if (MSG_OK != ret) {
    printf("%s\n", gm(ret););
}

আমার এই নকশাটি পছন্দ করার মতো আরেকটি বিষয় হ'ল আপনি বিভিন্ন ফাইলগুলিতে বার্তা সংজ্ঞা পরিচালনা করতে পারেন।


আমি এই প্রশ্নের সমাধান আরও ভাল দেখায়।


হাই ম্যাডউইন আপনার ধারণার জন্য ধন্যবাদ। কিন্তু এটি কিভাবে কাজ করে? ওভারহেড কি? (শূন্য ওভারহেড বা এটি অতিরিক্ত ডেটা তৈরি করে?) আপনার প্রস্তাবটি ঠিক আছে বলে মনে হচ্ছে, তবে দুর্ভাগ্যক্রমে, DEF_MSGপ্রতিটি enumমানের জন্য একটি বিবৃতি ব্যবহার করতে হবে / আপডেট করতে হবে / বজায় রাখতে হবে : - / এবং এটিই আদর্শভাবে আমরা করা বন্ধ করতে চাই ... চিয়ার্স
অলিবার

উত্তরের জন্য ধন্যবাদ, @ ওলিব্রে দয়া করে আপডেট করা উত্তরটি পরীক্ষা করুন। আমি এখানে ওভারহেড দেখতে পাচ্ছি না, স্ট্রিংগুলি অ্যাক্সেস করার জন্য কোনও ফাংশন কলের প্রয়োজন বাদে। DEF_MSGতোলে enumযদিও এটি কিছু সীমাবদ্ধতা আছে, ঘনিষ্ঠভাবে বার্তা সঙ্গে যুক্ত করা।
ম্যাডউইন

আপনার উত্তরে সংযুক্ত ব্যাখ্যার জন্য আপনাকে ধন্যবাদ :-) আপনার লিব ঠিক আছে তবে একাধিক এনামের জন্য ব্যবহার করা যায় না: - / enum class(সি ++ 11) এর সমর্থন সম্পর্কে কি ? আপনি রান-টাইমে constexprসীমাবদ্ধ করতে ব্যবহার করতে পারেন _g_messages। মেটা-প্রোগ্রামিং (টাইপ কনভেভিং {এনুম-টাইপ, এনুম-ভ্যালু}) বা টেমপ্লেট ভেরিয়েবলগুলি (সি ++ 14) ব্যবহার করে একাধিক enumধরণের (এড়ানো _g_messages) সমর্থন করুন । আমি মনে করি আপনার লিবিয়া (এখনও?) সি ++ 11/14/17 প্রয়োজনীয়তার সাথে খাপ খায় না? আপনি কি মনে করেন? চিয়ার্স ;-)
ওলিব্রে

1
নিম্নলিখিত আপ জন্য ধন্যবাদ। আমি আজ নতুন কিছু শিখেছি! এনাম ক্লাস এবং টেম্পলেট ভেরিয়েবলগুলি দেখতে ভাল লাগে। আমার মনে হয় আমার স্বাদটি সি স্বাদযুক্ত হওয়ায় কিছুটা "অফ টপিক" ছিল।
ম্যাডউইন

0
#define ENUM_MAKE(TYPE, ...) \
        enum class TYPE {__VA_ARGS__};\
        struct Helper_ ## TYPE { \
            static const String& toName(TYPE type) {\
                int index = static_cast<int>(type);\
                return splitStringVec()[index];}\
            static const TYPE toType(const String& name){\
                static std::unordered_map<String,TYPE> typeNameMap;\
                if( typeNameMap.empty() )\
                {\
                    const StringVector& ssVec = splitStringVec();\
                    for (size_t i = 0; i < ssVec.size(); ++i)\
                        typeNameMap.insert(std::make_pair(ssVec[i], static_cast<TYPE>(i)));\
                }\
                return typeNameMap[name];}\
            static const StringVector& splitStringVec() {\
                static StringVector typeNameVector;\
                if(typeNameVector.empty()) \
                {\
                    typeNameVector = StringUtil::split(#__VA_ARGS__, ",");\
                    for (auto& name : typeNameVector)\
                    {\
                        name.erase(std::remove(name.begin(), name.end(), ' '),name.end()); \
                        name = String(#TYPE) + "::" + name;\
                    }\
                }\
                return typeNameVector;\
            }\
        };


using String = std::string;
using StringVector = std::vector<String>;

   StringVector StringUtil::split( const String& str, const String& delims, unsigned int maxSplits, bool preserveDelims)
    {
        StringVector ret;
        // Pre-allocate some space for performance
        ret.reserve(maxSplits ? maxSplits+1 : 10);    // 10 is guessed capacity for most case

        unsigned int numSplits = 0;

        // Use STL methods 
        size_t start, pos;
        start = 0;
        do 
        {
            pos = str.find_first_of(delims, start);
            if (pos == start)
            {
                // Do nothing
                start = pos + 1;
            }
            else if (pos == String::npos || (maxSplits && numSplits == maxSplits))
            {
                // Copy the rest of the string
                ret.push_back( str.substr(start) );
                break;
            }
            else
            {
                // Copy up to delimiter
                ret.push_back( str.substr(start, pos - start) );

                if(preserveDelims)
                {
                    // Sometimes there could be more than one delimiter in a row.
                    // Loop until we don't find any more delims
                    size_t delimStart = pos, delimPos;
                    delimPos = str.find_first_not_of(delims, delimStart);
                    if (delimPos == String::npos)
                    {
                        // Copy the rest of the string
                        ret.push_back( str.substr(delimStart) );
                    }
                    else
                    {
                        ret.push_back( str.substr(delimStart, delimPos - delimStart) );
                    }
                }

                start = pos + 1;
            }
            // parse up to next real data
            start = str.find_first_not_of(delims, start);
            ++numSplits;

        } while (pos != String::npos);



        return ret;
    }

উদাহরণ

ENUM_MAKE(MY_TEST, MY_1, MY_2, MY_3)


    MY_TEST s1 = MY_TEST::MY_1;
    MY_TEST s2 = MY_TEST::MY_2;
    MY_TEST s3 = MY_TEST::MY_3;

    String z1 = Helper_MY_TEST::toName(s1);
    String z2 = Helper_MY_TEST::toName(s2);
    String z3 = Helper_MY_TEST::toName(s3);

    MY_TEST q1 = Helper_MY_TEST::toType(z1);
    MY_TEST q2 = Helper_MY_TEST::toType(z2);
    MY_TEST q3 = Helper_MY_TEST::toType(z3);

স্বয়ংক্রিয়ভাবে ENUM_MAKE ম্যাক্রো 'এনাম প্রতিবিম্ব ফাংশন' সহ 'এনাম ক্লাস' এবং সহায়ক শ্রেণি উত্পন্ন করে।

ভুলগুলি হ্রাস করার জন্য, একবারে সমস্ত কিছু কেবল একটি ENUM_MAKE দিয়ে সংজ্ঞায়িত করা হয়।

এই কোডটির সুবিধাটি স্বয়ংক্রিয়ভাবে প্রতিবিম্বের জন্য তৈরি হয়েছে এবং ম্যাক্রো কোডটি, সহজেই বোঝার কোডটি রয়েছে close 'এনাম টু স্ট্রিং', 'স্ট্রিং টু এনুম' পারফরম্যান্স উভয়ই অ্যালগোরিদম হে (1)।

অসুবিধাগুলি হ'ল প্রথম ব্যবহারের সময় এনাম রেফারেন্সের স্ট্রিং ভেক্টর এবং মানচিত্রের জন্য সহায়ক শ্রেণি শুরু করা হয়। তবে আপনি যদি চান তবে আপনাকে প্রাক-প্রাথমিককরণও করা হবে। -


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

ওহে ছেলেরা, আমি দুঃখিত আমি খুব ভাল ইংরেজি বলতে পারি না।
desperado_98

স্বয়ংক্রিয়ভাবে ENUM_MAKE ম্যাক্রো 'এনাম প্রতিবিম্ব ফাংশন' সহ 'এনাম ক্লাস' এবং সহায়ক শ্রেণি উত্পন্ন করে। / ভুলগুলি হ্রাস করার জন্য, একবারে সমস্ত কিছু কেবল একটি ENUM_MAKE দিয়ে সংজ্ঞায়িত করা হয়। এই কোডটির সুবিধাটি স্বয়ংক্রিয়ভাবে প্রতিবিম্বের জন্য তৈরি হয়েছে এবং ম্যাক্রো কোডটি, সহজেই বোঝার কোডটি রয়েছে close 'এনাম টু স্ট্রিং', 'স্ট্রিং টু এনুম' পারফরম্যান্স উভয়ই অ্যালগোরিদ হে (1)। অসুবিধাগুলি হ'ল প্রথম ব্যবহারের সময় এনাম রেফারেন্সের স্ট্রিং ভেক্টর এবং মানচিত্রের জন্য সহায়ক শ্রেণি শুরু করা হয়। তবে আপনি যদি চান তবে আপনাকে প্রাক-প্রাথমিককরণও করা হবে।
desperado_98

হাই desperado_98। আপনার অবদানের জন্য ধন্যবাদ. আপনার উত্তর সম্পাদনা করুন এবং এটিতে আপনার মন্তব্য সামগ্রী contentোকান। সংকলকটি সংকলন-সময়ে আপনার উদাহরণটি গণনা করতে পারে যদি আপনি কিছু মেটা-প্রোগ্রামিং ট্রিক ব্যবহার করেন constexpr। আমি ফাংশন বলতে চাই toName()এবং toType()সংকলন চলাকালীন নির্ধারণ করা যেতে পারে এবং মৃত্যুদণ্ড কার্যকর করার সময় নয় (রান-টাইম)। আপনার উত্তরে সি ++ 11/14/17 স্টাইলটি গ্রহণ করুন। চিয়ার্স ;-)
অলিবার

তাছাড়া: আপনার ম্যাক্রো কি সামঞ্জস্যপূর্ণ enum class MyEnum : short { A, B, C };?
অলিবরে

0

আমার সমাধান ম্যাক্রো ব্যবহার ছাড়াই।

সুবিধাদি:

  • আপনি ঠিক কি দেখতে পাবেন
  • অ্যাক্সেস হ্যাশ মানচিত্র সহ হয়, তাই অনেক মূল্যবান enums জন্য ভাল
  • ক্রম বা অ-পরপর মান বিবেচনা করার প্রয়োজন নেই
  • এনুম থেকে স্ট্রিং এবং স্ট্রিং থেকে এনাম অনুবাদ উভয়ই, তবে যোগ করা এনাম মানটি কেবল একটি অতিরিক্ত জায়গায় যুক্ত করতে হবে

অসুবিধেও:

  • আপনাকে সমস্ত enums মানগুলি পাঠ্য হিসাবে প্রতিলিপি করতে হবে
  • হ্যাশ মানচিত্রে অ্যাক্সেস অবশ্যই স্ট্রিং কেস বিবেচনা করবে
  • রক্ষণাবেক্ষণ যদি মান যোগ করা কষ্টদায়ক হয় - অবশ্যই এনাম এবং সরাসরি অনুবাদ ম্যাপ উভয়ই যুক্ত করতে হবে

সুতরাং ... যে দিন সি ++ সি # এনাম প্রয়োগ করে function

            #include <unordered_map>

            enum class Language
            { unknown, 
                Chinese, 
                English, 
                French, 
                German
                // etc etc
            };

            class Enumerations
            {
            public:
                static void fnInit(void);

                static std::unordered_map <std::wstring, Language> m_Language;
                static std::unordered_map <Language, std::wstring> m_invLanguage;

            private:
                static void fnClear();
                static void fnSetValues(void);
                static void fnInvertValues(void);

                static bool m_init_done;
            };

            std::unordered_map <std::wstring, Language> Enumerations::m_Language = std::unordered_map <std::wstring, Language>();
            std::unordered_map <Language, std::wstring> Enumerations::m_invLanguage = std::unordered_map <Language, std::wstring>();

            void Enumerations::fnInit()
            {
                fnClear();
                fnSetValues();
                fnInvertValues();
            }

            void Enumerations::fnClear()
            {
                m_Language.clear();
                m_invLanguage.clear();
            }

            void Enumerations::fnSetValues(void)
            {   
                m_Language[L"unknown"] = Language::unknown;
                m_Language[L"Chinese"] = Language::Chinese;
                m_Language[L"English"] = Language::English;
                m_Language[L"French"] = Language::French;
                m_Language[L"German"] = Language::German;
                // and more etc etc
            }

            void Enumerations::fnInvertValues(void)
            {
                for (auto it = m_Language.begin(); it != m_Language.end(); it++)
                {
                    m_invLanguage[it->second] = it->first;
                }
            }

            // usage -
            //Language aLanguage = Language::English;
            //wstring sLanguage = Enumerations::m_invLanguage[aLanguage];

            //wstring sLanguage = L"French" ;
            //Language aLanguage = Enumerations::m_Language[sLanguage];

0

ঠিক আছে, অন্য একটি বিকল্প। একটি সাধারণ ব্যবহারের ক্ষেত্রে হ'ল এইচটিটিপি ক্রিয়াগুলির পাশাপাশি স্ট্রিংয়ের সংস্করণ মানগুলি ব্যবহার করার জন্য আপনার ধ্রুবক প্রয়োজন।

উদাহরণ:

int main () {

  VERB a = VERB::GET;
  VERB b = VERB::GET;
  VERB c = VERB::POST;
  VERB d = VERB::PUT;
  VERB e = VERB::DELETE;


  std::cout << a.toString() << std::endl;

  std::cout << a << std::endl;

  if ( a == VERB::GET ) {
    std::cout << "yes" << std::endl;
  }

  if ( a == b ) {
    std::cout << "yes" << std::endl;
  }

  if ( a != c ) {
    std::cout << "no" << std::endl;
  }

}

ভেরিব শ্রেণি:

// -----------------------------------------------------------
// -----------------------------------------------------------
class VERB {

private:

  // private constants
  enum Verb {GET_=0, POST_, PUT_, DELETE_};

  // private string values
  static const std::string theStrings[];

  // private value
  const Verb value;
  const std::string text;

  // private constructor
  VERB (Verb v) :
  value(v), text (theStrings[v])
  {
    // std::cout << " constructor \n";
  }

public:

  operator const char * ()  const { return text.c_str(); }

  operator const std::string ()  const { return text; }

  const std::string toString () const { return text; }

  bool operator == (const VERB & other) const { return (*this).value == other.value; }

  bool operator != (const VERB & other) const { return ! ( (*this) == other); }

  // ---

  static const VERB GET;
  static const VERB POST;
  static const VERB PUT;
  static const VERB DELETE;

};

const std::string VERB::theStrings[] = {"GET", "POST", "PUT", "DELETE"};

const VERB VERB::GET = VERB ( VERB::Verb::GET_ );
const VERB VERB::POST = VERB ( VERB::Verb::POST_ );
const VERB VERB::PUT = VERB ( VERB::Verb::PUT_ );
const VERB VERB::DELETE = VERB ( VERB::Verb::DELETE_ );
// end of file

1
মেমরির ব্যবহার হ্রাস করতে, আপনি const std::string textকেবলমাত্র সদস্যকে প্রতিস্থাপন করতে পারেন theStrings[v]। তবে প্রশ্নটি হ'ল সি ++ 11 / সি ++ 14 / সি ++ 17 / সি ++ 20 এর বৈশিষ্ট্যগুলি সম্পর্কে হাত থেকে এ জাতীয় ক্লাসটি লিখতে এড়াতে: - /
অলিবার

0

আমার উত্তর এখানে।

স্ট্রিংয়ের ডীক হিসাবে আপনি এনাম মানের নাম এবং এই সূচকগুলি একই সাথে পেতে পারেন।

এই পদ্ধতিতে কেবল সামান্য অনুলিপি এবং পেস্ট এবং সম্পাদনা দরকার।

প্রাপ্ত ফলাফলের জন্য সাইজ_টি থেকে এনাম শ্রেণীর ধরণের টাইপ-কাস্টিং প্রয়োজন যখন আপনার এনুম শ্রেণীর ধরণের মান প্রয়োজন তবে আমি মনে করি এটি এনাম শ্রেণীর চিকিত্সার একটি খুব বহনযোগ্য এবং শক্তিশালী উপায়।

enum class myenum
{
  one = 0,
  two,
  three,
};

deque<string> ssplit(const string &_src, boost::regex &_re)
{
  boost::sregex_token_iterator it(_src.begin(), _src.end(), _re, -1);
  boost::sregex_token_iterator e;
  deque<string> tokens;
  while (it != e)
    tokens.push_back(*it++);
  return std::move(tokens);
}

int main()
{
  regex re(",");
  deque<string> tokens = ssplit("one,two,three", re);
  for (auto &t : tokens) cout << t << endl;
    getchar();
  return 0;
}

0

আপনি পন্ডারের মতো একটি প্রতিচ্ছবি গ্রন্থাগার ব্যবহার করতে পারেন :

enum class MyEnum
{
    Zero = 0,
    One  = 1,
    Two  = 2
};

ponder::Enum::declare<MyEnum>()
    .value("Zero", MyEnum::Zero)
    .value("One",  MyEnum::One)
    .value("Two",  MyEnum::Two);

ponder::EnumObject zero(MyEnum::Zero);

zero.name(); // -> "Zero"

0

( Https://stackoverflow.com/a/54967187/2338477 এর অ্যানালগ , কিছুটা সংশোধিত)।

এখানে ন্যূনতম সংজ্ঞায়িত যাদু এবং পৃথক এনাম অ্যাসাইনমেন্টগুলির সমর্থন সহ আমার নিজস্ব সমাধান।

এখানে শিরোনাম ফাইল:

#pragma once
#include <string>
#include <map>
#include <regex>

template <class Enum>
class EnumReflect
{
public:
    static const char* getEnums() { return ""; }
};

//
//  Just a container for each enumeration type.
//
template <class Enum>
class EnumReflectBase
{
public:
    static std::map<std::string, int> enum2int;
    static std::map<int, std::string> int2enum;

    static void EnsureEnumMapReady( const char* enumsInfo )
    {
        if (*enumsInfo == 0 || enum2int.size() != 0 )
            return;

        // Should be called once per each enumeration.
        std::string senumsInfo(enumsInfo);
        std::regex re("^([a-zA-Z_][a-zA-Z0-9_]+) *=? *([^,]*)(,|$) *");     // C++ identifier to optional " = <value>"
        std::smatch sm;
        int value = 0;

        for (; regex_search(senumsInfo, sm, re); senumsInfo = sm.suffix(), value++)
        {
            string enumName = sm[1].str();
            string enumValue = sm[2].str();

            if (enumValue.length() != 0)
                value = atoi(enumValue.c_str());

            enum2int[enumName] = value;
            int2enum[value] = enumName;
        }
    }
};

template <class Enum>
std::map<std::string, int> EnumReflectBase<Enum>::enum2int;

template <class Enum>
std::map<int, std::string> EnumReflectBase<Enum>::int2enum;


#define DECLARE_ENUM(name, ...)                                         \
    enum name { __VA_ARGS__ };                                          \
    template <>                                                         \
    class EnumReflect<##name>: public EnumReflectBase<##name> {         \
    public:                                                             \
        static const char* getEnums() { return #__VA_ARGS__; }          \
    };




/*
    Basic usage:

    Declare enumeration:

DECLARE_ENUM( enumName,

    enumValue1,
    enumValue2,
    enumValue3 = 5,

    // comment
    enumValue4
);

    Conversion logic:

    From enumeration to string:

        printf( EnumToString(enumValue3).c_str() );

    From string to enumeration:

       enumName value;

       if( !StringToEnum("enumValue4", value) )
            printf("Conversion failed...");
*/

//
//  Converts enumeration to string, if not found - empty string is returned.
//
template <class T>
std::string EnumToString(T t)
{
    EnumReflect<T>::EnsureEnumMapReady(EnumReflect<T>::getEnums());
    auto& int2enum = EnumReflect<T>::int2enum;
    auto it = int2enum.find(t);

    if (it == int2enum.end())
        return "";

    return it->second;
}

//
//  Converts string to enumeration, if not found - false is returned.
//
template <class T>
bool StringToEnum(const char* enumName, T& t)
{
    EnumReflect<T>::EnsureEnumMapReady(EnumReflect<T>::getEnums());
    auto& enum2int = EnumReflect<T>::enum2int;
    auto it = enum2int.find(enumName);

    if (it == enum2int.end())
        return false;

    t = (T) it->second;
    return true;
}

এবং এখানে উদাহরণ পরীক্ষার আবেদন:

DECLARE_ENUM(TestEnum,
    ValueOne,
    ValueTwo,
    ValueThree = 5,
    ValueFour = 7
);

DECLARE_ENUM(TestEnum2,
    ValueOne2 = -1,
    ValueTwo2,
    ValueThree2 = -4,
    ValueFour2
);

void main(void)
{
    string sName1 = EnumToString(ValueOne);
    string sName2 = EnumToString(ValueTwo);
    string sName3 = EnumToString(ValueThree);
    string sName4 = EnumToString(ValueFour);

    TestEnum t1, t2, t3, t4, t5 = ValueOne;
    bool b1 = StringToEnum(sName1.c_str(), t1);
    bool b2 = StringToEnum(sName2.c_str(), t2);
    bool b3 = StringToEnum(sName3.c_str(), t3);
    bool b4 = StringToEnum(sName4.c_str(), t4);
    bool b5 = StringToEnum("Unknown", t5);

    string sName2_1 = EnumToString(ValueOne2);
    string sName2_2 = EnumToString(ValueTwo2);
    string sName2_3 = EnumToString(ValueThree2);
    string sName2_4 = EnumToString(ValueFour2);

    TestEnum2 t2_1, t2_2, t2_3, t2_4, t2_5 = ValueOne2;
    bool b2_1 = StringToEnum(sName2_1.c_str(), t2_1);
    bool b2_2 = StringToEnum(sName2_2.c_str(), t2_2);
    bool b2_3 = StringToEnum(sName2_3.c_str(), t2_3);
    bool b2_4 = StringToEnum(sName2_4.c_str(), t2_4);
    bool b2_5 = StringToEnum("Unknown", t2_5);

একই শিরোনাম ফাইলটির আপডেট হওয়া সংস্করণ এখানে রাখা হবে:

https://github.com/tapika/cppscriptcore/blob/master/SolutionProjectModel/EnumReflect.h


-5

একটি সাধারণ স্ট্রিমিং ওভারলোড সম্পর্কে কী? আপনি যদি কিছু ম্যাক্রো যাদু না করতে চান তবে আপনাকে এখনও ম্যাপিং বজায় রাখতে হবে, তবে আমি এটি আপনার মূল সমাধানের চেয়ে আরও পরিস্কার পেয়েছি।

#include <cstdint>  // for std::uint_fast8_t
#include <array>
#include <string>
#include <iostream>

enum class MyEnum : std::uint_fast8_t {
   AAA,
   BBB,
   CCC,
};

std::ostream& operator<<(std::ostream& str, MyEnum type)
{
    switch(type)
    {
    case MyEnum::AAA: str << "AAA"; break;
    case MyEnum::BBB: str << "BBB"; break;
    case MyEnum::CCC: str << "CCC"; break;
    default: break;
    }
    return str;
}

int main()
{
   std::cout << MyEnum::AAA <<'\n';
}

5
1) এটি আরও বেশি সদৃশ তৈরি করে 2) এটি আপনাকে স্ট্রিমগুলি ব্যবহার করতে বাধ্য করে
করোলি হরভথ

6
-1 দুঃখিত @ দাউ_সামা কিন্তু স্ট্রিং পুনরাবৃত্ত প্রশ্নের এই সমস্ত এনামের উদ্দেশ্য এনাম / স্ট্রিং ম্যাপিংয়ের রক্ষণাবেক্ষণ এড়ানো। আপনি যদি মনে করেন যে আপনার উত্তরটি উদ্দেশ্যটির সাথে খাপ খায় না, দয়া করে উত্তরটি মুছে ফেলার বিষয়ে বিবেচনা করুন। আপনার পরবর্তী উত্তরের জন্য শুভকামনা;) চিয়ার্স
ওলিব্রে

-9

সহজতম পথ?
অ্যাডা ব্যবহার করুন: Enumeration'Image( Value )আপনি যা চান ঠিক তাই করে। আপনার যদি সত্যিই সি ++ প্রয়োজন হয় তবে আপনি ফাংশনটি রফতানি করতে চেষ্টা করতে পারেন:

Function To_String( Input : Enumeration ) return Interfaces.C.Strings.chars_ptr is
    ( Interfaces.C.Strings.New_String( Enumeration'Image(Input) ) )
    with Export, Convention => C;

4
কীভাবে এই প্রশ্নের উত্তর দেওয়া যায় না? প্রশ্নটি পরিষ্কারভাবে একটি এনামকে আধুনিক সি ++ এ স্ট্রিংয়ে রূপান্তরিত করে।
মাইকেল চোই

1
@ মিশেলচোই - এটি হ'ল, তবে কাজের জন্য উপযুক্ত সরঞ্জামটি ব্যবহার করার বিষয়টিও রয়েছে: কেবলমাত্র সি ++ টিউরিং-সম্পূর্ণ এবং তাই সমস্ত সমাধানযোগ্য সমস্যার সমাধান করতে পারে তার অর্থ এই নয় যে সমাধানটি হল: দ্রুত, রক্ষণাবেক্ষণযোগ্য বা দক্ষ। সঠিক / পছন্দসই কার্যকারিতা আছে একটি ভাষা ব্যবহার এবং এটি রপ্তানি হয় একটি বৈধ সমাধান।
শার্ক 8

3
প্রশ্নের প্রথম বাক্যে "এই প্রশ্নটি নতুন সি ++ বৈশিষ্ট্যগুলি ব্যবহার সম্পর্কে"। তারপরে "[আমি এখনও কোনও সন্ধান পাইনি] সি ++ 11, সি ++ 14 বা সি ++ 17 নতুন বৈশিষ্ট্যগুলি ব্যবহার করে মার্জিত উপায়"। লেখক স্পষ্টতই একটি সি ++ সমাধান খুঁজছিলেন; আপনি অ্যাডায় একটি সমাধান দিয়েছেন, সুতরাং আপনি প্রশ্নের উত্তর দেন নি। আপনি এমন কিছু সমাধানের জন্য সম্পূর্ণ আলাদা নির্ভরশীলতা অন্তর্ভুক্ত করার পরামর্শ দিচ্ছেন যা সম্ভবত প্রশ্নের ক্ষেত্র ছিল না।
মাইকেল চই
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.