Use next_permutation para permutar un vector de clases

Question

¿Es posible usar std :: next_permutation() para permutar los elementos de un vector de una clase que creé?

¿Cómo funciona el parámetro de comparación en next_permutation()?

Answer 1

¿Es posible usar std :: next_permutation() para permutar los elementos de un vector de una clase que he creado?

Sí!

probar este

#include<iostream> 
#include<vector> 
#include<algorithm> 

int main() 
{ 
     typedef std::vector<int> V; //<or_any_class> 
     V v; 

     for(int i=1;i<=5;++i) 
     v.push_back(i*10); 
     do{ 
      std::cout<<v[0]<<" "<<v[1]<<" "<<v[2]<<" "<<v[3]<<" "<<v[4]<<std::endl;; 
     } 

     while(std::next_permutation(v.begin(),v.end())); 
} 

¿Cómo funciona el parámetro de comparación en next_permutation() funciona?

This podría ayudar

Answer 2

Sí, la forma más sencilla es anular el operador < dentro de su clase, en cuyo caso no tendrá que preocuparse por la comp.

El parámetro comp es un puntero a función que toma dos iteradores para el vector y devuelve verdadero o falso dependiendo de cómo desee que se ordenen.

Editar: No probado, pero para lo que vale la pena:

class myclass 
{ 
public: 
    myclass() : m_a(0){} 
    void operator = (int a) { m_a = a; } 

private: 
    friend bool operator<(const myclass& lhs, const myclass& rhs) { return lhs.m_a < rhs.m_a; } 
    int m_a; 
}; 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    myclass c; 
    std::vector<myclass> vec; 

    for(int i = 0; i < 10; ++i) 
    { 
     c = i; 
     vec.push_back(c); 
    } 

    //these two should perform the same given the same input vector 
    std::next_permutation(vec.begin(), vec.end());  
    std::next_permutation(vec.begin(), vec.end(), &operator<); 

    return 0; 
} 

Answer 3

1. Claro que sí; solo tiene que pasar un iterador al primer elemento y uno al penúltimo elemento, como es habitual con los algoritmos STL.

2. Es un functor usado para comparar elementos de su vector (o contenedor en general); debería comportarse como lo haría cualquier operador <: devuelve verdadero si el primer elemento es menor que el segundo, de lo contrario será falso, estableciendo así una relación de orden entre sus objetos. Tenga en cuenta que, como todos los operadores de comparación, debe seguir algunas reglas (here explicadas en un contexto ligeramente diferente, pero siempre son las mismas).

Por cierto, si se define un operador < para su clase sólo tiene que utilizar el primer sobrecarga (el que sólo los iteradores como parámetros) y evitar la creación de un funtor separada.