Newsgroup: it.comp.lang.c++
Titolo: Borland C++ Builder 3: c.s. per permutazioni

Salve,
sto cercando del codice sorgente compilabile con l'implementazine in oggetto
e che sia in grado di produrre permutazioni.
Grazie
KF

 wrote in message
8htf76$j7o$1...@nslave2.tin.it...

Non dispone della libreria standard C++, e di conseguenza
di std::next_permutation nella #include <algoritm>...?
Alex

 }
Scusa ma questo non riesco proprio a farlo funzionare, né con il BC++
5.5 né con il DJGPP. Un errore evidente (o almeno io penso sia un
errore) è che l'operator() è dichiarato const ma poi al suo interno
modifica il valore del suo membro n.
Inoltre entrambi i compilatori non ne vogliono sapere di accettare
for_each() con i parametri da te riportati. Penso che il problema sia
nell'oggetto funzione stampa(). Nell'help del BC++ 5.5 c'è il seguente
esempio (un po' più complesso) che invece funziona:
//
// for_each.cpp 
//
#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>
using namespace std;
 // Function class that outputs its argument times x
 template <class Arg>
 class out_times_x :  private unary_function<Arg,void>
 {
   private:
      Arg multiplier;
   public:
      out_times_x(const Arg& x) : multiplier(x) { }
      void operator()(const Arg& x) 
         { cout << x * multiplier << " " << endl; }
 };
 int main()
 {
   int sequence[5] = {1,2,3,4,5};  
   // Set up a vector
   vector<int> v(sequence,sequence + 5);
 
   // Setup a function object 
   out_times_x<int> f2(2);
   for_each(v.begin(),v.end(),f2);   // Apply function
   return 0;
 }
Che ne pensi?
EMG

scusate ma non capisco proprio.
qualcuno mi farebbe un esempio?
Diciamo che ho 2 liste
list<miaclasse> Originale;
list<miaclasse> ConPermutazioni;
vorrei fare le permutazioni di Originale e metterle in ConPermutazioni
usando std::next_permutation
Come si fa??
Gerolamo

 Come si fa??
Devi usare la forma con il terzo parametro che rappresenta la funzione
che next_permutation() utilizzerà per confrontare due oggetti della tua
classe.
EMG

 Come si fa??
Supponendo che esista un operator< applicabile a
istanze di miaclasse:
    ConPermutazioni = Originale;
    ConPermutazioni.sort();
    do {
        // fai qualcosa su questa permutazione
    } while(std::next_permutation(
        ConPermutazioni.begin(),
        ConPermutazioni.end()));
Ecco dunque un completo esempio-giocattolo:
#include <list>
#include <algorithm>
#include <iostream>
struct miaclasse {
    char c;
    miaclasse(char c):c(c) {}
    bool operator<(const miaclasse& x) const { return c < x.c; }
    bool operator==(const miaclasse& x) const { return c == x.c; }
};
std::list<miaclasse> Originale;
std::list<miaclasse> ConPermutazioni;
void emetti(const std::list<miaclasse> & li)
{
    std::list<miaclasse>::const_iterator it = li.begin();
    while(it!=li.end()) {
        std::cout<<it->c;
        ++it;
    }
    if(std::equal(li.begin(), li.end(), Originale.begin()))
        std::cout << " ***";
    std::cout<<'\n';
}
int main()
{
    const char* p = "ciao";
    while(*p) Originale.push_back(*p++);
    ConPermutazioni = Originale;
    ConPermutazioni.sort();
    do {
        // fai qualcosa su questa permutazione
        emetti(ConPermutazioni);
    } while(std::next_permutation(
        ConPermutazioni.begin(),
        ConPermutazioni.end()));
    return 0;
}
e il suo output dovra` essere...:
acio
acoi
aico
aioc
aoci
aoic
caio
caoi
ciao ***
cioa
coai
coia
iaco
iaoc
icao
icoa
ioac
ioca
oaci
oaic
ocai
ocia
oiac
oica
Alex