Newsgroup: it.comp.lang.c++
Titolo: Gli iteratori servono?


Ora capisco tutto. In particolare il perche' del fatto che lo stack e' in
pratica un deque (se non sbaglio) camuffato. Del resto sul Lippaman dice che
lo stack e' un adattatore di contenitore, solo che non spiega praticamente
cosa significa. A parte questi due, quali altri container/template ci sono
nella libreria standard del C++?
Stefano

 difficili.
Probabilmente hai solo bisogno di un testo di base chiaro e completo;
visto che tutti consigliano TIC, ricordiamo che c'e' anche, a
disposizione gratuitamente sul web, l'ottimo C++ annotations:
http://www.icce.rug.nl/docs/cplusplus/cplusplus.html
 .
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it
The instructions said to use Windows 98 or better - so I installed FreeBSD.


Il testo chiaro credo di averlo (il Lippman). Solo che nel punto in cui
accenna i priority_queue non spiega quasi per niente (e senza esempi di
codice) come si fa a stabilire la priorita'. Il mio problema piu' grande,
poi, e' che non conosco per niente l'inglese e tutti i tutorial e i
documenti in inglese (come Thinking C++) sono per me inaccessibili.
Comunque grazie per la risposta.
Posso rubarti solo un paio di minuti e chiederti se puoi inviarmi un esempio
di codice per stabilire una priorita' degli elementi in una priority_queue?
Stefano

 il VC++.
Gli iterator sono disponibili per TUTTI i container. Il problema e' che stack,
queue etc. non sono dei container. Sono dei container adaptor. Ovvero sono dei
template che prendono un container come parametro e lo usano come supporto alla
base delle loro operazioni. Ma non sono dei container loro stessi.
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

Creando un oggetto di tipo Stack o Queue, come si fa (se e' possibile) a
visualizzarne gli elementi intermedi? Magari con l'utilizzo degli iteratori?
E poi come si fa a stabilire la priorita' tra gli elementi in una
priority_queue?
Scusatemi se le mie sono domande elementari, ma purtroppo sono un newbie, e
cose che a voi sembreranno estremamente semplici, per me sono enormemente
difficili.
Stefano

 ma non spiega come, pero'.
La definizione e':
namespace std {
  template<class T, class Container = vector<T>,
           class Compare = less<typename Container::value_type> >
  class priority_queue {
  ...
quindi puoi specificare tu un altro operatore relazionale al posto di
less, per realizzare il tipo di ordinamento che ritieni piu'
opportuno.  Facciamo un esempio: inizializziamo tre priority_queues
dallo stesso insieme di dati.  Diamo come criterio di ordinamento alla
prima coda quello di default (less); alla seconda il contrario
(greater); ed alla terza un criterio user-defined che e' "prima i
numeri dispari e poi quelli pari".  Ricorda che la stampa e' dal top
della coda in giu', quindi gli elementi con priorita' piu' alta escono
per primi.  Guarda:
MLO@pcdf0 6 $ cat foo.cxx
#include <queue>
#include <functional>
#include <iostream>
struct pardis {
  bool operator () (const int i1, const int i2) const {
    if (i1 % 2 == i2 % 2) return i1 < i2; else return i1 % 2;
  }
};
int main() {
  int data[] = { 1, 17, 69, 42, 666, 314 };
  const size_t nData = sizeof(data) / sizeof( data[0] );
  std::priority_queue<int> pq1(data, data+nData);
  std::priority_queue<int, std::vector<int>, std::greater<int> >
    pq2(data, data+nData);
  std::priority_queue<int, std::vector<int>, pardis> pq3(data, data+nData);
  while (pq1.size()) { std::cout << pq1.top() << ' ';  pq1.pop(); }
  std::cout << std::endl;
  while (pq2.size()) { std::cout << pq2.top() << ' ';  pq2.pop(); }
  std::cout << std::endl;
  while (pq3.size()) { std::cout << pq3.top() << ' ';  pq3.pop(); }
  std::cout << std::endl;
  return 0;
}
MLO@pcdf0 6 $ KCC -o foo foo.cxx && ./foo
666 314 69 42 17 1 
1 17 42 69 314 666 
666 314 42 69 17 1 
MLO@pcdf0 7 $



Vediamo se ho capito. Per definire la priorita' degli elementi in una
priority_queue bisogna utilizzare la "formula":
priority_queue<tipo, contenitore, definizione_della_priorita'> nome_oggetto;
dove:
tipo e' il tipo del queue
contenitore e' il contenitore in cui memorizzare il priority_queue (ad es.
vector<tipo>)
definizione_della_priorita' e' il modo in cui ordinare gli elementi e puo'
essere una funzione gia' creata (tipo greater) oppure una creata
dall'utente.
In questo modo ogni nuovo elemento inserito seguira' la priorita' definita
in "definizione_della_priorita'".
Un'ultima domanda. Il modo in cui definire la priorita' puo' essere fatto
solo all'inizio nella definizione dell'oggetto priority_queue, o si puo'
anche definirne una nuova all'atto dell'inserimento di nuovi elementi nella
priority_queue?
Grazie dell'aiuto
Stefano