c++ - সি শার্প



তাদের ক্লাস নাম ধারণ করে একটি স্ট্রিং থেকে বস্তু তাত্ক্ষণিক করার একটি উপায় আছে কি? (6)

আমার একটি ফাইল আছে: Base.h

class Base;
class DerivedA : public Base;
class DerivedB : public Base;

/*etc...*/

এবং অন্য ফাইল: BaseFactory.h

#include "Base.h"

class BaseFactory
{
public:
  BaseFactory(const string &sClassName){msClassName = sClassName;};

  Base * Create()
  {
    if(msClassName == "DerivedA")
    {
      return new DerivedA();
    }
    else if(msClassName == "DerivedB")
    {
      return new DerivedB();
    }
    else if(/*etc...*/)
    {
      /*etc...*/
    }
  };
private:
  string msClassName;
};

/*etc.*/

কোনভাবেই এই স্ট্রিংটি প্রকৃত ধরণের (বর্গ) রূপে রূপান্তর করার উপায় আছে, যাতে বেসফ্যাক্টিকে সমস্ত সম্ভাব্য ডেরিভেড শ্রেণিগুলি জানাতে হবে না এবং তাদের প্রতিটির জন্য () আছে কিনা? আমি এই স্ট্রিং থেকে একটি বর্গ উত্পাদন করতে পারি?

আমি এই প্রতিফলন মাধ্যমে সি # মধ্যে করা যেতে পারে। সি ++ এর মতো কিছু আছে কি?

https://ffff65535.com


boost :: functional একটি কারখানা টেম্পলেট যা বেশ নমনীয়: http://www.boost.org/doc/libs/1_54_0/libs/functional/factory/doc/html/index.html

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

#ifndef GENERIC_FACTORY_HPP_INCLUDED

//BOOST_PP_IS_ITERATING is defined when we are iterating over this header file.
#ifndef BOOST_PP_IS_ITERATING

    //Included headers.
    #include <unordered_map>
    #include <functional>
    #include <boost/preprocessor/iteration/iterate.hpp>
    #include <boost/preprocessor/repetition.hpp>

    //The GENERIC_FACTORY_MAX_ARITY directive controls the number of factory classes which will be generated.
    #ifndef GENERIC_FACTORY_MAX_ARITY
        #define GENERIC_FACTORY_MAX_ARITY 10
    #endif

    //This macro magic generates GENERIC_FACTORY_MAX_ARITY + 1 versions of the GenericFactory class.
    //Each class generated will have a suffix of the number of parameters taken by the derived type constructors.
    #define BOOST_PP_FILENAME_1 "GenericFactory.hpp"
    #define BOOST_PP_ITERATION_LIMITS (0,GENERIC_FACTORY_MAX_ARITY)
    #include BOOST_PP_ITERATE()

    #define GENERIC_FACTORY_HPP_INCLUDED

#else

    #define N BOOST_PP_ITERATION() //This is the Nth iteration of the header file.
    #define GENERIC_FACTORY_APPEND_PLACEHOLDER(z, current, last) BOOST_PP_COMMA() BOOST_PP_CAT(std::placeholders::_, BOOST_PP_ADD(current, 1))

    //This is the class which we are generating multiple times
    template <class KeyType, class BasePointerType BOOST_PP_ENUM_TRAILING_PARAMS(N, typename T)>
    class BOOST_PP_CAT(GenericFactory_, N)
    {
        public:
            typedef BasePointerType result_type;

        public:
            virtual ~BOOST_PP_CAT(GenericFactory_, N)() {}

            //Registers a derived type against a particular key.
            template <class DerivedType>
            void Register(const KeyType& key)
            {
                m_creatorMap[key] = std::bind(&BOOST_PP_CAT(GenericFactory_, N)::CreateImpl<DerivedType>, this BOOST_PP_REPEAT(N, GENERIC_FACTORY_APPEND_PLACEHOLDER, N));
            }

            //Deregisters an existing registration.
            bool Deregister(const KeyType& key)
            {
                return (m_creatorMap.erase(key) == 1);
            }

            //Returns true if the key is registered in this factory, false otherwise.
            bool IsCreatable(const KeyType& key) const
            {
                return (m_creatorMap.count(key) != 0);
            }

            //Creates the derived type associated with key. Throws std::out_of_range if key not found.
            BasePointerType Create(const KeyType& key BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N,const T,& a)) const
            {
                return m_creatorMap.at(key)(BOOST_PP_ENUM_PARAMS(N,a));
            }

        private:
            //This method performs the creation of the derived type object on the heap.
            template <class DerivedType>
            BasePointerType CreateImpl(BOOST_PP_ENUM_BINARY_PARAMS(N,const T,& a))
            {
                BasePointerType pNewObject(new DerivedType(BOOST_PP_ENUM_PARAMS(N,a)));
                return pNewObject;
            }

        private:
            typedef std::function<BasePointerType (BOOST_PP_ENUM_BINARY_PARAMS(N,const T,& BOOST_PP_INTERCEPT))> CreatorFuncType;
            typedef std::unordered_map<KeyType, CreatorFuncType> CreatorMapType;
            CreatorMapType m_creatorMap;
    };

    #undef N
    #undef GENERIC_FACTORY_APPEND_PLACEHOLDER

#endif // defined(BOOST_PP_IS_ITERATING)
#endif // include guard

আমি সাধারণত ভারী ম্যাক্রো ব্যবহারের বিরোধিতা করছি, তবে আমি এখানে একটি ব্যতিক্রম তৈরি করেছি। উপরের কোডটি GENERIC_FACTORY_MAX_ARITY +1 জেনারিকফ্যাক্টরি_এন নামের একটি শ্রেণির জেনারেট করে, প্রতিটি N এর মধ্যে 0 এবং GENERIC_FACTORY_MAX_ARITY সমেত অন্তর্ভুক্ত।

উত্পন্ন ক্লাস টেমপ্লেট ব্যবহার করে সহজ। ধরুন আপনি একটি স্ট্রিং ম্যাপিং ব্যবহার করে বেস্ল্যাসের প্রাপ্ত বস্তু তৈরি করতে একটি কারখানা চান। উদ্ভূত বস্তুর প্রত্যেকটি গঠনকারী পরামিতি হিসাবে 3 পূর্ণসংখ্যা নেয়।

#include "GenericFactory.hpp"

typedef GenericFactory_3<std::string, std::shared_ptr<BaseClass>, int, int int> factory_type;

factory_type factory;
factory.Register<DerivedClass1>("DerivedType1");
factory.Register<DerivedClass2>("DerivedType2");
factory.Register<DerivedClass3>("DerivedType3");

factory_type::result_type someNewObject1 = factory.Create("DerivedType2", 1, 2, 3);
factory_type::result_type someNewObject2 = factory.Create("DerivedType1", 4, 5, 6);

জেনেরিকফ্যাক্ট_এন ক্লাস ডিস্ট্রাক্টর নিম্নলিখিত অনুমতি দেয় ভার্চুয়াল।

class SomeBaseFactory : public GenericFactory_2<int, BaseType*, std::string, bool>
{
    public:
        SomeBaseFactory() : GenericFactory_2()
        {
            Register<SomeDerived1>(1);
            Register<SomeDerived2>(2);
        }
}; 

SomeBaseFactory factory;
SomeBaseFactory::result_type someObject = factory.Create(1, "Hi", true);
delete someObject;

উল্লেখ্য জেনেরিক কারখানা জেনারেটর ম্যাক্রো এই লাইন

#define BOOST_PP_FILENAME_1 "GenericFactory.hpp"

জেনেরিক ফ্যাক্টরি শিরোনাম ফাইলটি জেনেরিকফ্যাক্টরী.পি.পি. নামক অনুমান করে


আমি সি ++ কারখানার সম্পর্কে আরেকটি এসও প্রশ্নে উত্তর দিয়েছি। একটি নমনীয় কারখানা সুদ there দয়া করে there দেখুন। আমি ম্যাক্রো ব্যবহার করার জন্য ইটি ++ থেকে একটি পুরানো পদ্ধতি বর্ণনা করার চেষ্টা করেছি যা আমার জন্য দুর্দান্ত কাজ করেছে।

