सदस्य कार्यों के लिए सूचक - सी ++ std :: सूची प्रकार

वोट
4

कैसे मैं) एसटीडी एक सदस्य कार्य करने के लिए एक सूचक पारित करते :: list.sort (?

क्या यह संभव है? धन्यवाद

struct Node {
       uint32_t ID;
       char *   Value;
};

class myClass {
          private:
            uint32_t  myValueLength;
          public:
            list<queueNode *> MyQueue;
            bool compare(Node * first, Node * second);
            bool doStuff();
}

bool myClass::compare(Node * first, Node * second) {
    unsigned int ii =0;
    while (ii < myValueLength)
    {
        if (first-> Value[ii] < second-> Value[ii]) 
        {
            return true;
        } else if (first-> Value[ii] > second-> Value[ii])
        {
            return false;
        }

        ++ii;
    }

    return false;
}

bool myClass::doStuff()
{
    list.sort(compare);
}

मैं बजाय strlen () की तुलना समारोह के भीतर करने का वर्ग के भीतर से लंबाई चर का उपयोग करना चाहते हैं (मूल्य हमेशा एक ही लंबाई हो जाएगा)

संपादित करें: myValueLength केवल चर मैं तुलना समारोह मैं सिर्फ यह उदाहरण कम करने के लिए सरल बनाया से पहुंचना चाहता था नहीं था।

12/03/2009 को 16:16
का स्रोत उपयोगकर्ता
अन्य भाषाओं में...                            


6 जवाब

वोट
7

पर विस्तार से चर्चा करते शोक की प्रतिक्रिया, क्यों एक functor का उपयोग नहीं? उदाहरण के लिए:

struct Functor
{
  bool operator()( char * a, char * b )
    { return strcmp(a,b) < 0; }
};

तो फिर तुम सिर्फ इस्तेमाल कर सकते हैं:

Functor f;
myList.sort(f);

तुम भी ऑपरेटर को परिभाषित करते हुए functor के रूप में अपने वर्ग इस्तेमाल कर सकते हैं () ...

class myClass {
  ...
  bool operator()( queueNode * a, queueNode * b )
  { return compare( a, b ); }

  void doStuff() { MyQueue.sort(*this); }
};

सरल उदाहरण कोड:

#include <iostream>
#include <list>
using namespace std;

  // Assumes  TYPE t; cout << t;  is valid.
template<class TYPE>
inline ostream & operator<< ( ostream & theOstream,
                              const list<TYPE> & theList )
{
  typename list<TYPE>::const_iterator listIterator = theList.begin();
  for ( int i = 0;   listIterator != theList.end();  listIterator ++, i ++ )
    theOstream << "    [" << i << "]:   \"" << (*listIterator) << "\"" << endl;
  return theOstream;
}

struct Functor
{
  bool operator()( const char * a, const char * b )
    { return strcmp(a,b) < 0; }
};

int
main()
{
  list<char*>  l;

    /* Load up some example test data... */
  char  s[3];
  s[2] = '\0';
  for (   s[0]='c'; s[0]>='a'; s[0]-- )
    for ( s[1]='c'; s[1]>='a'; s[1]--  )
      l.push_back(strdup(s));

    /* Show us that test data... */
  cout << l << endl;

    /* Sort list. */
  Functor f;
  l.sort(f);

    /* Show us what we have now... */
  cout << l << endl;
}
12/03/2009 को 17:25
का स्रोत उपयोगकर्ता

वोट
7

हो सकता है। आप को बढ़ावा देने :: समारोह उपयोग करने पर विचार किया?

list.sort( boost::bind( &myClass::compare, this, _1, _2 ) );

अपने 'की तुलना' समारोह पर निर्भर करेगा है इस डेटा? यदि नहीं - आप मेकअप simpy सकता है 'की तुलना' होने के लिए कार्य करते हैं स्थिर । और फिर यह हो जाएगा

list.sort( &myClass::compare );

आप अपनी तुलना करने के लिए सहायक struct जोड़ सकते हैं और उसके बाद

list.sort( Comparer( myValueLength ) );

struct Comparer
{
    Comparer( uint32_t myValueLength ):
        length( myValueLength )
    {}

    bool operator() (Node * first, Node * second)
    {
        unsigned int ii =0;
        while (ii < length)
        {
            if (first-> Value[ii] < second-> Value[ii]) 
            {
                    return true;
            } else if (first-> Value[ii] > second-> Value[ii])
            {
                    return false;
            }

            ++ii;
        }

        return false;
    }


    uint32_t length;
};
12/03/2009 को 16:26
का स्रोत उपयोगकर्ता

वोट
3

आप एक functor उपयोग कर सकते हैं।

http://www.newty.de/fpt/functor.html

12/03/2009 को 16:18
का स्रोत उपयोगकर्ता

वोट
1

ध्यान दें कि std::listके अनुसार तत्व सॉर्ट करता operator<है कि तत्व के लिए परिभाषित। आप अपने को बदलने की जरूरत compareएक वैश्विक उपयोग करने के लिए समारोह operator<के लिए परिभाषित Nodeवस्तुओं:

bool operator<(Node const& first, Node const& second) {
unsigned int ii =0;
while (ii < length)
{
    if (first.Value[ii] < second.Value[ii]) 
    {
            return true;
    } else if (first.Value[ii] > second.Value[ii])
    {
            return false;
    }

    ++ii; 
}

return false;

}

एक सुझाव सुधार हो जाएगा:

bool operator<(Node const& first, Node const& second) {
    for (size_t ii =0; first.Value[ii] == second.Value[ii]; ++ii) ; // note ;
    return (first.Value[ii] < second.Value[ii]);
}

यदि char *Valueवास्तव में एक सी शैली स्ट्रिंग का प्रतिनिधित्व करता है, और आप चाहते हैं कोषगत छंटाई, और अधिक सुधारों संभव हो रहे हैं:

bool operator<(Node const& first, Node const& second) {
     return (strcmp(first.Value, second.Value) < 0);
}

और यदि वे वास्तव में तार कर रहे हैं, मैं सुझाव है कि आप का उपयोग std::stringकरें और आप लिख सकते हैं:

bool operator<(Node const& first, Node const& second) {
     return first.Value < second.Value;
}
12/03/2009 को 16:23
का स्रोत उपयोगकर्ता

वोट
0

क्यों नहीं अपने तुलना समारोह स्थिर बनाने, तो आपको अब functor की जरूरत है। तो फिर तुम बस list.sort कर सकते हैं (तुलना);

कोई बात नहीं ... मैं सिर्फ महसूस किया अपने तुलना समारोह एक वर्ग डेटा सदस्य उपयोग कर रहा है तो यह स्थिर नहीं हो सकता। Functor का प्रयोग करें :)

02/03/2012 को 06:17
का स्रोत उपयोगकर्ता

वोट
0

के रूप में शोक और mrree सुझाव

बस () ऑपरेटर काम करता है ओवरलोडिंग

सभी को धन्यवाद जो जवाब

struct Node {
       uint32_t ID;
       char     *       Value;
};

class myClass {
          private:
            uint32_t  myValueLength;
          public:
            list<queueNode *> MyQueue;
            bool operator()(Node * first, Node * second);
            bool doStuff();
}

bool myClass::operator()(Node * first, Node * second) {
    unsigned int ii =0;
    while (ii < myValueLength)
    {
        if (first-> Value[ii] < second-> Value[ii]) 
        {
                return true;
        } else if (first-> Value[ii] > second-> Value[ii])
        {
                return false;
        }

        ++ii;
    }

    return false;
}

bool myClass::doStuff()
{
    list.sort(*this);
}
12/03/2009 को 17:32
का स्रोत उपयोगकर्ता

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more