কেন কোনও ডিফল্ট মুভ-অ্যাসাইনমেন্ট / মুভ-কনস্ট্রাক্টর নেই?

Question 1

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

এটি যুক্ত করুন, আমি যদি std::moveঅস্থাবর বস্তুগুলিতে ব্যবহার করি তবে এটি অ্যাসাইনমেন্ট-অপারেটরটি ব্যবহার করে, অর্থ std::moveপুরোপুরি নিরাপদ।

আমি যেহেতু একটি সাধারণ প্রোগ্রামার, আমি লিখছি প্রতি ক্লাসে একটি মুভ কনস্ট্রাক্টর / অ্যাসাইনমেন্ট অপারেটর যুক্ত না করেই মুভ-সক্ষমতার সুবিধা নিতে চাই, কারণ সংকলকটি কেবল তাদের হিসাবে প্রয়োগ করতে পারে " this->member1_ = std::move(other.member1_);..."

তবে এটি (কমপক্ষে ভিজ্যুয়াল ২০১০ এ নয়) এর কোনও বিশেষ কারণ আছে কি না?

অধিক গুরুত্বের সাথে; এই সমস্যা এড়ানোর পেতে কোন উপায় আছে কি?

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

Question 2

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

ইস্যুর ইতিহাস সম্পর্কে আরও তথ্যের জন্য, ২০১০ এর ডাব্লুজি 21 পত্রিকার তালিকাটি দেখুন এবং " মুভি " অনুসন্ধান করুন

বর্তমান স্পেসিফিকেশন (নভেম্বর থেকে N3225) জানিয়েছে (N3225 12.8 / 8):

যদি কোনও শ্রেণীর সংজ্ঞা Xস্পষ্টভাবে কোনও মুভ কনস্ট্রাক্টরকে ঘোষণা না করে তবে একটি স্পষ্টতই খেলাপী হিসাবে ঘোষণা করা হবে যদি এবং কেবল যদি

X কোনও ব্যবহারকারী-ঘোষিত অনুলিপি নির্মাণকারী নেই এবং

X কোনও ব্যবহারকারী-ঘোষিত অনুলিপি অপারেটর নেই

X কোনও ব্যবহারকারী-ঘোষিত মুভ অ্যাসাইনমেন্ট অপারেটর নেই,

X ব্যবহারকারীর দ্বারা ঘোষিত ডেস্ট্রাক্টর নেই এবং

মুভ কনস্ট্রাক্টর মুছে ফেলা হিসাবে স্পষ্টভাবে সংজ্ঞায়িত করা হবে না।

মুভ অ্যাসাইনমেন্ট অপারেটরকে স্পষ্টতই খেলাপি হিসাবে ঘোষণা করা হলে নির্দিষ্ট করে 12.8 / 22 তে একই ভাষা রয়েছে। আপনি N3203 এ অন্তর্নিহিত পদক্ষেপের প্রজন্মের বর্তমান স্পেসিফিকেশনকে সমর্থন করার জন্য করা পরিবর্তনের সম্পূর্ণ তালিকাটি খুঁজে পেতে পারেন : অন্তর্নিহিত পদক্ষেপগুলি উত্পন্ন করার শর্তকে আরও শক্ত করে তোলা , যা মূলত বজর্ন স্ট্রস্ট্রপের পেপার এন 32012 এর প্রস্তাবিত রেজোলিউশনের একটির উপর ভিত্তি করে ছিল : ডানদিকে সরানো ।

Question 3

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

তবে শেষ পর্যন্ত, স্ট্যান্ডার্ডটিতে মুভ কনস্ট্রাক্টর এবং মুভ অ্যাসাইনমেন্ট অপারেটরগুলির অন্তর্ভুক্ত জেনারেশন অন্তর্ভুক্ত ছিল যদিও সীমাবদ্ধতার মোটামুটি উল্লেখযোগ্য তালিকা সহ:

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