ET++ সি ++ এবং এক্স 11 এ পুরানো MacApp পোর্ট করার একটি প্রকল্প ছিল। এর প্রচেষ্টায় এরিম গামা ইত্যাদি ডিজাইন প্যাটার্নস সম্পর্কে ভাবতে লাগলো


জাভা হিসাবে অর্থ প্রতিফলন। এখানে কিছু তথ্য আছে: http://msdn.microsoft.com/en-us/library/y0114hz2(VS.80).aspx

সাধারণভাবে বলছেন, "c ++ প্রতিফলন" এর জন্য গুগল অনুসন্ধান করুন


টর ব্রেড ভেক্টার্লি আপনাকে একটি বুস্ট এক্সটেনশান সরবরাহ করে যা আপনাকে যথাযথ কার্যকারিতা দেয়। বর্তমানে, এটি সাম্প্রতিক বুস্ট লিবাসগুলির সাথে সামান্য অদ্ভুত ফিটিং, তবে আমি তার বেস নামস্থান পরিবর্তন করার পরে এটি 1.48_0 দিয়ে কাজ করতে সক্ষম হয়েছিলাম।

http://arcticinteractive.com/static/boost/libs/factory/doc/html/factory/factory.html#factory.factory.reference

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

এখানে কাঠামো ব্যবহার করার প্রধান সুবিধা (কোথাও ফল-তালিকা বজায় রাখার উপরে) নিবন্ধন ফাংশনটি প্রতিটি শ্রেণীর সংজ্ঞা (এবং শুধুমাত্র নিবন্ধিত শ্রেণির জন্য নিবন্ধন ফাংশন কল করার কোডের একটি লাইন দরকার) - এটির একটি ফাইলের বিপরীতে ফল তালিকা, যা প্রতিটি সময় ম্যানুয়ালি যোগ করা উচিত একটি নতুন ক্লাস প্রাপ্ত হয়।

আমি কারখানাটিকে আমার বেস ক্লাসের স্ট্যাটিক সদস্য বানিয়েছি।


না, কেউ নেই, যদি না আপনি নিজেকে ম্যাপিং না। সি ++গুলির এমন বস্তু তৈরি করার কোন পদ্ধতি নেই যার রেনটাইম নির্ধারিত হয়। আপনি নিজের ম্যাপিং করতে একটি মানচিত্র ব্যবহার করতে পারেন, যদিও:

template<typename T> Base * createInstance() { return new T; }

typedef std::map<std::string, Base*(*)()> map_type;

map_type map;
map["DerivedA"] = &createInstance<DerivedA>;
map["DerivedB"] = &createInstance<DerivedB>;

এবং তারপর আপনি করতে পারেন

return map[some_string]();

একটি নতুন উদাহরণ পেয়ে। আরেকটি ধারণা হচ্ছে তাদের নিজস্ব নাম নিবন্ধন করা:

// in base.hpp:
template<typename T> Base * createT() { return new T; }

struct BaseFactory {
    typedef std::map<std::string, Base*(*)()> map_type;

    static Base * createInstance(std::string const& s) {
        map_type::iterator it = getMap()->find(s);
        if(it == getMap()->end())
            return 0;
        return it->second();
    }

protected:
    static map_type * getMap() {
        // never delete'ed. (exist until program termination)
        // because we can't guarantee correct destruction order 
        if(!map) { map = new map_type; } 
        return map; 
    }

private:
    static map_type * map;
};

template<typename T>
struct DerivedRegister : BaseFactory { 
    DerivedRegister(std::string const& s) { 
        getMap()->insert(std::make_pair(s, &createT<T>));
    }
};

// in derivedb.hpp
class DerivedB {
    ...;
private:
    static DerivedRegister<DerivedB> reg;
};

// in derivedb.cpp:
DerivedRegister<DerivedB> DerivedB::reg("DerivedB");

আপনি নিবন্ধনের জন্য একটি ম্যাক্রো তৈরি করার সিদ্ধান্ত নিতে পারে

#define REGISTER_DEC_TYPE(NAME) \
    static DerivedRegister<NAME> reg

