दर्दनाक जेनेरिक्स, ऑपरेटर '> =' प्रकार 'टी' की ऑपरेंड के लिए लागू नहीं किया जा सकता और 'टी'

Question

यहाँ मेरी कोड है:

class BinaryTree<T> 
{ 
    private node<T> Head; 
    public class node<T> 
    { 
    public T Data; 
    public node<T> right; 
    public node<T> left; 
    public node<T> parent; 
    ... 
    } 
    ... 
    private void insert(ref T data, node<T> parent, ref node<T> currentChild) 
    { 
    ... 
     { 
      if (currentChild.Data >= data) insert(ref data, currentChild, ref currentChild.right); 
      else insert(ref data, currentChild, ref currentChild.left); 
     } 
    } 
} 

से ऊपर बिंदु if (currentChild.Data >= data) पर मैं त्रुटि हो रही है:

ऑपरेटर '> =' प्रकार 'टी' की ऑपरेंड के लिए लागू नहीं किया जा सकता और 'टी'

मैं त्रुटि को हल करने क्या करते हैं?

Answer 1

इस समस्या का समाधान कर रहे हैं क्लासिक (1) TIComparable<T>, बनाने के लिए या (2) एक IComparer<T> या एक का उपयोग करें:

Answer 2

मुझे सी # के बारे में पता नहीं है, लेकिन जावा में आपको एक सामान्य तुलनात्मक वर्ग का उदाहरण होना होगा, जिस प्रकार आप तुलना करना चाहते हैं उसके साथ parametrized। इस जेनेरिक वर्ग ने तुलना() फ़ंक्शन प्रदान किया जो कि इस तरह कार्यान्वित किया जाएगा जो दो प्रकार की तुलना करने की अनुमति देता है।

class BinaryTree<T> where T : IComparable<T> 
{ 
    ... 
    public class node<T> where T : IComparable<T> ... 
    ... 
    if (currentChild.Data.CompareTo(data) >= 0) ... 
    ... 
} 

Answer 3

आपको लगता है कि टी IComparable लागू करता है, ताकि आप तुलना कर सकते हैं निर्दिष्ट करने की आवश्यकता आपकी कक्षा में मज़ाकिया।

(1)

class BinaryTree<T> where T : Comparable<T> ... 

(2)

class BinaryTree<T> { 
    private node<T> Head; 
    private readonly IComparer<T> comparer; 
    public BinaryTree(IComparer<T> comparer) { 
     this.comparer = comparer; 
    } 
    //... 
} 

Answer 4

टी एक प्रकार है कि IComparable लागू करता है और उसके बाद के बजाय> = की विधि के लिए अपनी compareTo का उपयोग किया जाना चाहिए। ऑपरेटर ओवरलोडिंग एक और विकल्प है यदि आप अभी भी समर्थन करना चाहते हैं> =।

Answer 5

मुझे लगता है कि डेटा Object प्रकार है और इस प्रकार स्वचालित रूप से एक> = ऑपरेशन की अनुमति नहीं देता है।
आप इतना है कि यह IComparable

class BinaryTree<T> where T : IComparable 

Answer 6

है कुछ लोगों को IComparable उपयोग करने का सुझाव जबकि टी के लिए एक बाधा जोड़ने की जरूरत है, मैं बजाय एक IComparer<T>, जो आपके पेड़ की एक क्षेत्र में संग्रहित किया जाना चाहिए उपयोग करने का सुझाव होगा। आपके पेड़ के रचनाकारों में से एक को IComparer<T> स्वीकार करना चाहिए, जिसे आपके क्षेत्र में संग्रहीत किया जाना चाहिए। दूसरे को शायद IComparer<T> फ़ील्ड को Comparer<T>.InvariantDefault() पर सेट करना चाहिए। इस प्रकार आपके पेड़ के उपभोक्ता इस प्रकार चुनने में सक्षम होंगे कि पेड़ के भीतर चीजें कैसे हल की जाएंगी। ध्यान दें कि यदि कक्षा का निर्माण होने पर IComparer<T> की आपूर्ति की जाती है, तो कोई वास्तविक कारण नहीं है कि T को IComparable<T> लागू करना होगा। एक संकलन-समय आवश्यकता को लागू करना अच्छा हो सकता है कि तुलनात्मक विधि निर्दिष्ट किए बिना पेड़ का निर्माण करते समय IComparer<T> लागू करें, लेकिन treeInstance = factoryClass.Create<myType>() जैसे कुछ अजीब सिंटैक्स की आवश्यकता के बिना ऐसा करने का कोई तरीका नहीं है जो treeClass<myType> का उदाहरण देगा।