是否有可能使'=`更喜歡通過（刪除）複製分配進行轉換賦值？

Question

我發現一些線程暗示這不能完成，但沒有一個使用完全相同的運算符和條件組合，所以我想問一些更具體的問題。希望這意味着對某個人來說這是一個快速而簡單的答案......這種或那種方式！

考慮一個例子代理類，做存儲的較大塊中管理的值 - 在這個過於簡單，但代表性的例子：

class SomeProxyThing { 
    std::uint32_t storage; 

public: 
    operator std::uint16_t() const 
    { 
     return storage & 0x0000FFFF; 
    } 

    SomeProxyThing &operator=(std::uint16_t const value) 
    { 
     storage &= 0xFFFF0000; 
     storage |= value; 
    } 
}; 

我想所有分配通過定義用戶工作operator s。用戶應該只能夠進入或退出'暴露'類型，在這種情況下std::uint16_t。我可能會使用各種代理類類型，並希望它適用於所有這些類型。理想情況下，對於任何類型的組合，我只需鍵入someProxy = anotherProxy，然後讓編譯器完成剩下的工作。

但是，當作業的左側和右側有相同或繼承相關的類型時，默認的複製賦值運算符 - 當然會與此目標衝突。它會複製整個storage，從而破壞uint32_t的另一半 - 而不是僅根據需要複製「暴露」值。正確的！對於大多數情況。但是，即使LHS和RHS類型相同，我也想要一種「按轉換分配」的方式。爲了避免這種情況，我可以：

• 重新定義拷貝賦值運算符執行「代理」複製使用用戶定義的operator秒 - 這是我一直在做什麼，但似乎有點哈克和一樣，打破可複製的struct的狀態 - 我需要保留。它仍然memcpy() s 無論如何在g++，但我想定義的行爲。
• 或= delete複製賦值運算符（我們現在可以對TC類型進行操作）。但作業仍然嘗試使用它並拋出一個編譯錯誤 - 因爲delete意味着'如果我是所選擇的超載而中止一個錯誤'，而不是'將我排除在重載解析之外'。爲了解決這個問題，我必須明確地告訴編譯器使用轉換操作符，並從其結果分配：

SomeProxyThing a, b; 
a = 42; 
b = static_cast<std::uint16_t>(a); 
// a.k.a. 
b.operator=(a.operator std::uint16_t()); 

目前似乎沒有一種方法來告訴編譯器「忽略您首選的超載所產生的任何錯誤，並選擇下一個最好的錯誤'。在那兒？更一般地說，在這種情況下，有沒有什麼辦法/破解/可怕的kludge到強制編譯器自動使用/更喜歡某些operator s？

換句話說，理想情況下，在

SomeProxyThing a, b; 
a = 42; 
b = a; 

是b = a;會真正做到這一點：

b = static_cast<std::uint16_t>(a); 
// a.k.a. 
b.operator=(a.operator std::uint16_t()); 

沒有我不必手動鍵入此，使用static_cast，或實現命名的get/set方法。理想情況下，我希望對任何這樣的代理進行讀取/寫入，使其看起來像寫入代碼中的基本類型的讀取/寫入，全部使用=。

我強烈懷疑這是不可能的......但確認就好了！

Answer 1

編譯時間類型匹配/不匹配可以通過標準:: enable_if來控制。 隱式類型轉換可以通過顯式關鍵字禁用。 可以顯式刪除所有的複製和移動構造函數，以避免複製和默認的構造函數可以顯式標記爲默認值。 編輯：早期的答案考慮到這個問題的第一部分是「用戶應該只能夠在通過或擺脫‘暴露’型」，讓所有的轉換必須是明確的，但是完成，你可以定義一個平凡的答案可複製類，並使用您的代理類中 可能是你想要的東西：

#include <cstdint> 
#include <type_traits> 
struct copyable{ 
    std::uint32_t number = 0x0; 
}; 
class SomeProxyThing { 

public: 
    explicit operator std::uint16_t() const 
    { 
     return storage.number & 0x0000FFFF; 
    } 
template <typename T, typename std::enable_if<std::is_same<T, std::uint16_t>::value, int>::type=0> 
    SomeProxyThing& operator=(T value) 
    { 
     storage.number &= 0xFFFF0000; 
     storage.number |= value; 
     return *this; 
    } 

    SomeProxyThing()=default; 
    SomeProxyThing(const SomeProxyThing&)=delete; 
    SomeProxyThing(SomeProxyThing&&)=delete; 
    SomeProxyThing& operator=(const SomeProxyThing& other) { 
     this->storage.number = static_cast<std::uint16_t>(other.storage.number); 
    } 
    SomeProxyThing& operator=(SomeProxyThing&& other) { 
     this->storage.number = static_cast<std::uint16_t>(other.storage.number); 
    } 

private: 
    copyable storage; 
}; 
int main() 
{ 
    SomeProxyThing a, b; 
    a = static_cast<std::uint16_t>(43); 
    b = a; 
} 

Answer 2

你可以這樣做：

#include <stdint.h> 
#include <iostream> 
#include <type_traits> 

using namespace std; 

class Proxy_state 
{ 
protected: 
    uint32_t storage; 
public: 
    // Access to the bytes 
}; 

static_assert(is_trivially_copyable<Proxy_state>::value, "!"); 

class Some_proxy_thing 
    : public Proxy_state 
{ 
private: 

public: 
    operator std::uint16_t() const 
    { 
     return storage & 0x0000FFFF; 
    } 

    auto operator=(uint16_t const value) 
     -> Some_proxy_thing& 
    { 
     clog << "=(uint16_t)" << endl; 
     storage &= 0xFFFF0000; 
     storage |= value; 
     return *this; 
    } 

    auto operator=(Some_proxy_thing const& value) 
     -> Some_proxy_thing& 
    { return operator=(static_cast<uint16_t>(value)); } 
}; 

static_assert(not is_trivially_copyable<Some_proxy_thing>::value, "!"); 

auto main() 
    -> int 
{ 
    Some_proxy_thing a{}; 
    Some_proxy_thing b{}; 
    const Some_proxy_thing c = b; 

    a = c; 

    a = 123; 
    a = b; 
} 

這裏所有三個任務的輸出（標準錯誤流）=(uint16t)。