#define REGISTER_DEF_TYPE(NAME) \
    DerivedRegister<NAME> NAME::reg(#NAME)

আমি যদিও যারা দুই জন্য ভাল নাম আছে নিশ্চিত নই। এখানে আরেকটি জিনিস যা বোঝাতে পারে সেটি এখানে shared_ptr ব্যবহার করা হয়।

যদি আপনার কোন সাধারণ বেস-ক্লাস থাকে না এমন সম্পর্কযুক্ত কোনও সেট থাকে তবে আপনি ফাংশন পয়েন্টারটিকে boost::variant<A, B, C, D, ...> একটি রিটার্ন টাইপ দিতে পারেন। আপনার যদি Foo, বার এবং Baz একটি বর্গ আছে, এটি ভালো লাগে:

typedef boost::variant<Foo, Bar, Baz> variant_type;
template<typename T> variant_type createInstance() { 
    return variant_type(T()); 
}

typedef std::map<std::string, variant_type (*)()> map_type;

একটি boost::variant একটি ইউনিয়ন মত। কোন বস্তুটি শুরু বা এটির জন্য বরাদ্দ করার জন্য ব্যবহৃত হয় তা দেখে এটি কোন ধরণের সঞ্চয় করে তা জানেন। here তার ডকুমেন্টেশন তাকান here । অবশেষে, একটি কাঁচা ফাংশন পয়েন্টার ব্যবহার একটু পুরাতন। আধুনিক সি ++ কোড নির্দিষ্ট ফাংশন / ধরনের থেকে decoupled করা উচিত। আপনি একটি ভাল উপায় সন্ধান করতে Boost.Function মধ্যে দেখতে চাইতে পারেন। এটি তখন এটি (মানচিত্রে) দেখতে হবে:

typedef std::map<std::string, boost::function<variant_type()> > map_type;

std::function সি ++ এর পরবর্তী সংস্করণেও পাওয়া যাবে, std::shared_ptr সহ।


বস্তু নিবন্ধনের জন্য বিস্তারিত সমাধান, এবং স্ট্রিং নাম দিয়ে তাদের অ্যাক্সেস।

common.h

#ifndef COMMON_H_
#define COMMON_H_


#include<iostream>
#include<string>
#include<iomanip>
#include<map>

using namespace std;
class Base{
public:
    Base(){cout <<"Base constructor\n";}
    virtual ~Base(){cout <<"Base destructor\n";}
};
#endif /* COMMON_H_ */

test1.h :

/*
 * test1.h
 *
 *  Created on: 28-Dec-2015
 *      Author: ravi.prasad
 */

#ifndef TEST1_H_
#define TEST1_H_
#include "common.h"

class test1: public Base{
    int m_a;
    int m_b;
public:
    test1(int a=0, int b=0):m_a(a),m_b(b)
    {
        cout <<"test1 constructor m_a="<<m_a<<"m_b="<<m_b<<endl;
    }
    virtual ~test1(){cout <<"test1 destructor\n";}
};



#endif /* TEST1_H_ */

3. test2.h
#ifndef TEST2_H_
#define TEST2_H_
#include "common.h"

class test2: public Base{
    int m_a;
    int m_b;
public:
    test2(int a=0, int b=0):m_a(a),m_b(b)
    {
        cout <<"test1 constructor m_a="<<m_a<<"m_b="<<m_b<<endl;
    }
    virtual ~test2(){cout <<"test2 destructor\n";}
};


#endif /* TEST2_H_ */

main.cpp :

#include "test1.h"
#include "test2.h"

template<typename T> Base * createInstance(int a, int b) { return new T(a,b); }

typedef std::map<std::string, Base* (*)(int,int)> map_type;

map_type mymap;

int main()
{

    mymap["test1"] = &createInstance<test1>;
    mymap["test2"] = &createInstance<test2>;

     /*for (map_type::iterator it=mymap.begin(); it!=mymap.end(); ++it)
        std::cout << it->first << " => " << it->second(10,20) << '\n';*/

    Base *b = mymap["test1"](10,20);
    Base *b2 = mymap["test2"](30,40);

    return 0;
}

কম্পাইল এবং চালান (Eclipse এর সাথে এটি সম্পন্ন করেছেন)

আউটপুট:

Base constructor
test1 constructor m_a=10m_b=20
Base constructor
test1 constructor m_a=30m_b=40




instantiation