Indicatorul pentru funcțiile de membru - C ++ std :: lista de sortare

voturi
4

Cum pot trece un pointer la o funcție membru pentru a std :: list.sort ()?

Este posibil? Mulțumiri

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

Vreau să folosesc o lungime variabilă din cadrul clasei în loc de a face strlen () în cadrul funcției de comparare (valoarea va fi întotdeauna aceeași lungime)

Editare: a myValueLength nu a fost singura variabilă am vrut să acceseze din cadrul funcției de comparare am simplificat ea pentru a face un exemplu mai scurt.

Întrebat 12/03/2009 la 14:16
sursa de către utilizator
În alte limbi...                            


6 răspunsuri

voturi
3

Este posibil să doriți să utilizați un functor.

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

Publicat 12/03/2009 la 14:18
sursa de către utilizator

voturi
1

Rețineți că std::listsortează elementul în funcție operator<definit pentru acel element. Trebuie să schimbați dvs. comparefuncția de a utiliza un nivel global operator<definit pentru Nodeobiecte:

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;

}

O îmbunătățire a sugerat va fi:

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]);
}

În cazul în care char *Valuereprezintă într - adevăr un șir de caractere de tip C, si doriti sortarea lexicografică, îmbunătățiri suplimentare sunt posibile:

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

și dacă acestea sunt într - adevăr siruri de caractere, vă sugerez să utilizați std::stringși puteți scrie:

bool operator<(Node const& first, Node const& second) {
     return first.Value < second.Value;
}
Publicat 12/03/2009 la 14:23
sursa de către utilizator

voturi
7

Este posibil. V-ati folosi impuls :: funcția?

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

Este funcția „compara“ se va baza pe acest date? Dacă nu - s -ar putea face simpy „compara“ funcția de a fi statică . Și atunci va fi

list.sort( &myClass::compare );

Puteți adăuga ajutor struct pentru a face comparația și apoi

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;
};
Publicat 12/03/2009 la 14:26
sursa de către utilizator

voturi
7

Explicând Grieve a răspuns, de ce să nu folosiți un functor? De exemplu:

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

Apoi, ai putea folosi doar:

Functor f;
myList.sort(f);

Ai putea folosi chiar clasa ca Functorul prin definirea operatorului () ...

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

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

exemplu simplu cod:

#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;
}
Publicat 12/03/2009 la 15:25
sursa de către utilizator

voturi
0

Așa cum întristăm & mrree sugerat

pur și simplu suprasolicitarea) lucrări de operator (

Multumesc tuturor celor care au răspuns

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);
}
Publicat 12/03/2009 la 15:32
sursa de către utilizator

voturi
0

De ce nu face funcția compara statică, atunci nu mai este nevoie de functorul. Apoi, puteți face pur și simplu list.sort (comparare);

Nevermind ... tocmai am realizat funcția de a compara este folosind un membru de date de clasă, astfel că nu poate fi static. Utilizați Functor :)

Publicat 02/03/2012 la 03:17
sursa de către utilizator

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