যদিও গল্পটি আছে তেমন কিছু নয়। একটি কর্টোর ঘোষিত হতে পারে, কিন্তু এখনও মুছে ফেলা হিসাবে সংজ্ঞায়িত:

একটি স্পষ্টভাবে ঘোষিত অনুলিপি / মুভ নির্মাণকারী তার শ্রেণীর একটি ইনলাইন পাবলিক সদস্য। দশম শ্রেণির জন্য একটি ডিফল্ট কপি / মুভ কনস্ট্রাক্টরকে মুছে ফেলা (8.4.3) হিসাবে সংজ্ঞায়িত করা হয় যদি এক্স থাকে:

- অ-তুচ্ছ সম্পর্কিত কনস্ট্রাক্টর এবং এক্স সহ একটি বৈকল্পিক সদস্য হ'ল ইউনিয়নের মতো শ্রেণি
- ক্লাস টাইপ এম (বা এর অ্যারে) এর একটি অ স্থিতিশীল ডেটা সদস্য যা অনুলিপি / সরানো যায় না কারণ ওভারলোড রেজোলিউশন (১৩.৩) হিসাবে এম এর সংশ্লিষ্ট কন্সট্রাক্টরের ক্ষেত্রে প্রয়োগ করা হয়েছে, দ্ব্যর্থহীন কন্সট্রাক্টর থেকে মুছে ফেলা বা অ্যাক্সেসযোগ্য কোনও ফাংশন বা ফলস্বরূপ ফলাফল ঘটে
- একটি সরাসরি বা ভার্চুয়াল বেস ক্লাস বি যা অনুলিপি / সরানো যায় না কারণ ওভারলোড রেজোলিউশন (13.3), বি এর সাথে সম্পর্কিত কনস্ট্রাক্টরের ক্ষেত্রে প্রয়োগ করা হয়েছে , অস্পষ্টতা বা ডিফল্ট কন্সট্রাক্টর থেকে মুছে ফেলা বা অ্যাক্সেসযোগ্য এমন কোনও ফাংশনের ফলস্বরূপ
- কোনও প্রত্যক্ষ বা ভার্চুয়াল বেস শ্রেণি বা ডিস্ট্রাক্টর এমন কোনও ধরণের অ-স্থিতিশীল ডেটা সদস্য যা ডিফল্ট কন্সট্রাক্টর থেকে মুছে ফেলা বা অ্যাক্সেসযোগ্য,
- অনুলিপি কনস্ট্রাক্টরের জন্য, মূলসূত্র রেফারেন্স প্রকারের একটি অ স্থিতিশীল ডেটা সদস্য, বা
- মুভ কনস্ট্রাক্টরের জন্য , স্থিতিবিহীন ডেটা সদস্য বা সরাসরি বা ভার্চুয়াল বেস শ্রেণীর সাথে এমন একটি ধরণের মুভ কনস্ট্রাক্টর নেই এবং তুচ্ছভাবে নয় অনুলিপিযোগ্য।

Question 4

(এখনও হিসাবে, আমি একটি বোকা ম্যাক্রো উপর কাজ করছি ...)

হ্যাঁ, আমিও সেই পথে চলেছি। আপনার ম্যাক্রো এখানে:

// detail/move_default.hpp
#ifndef UTILITY_DETAIL_MOVE_DEFAULT_HPP
#define UTILITY_DETAIL_MOVE_DEFAULT_HPP

#include <boost/preprocessor.hpp>

#define UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR_BASE(pR, pData, pBase) pBase(std::move(pOther))
#define UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT_BASE(pR, pData, pBase) pBase::operator=(std::move(pOther));

#define UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR(pR, pData, pMember) pMember(std::move(pOther.pMember))
#define UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT(pR, pData, pMember) pMember = std::move(pOther.pMember);

