std :: variant को अन्य std :: variant में प्रकारों के सुपर-सेट

Question

में कनवर्ट करें मेरे पास std::variant है जो मैं std::variant में कनवर्ट करना चाहता हूं जिसमें इसके प्रकार का सुपर-सेट है। क्या ऐसा करने का कोई तरीका है जिससे मुझे एक दूसरे को असाइन करने की अनुमति मिलती है?

template <typename ToVariant, typename FromVariant> 
ToVariant ConvertVariant(const FromVariant& from) { 
    ToVariant to = std::visit([](auto&& arg) -> ToVariant {return arg ; }, from); 
    return to; 
} 

int main() 
{ 
    std::variant<int , double> a; 
    a = 5; 
    std::variant <std::string, double, int> b; 
    b = ConvertVariant<decltype(b),decltype(a)>(a); 
    return 0; 
} 

मैं बस आदेश नहीं बल्कि इस जटिल कास्टिंग सेटअप के दौरान की तुलना में रूपांतरण करने के लिए b = a लिखने में सक्षम होना चाहते हैं। std नामस्थान प्रदूषित किए बिना।

संपादित करें:

error C2679: binary '=': no operator found which takes a right-hand operand of type 'std::variant<int,double>' (or there is no acceptable conversion) 

note: while trying to match the argument list '(std::variant<std::string,int,double>, std::variant<int,double>)' 

Answer 1

यह Yakk का दूसरा विकल्प के एक कार्यान्वयन है।

और जैसा कि आप इसके उपयोग को देख सकते हैं सरल है:

std::variant<int, char> v1 = 24; 
std::variant<int, char, bool> v2; 

v2 = variant_cast(v1); 

Answer 2

विकल्प::

• अपनी खुद की variant प्रकार, संभवतः std::variant से इनहेरिट, कि operator= और निर्माण जिस तरह से आप चाहते हैं को लागू करता है लिखें, बस b = a लेखन निम्न त्रुटि देता है । कुछ काम करना है, क्योंकि variant के निर्माता एसएफआईएनएई चाल कर सकते हैं जो आपके प्रकार के प्रकार के साथ ठीक से काम नहीं कर सकते हैं; उस अंत में, आप कुछ SFINAE को नग्न using घोषणाओं के बजाय बेस-वेरिएंट को अग्रेषित करना चाहते हैं।

• एक बेहतर ConvertVariant लिखें जो स्रोत/गंतव्य प्रकारों को सूचीबद्ध करने की आवश्यकता नहीं है। आप एक कन्वर्ट हेल्पर टेम्पलेट प्रकार वापस कर देंगे जो स्रोत संस्करण धारण करता है जिसमें operator std::variant<Ts...>()&& है जो आपके ConvertVariant की तरह कुछ कहता है।

  template <class... Args> 
  struct variant_cast_proxy 
  { 
      std::variant<Args...> v; 
  
      template <class... ToArgs> 
      operator std::variant<ToArgs...>() const 
      { 
       return std::visit([](auto&& arg) -> std::variant<ToArgs...> { return arg ; }, 
            v); 
      } 
  }; 
  
  template <class... Args> 
  auto variant_cast(const std::variant<Args...>& v) -> variant_cast_proxy<Args...> 
  { 
      return {v}; 
  } 
  

  आप अग्रेषण अर्थ विज्ञान के लिए ठीक धुन यह करने के लिए चाहते हो सकता है: