Neden varsayılan taşıma ataması / taşıma yapıcısı yok?

Ben basit bir programcıyım. Sınıf üyelerim değişkenleri çoğunlukla POD türleri ve STL kapsayıcılarından oluşur. Bu nedenle, bunlar varsayılan olarak uygulandığı için nadiren atama işleçleri yazmak veya oluşturucuları kopyalamak zorunda kalıyorum.

Buna ek olarak, std::movehareket ettirilemeyen nesnelerde kullanırsam, atama operatörünü kullanır, yani std::movetamamen güvenlidir.

Basit bir programcı olduğum için, yazdığım her sınıfa bir taşıma yapıcısı / atama operatörü eklemeden taşıma yeteneklerinden yararlanmak istiyorum, çünkü derleyici bunları " this->member1_ = std::move(other.member1_);..." olarak uygulayabilir.

Ama öyle değil (en azından Visual 2010'da değil), bunun özel bir nedeni var mı?

Daha önemlisi; Bu aşmanın bir yolu var mı?

Güncelleme: GManNickG'nin cevabına bakarsanız, bunun için harika bir makro sağlar. Ve eğer bilmiyorsanız, hareket-anlambilimini uygularsanız, takas üye işlevini kaldırabilirsiniz.

Hareket oluşturucuların ve atama operatörlerinin örtük üretimi tartışmalı olmuştur ve C ++ Standardının son taslaklarında büyük revizyonlar yapılmıştır, bu nedenle şu anda mevcut derleyiciler örtük üretime göre muhtemelen farklı davranacaktır.

Sorunun geçmişi hakkında daha fazla bilgi için 2010 WG21 makaleler listesine bakın ve "mov" araması yapın

Mevcut spesifikasyon (Kasım ayından itibaren N3225) (N3225 12.8 / 8) şunları belirtir:

Bir sınıfın tanımı, bir Xhareket yapıcısını açıkça bildirmezse, yalnızca ve yalnızca aşağıdaki durumlarda biri örtük olarak varsayılan olarak bildirilir.

• X kullanıcı tanımlı bir kopya oluşturucusuna sahip değil ve

• X kullanıcının beyan ettiği kopya atama operatörüne sahip değildir

• X kullanıcı tanımlı bir taşıma atama operatörüne sahip değil,

• X kullanıcı tanımlı bir yıkıcıya sahip değil ve

• taşıma yapıcısı örtük olarak silinmiş olarak tanımlanmayacaktır.

12.8 / 22'de, taşıma atama operatörünün örtük olarak varsayılan olarak bildirildiğini belirten benzer bir dil vardır. N3203'te örtük hareket oluşturmanın mevcut belirtimini desteklemek için yapılan değişikliklerin tam listesini bulabilirsiniz : Büyük ölçüde Bjarne Stroustrup'un N3201 adlı makalesi tarafından önerilen çözümlerden birine dayanan örtük hareketler oluşturma koşullarını sıkılaştırma: Devam etmek .

Örtük olarak oluşturulan hareket oluşturucular standart için dikkate alınmıştır, ancak tehlikeli olabilir. Dave Abrahams'ın analizine bakın .

Bununla birlikte, sonuçta standart, oldukça önemli bir sınırlama listesi olmasına rağmen, taşıma oluşturucularının ve taşıma atama operatörlerinin örtük üretimini içeriyordu:

Bir X sınıfının tanımı açıkça bir taşıma yapıcısı bildirmiyorsa, yalnızca ve yalnızca
- X'in kullanıcı tarafından bildirilen bir kopya oluşturucusu
yoksa , - X'in kullanıcı tarafından bildirilen bir kopya atama operatörü yoksa ,
- X'in kullanıcı tarafından bildirilen bir taşıma atama işleci yok,
- X'in kullanıcı tarafından bildirilmiş bir yıkıcısı yok ve
- taşıma yapıcısı örtük olarak silinmiş olarak tanımlanmayacak.

Yine de hikayenin tamamı bu değil. Bir ctor bildirilebilir, ancak yine de silinmiş olarak tanımlanabilir:

Örtük olarak bildirilmiş bir kopyala / taşı yapıcısı, sınıfının satır içi genel üyesidir. X sınıfı için varsayılan bir kopyalama / taşıma yapıcısı, X'in aşağıdakilere sahip olması durumunda silinmiş (8.4.3) olarak tanımlanır:

- önemsiz olmayan bir karşılık gelen kurucuya sahip bir değişken üye ve X, birleşim benzeri bir sınıftır,
- aşırı yük çözünürlüğü (13.3) nedeniyle kopyalanamayan / taşınamayan, sınıf tipi M'nin (veya bunun dizisi) statik olmayan bir veri üyesi, M'nin karşılık gelen yapıcısına uygulandığında, bir belirsizlik veya varsayılan kurucudan silinen veya erişilemeyen bir işlevle sonuçlanır -
B'nin karşılık gelen yapıcısına uygulandığı gibi aşırı yük çözünürlüğü (13.3) nedeniyle kopyalanamayan / taşınamayan doğrudan veya sanal bir temel B sınıfı varsayılan kurucudan silinen veya erişilemeyen bir belirsizlik veya işlevle sonuçlanır,
- varsayılan kurucudan silinen veya erişilemez bir yıkıcıya sahip herhangi bir doğrudan veya sanal temel sınıf veya statik olmayan veri üyesi,
- kopya oluşturucu için, rvalue başvuru türünün statik olmayan bir veri üyesi veya
- hareket oluşturucu için, bir hareket yapıcısı olmayan ve önemsiz olmayan bir türe sahip statik olmayan bir veri üyesi veya doğrudan veya sanal temel sınıf için kopyalanabilir.

(şimdilik aptal bir makro üzerinde çalışıyorum ...)

Evet, o yola ben de gittim. İşte makronuz:

// 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

(Uzunluk ve belgesel olan gerçek yorumları kaldırdım.)

Sınıfınızdaki tabanları ve / veya üyeleri önişlemci listesi olarak belirtirsiniz, örneğin:

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

Ve ortaya bir hareket kurucu ve hareket atama operatörü çıkıyor.

(Bir kenara gelecek olursak, ayrıntıları tek bir makroda nasıl birleştirebileceğimi bilen biri varsa, bu harika olurdu.)

VS2010, uygulama sırasında Standart olmadıkları için bunu yapmaz.