#define UTILITY_MOVE_DEFAULT_DETAIL(pT, pBases, pMembers)                                               \
        pT(pT&& pOther) :                                                                               \
        BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(                                                       \
            UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR_BASE, BOOST_PP_EMPTY, pBases))                      \
        ,                                                                                               \
        BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(                                                       \
            UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR, BOOST_PP_EMPTY, pMembers))                         \
        {}                                                                                              \
                                                                                                        \
        pT& operator=(pT&& pOther)                                                                      \
        {                                                                                               \
            BOOST_PP_SEQ_FOR_EACH(UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT_BASE, BOOST_PP_EMPTY, pBases)  \
            BOOST_PP_SEQ_FOR_EACH(UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT, BOOST_PP_EMPTY, pMembers)     \
                                                                                                        \
            return *this;                                                                               \
        }

#define UTILITY_MOVE_DEFAULT_BASES_DETAIL(pT, pBases)                                                   \
        pT(pT&& pOther) :                                                                               \
        BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(                                                       \
            UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR_BASE, BOOST_PP_EMPTY, pBases))                      \
        {}                                                                                              \
                                                                                                        \
        pT& operator=(pT&& pOther)                                                                      \
        {                                                                                               \
            BOOST_PP_SEQ_FOR_EACH(UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT_BASE, BOOST_PP_EMPTY, pBases)  \
                                                                                                        \
            return *this;                                                                               \
        }

#define UTILITY_MOVE_DEFAULT_MEMBERS_DETAIL(pT, pMembers)                                               \
        pT(pT&& pOther) :                                                                               \
        BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(                                                       \
            UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR, BOOST_PP_EMPTY, pMembers))                         \
        {}                                                                                              \
                                                                                                        \
        pT& operator=(pT&& pOther)                                                                      \
        {                                                                                               \
            BOOST_PP_SEQ_FOR_EACH(UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT, BOOST_PP_EMPTY, pMembers)     \
                                                                                                        \
            return *this;                                                                               \
        }

#endif

اور

// move_default.hpp
#ifndef UTILITY_MOVE_DEFAULT_HPP
#define UTILITY_MOVE_DEFAULT_HPP

#include "utility/detail/move_default.hpp"

// move bases and members
#define UTILITY_MOVE_DEFAULT(pT, pBases, pMembers) UTILITY_MOVE_DEFAULT_DETAIL(pT, pBases, pMembers)

// base only version
#define UTILITY_MOVE_DEFAULT_BASES(pT, pBases) UTILITY_MOVE_DEFAULT_BASES_DETAIL(pT, pBases)

// member only version
#define UTILITY_MOVE_DEFAULT_MEMBERS(pT, pMembers) UTILITY_MOVE_DEFAULT_MEMBERS_DETAIL(pT, pMembers)

#endif

(আমি আসল মন্তব্যগুলি সরিয়েছি, যা দৈর্ঘ্য এবং ডকুমেন্টারি।

আপনি আপনার শ্রেণীর বেসগুলি এবং / অথবা সদস্যদের একটি প্রিপ্রসেসর তালিকা হিসাবে নির্দিষ্ট করেন, উদাহরণস্বরূপ:

#include "move_default.hpp"

struct foo
{
    UTILITY_MOVE_DEFAULT_MEMBERS(foo, (x)(str));

    int x;
    std::string str;
};

struct bar : foo, baz
{
    UTILITY_MOVE_DEFAULT_BASES(bar, (foo)(baz));
};

struct baz : bar
{
    UTILITY_MOVE_DEFAULT(baz, (bar), (ptr));

    void* ptr;
};

এবং একটি মুভ-কনস্ট্রাক্টর এবং মুভ-এসাইনমেন্ট অপারেটর আসে।

(একদিকে যেমন, কেউ যদি জানতে পারে যে কীভাবে আমি বিশদগুলি এক ম্যাক্রোর সাথে সংযুক্ত করতে পারি তবে তা ফুলে উঠবে))

Question 5

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