Newsgroup: it.comp.lang.c++
Titolo: bubble sort

Volevo porvi una domanda, spero che non sia OT.
sto studiando il c++ su un libro, che mi propone il listato per
l'ordinamento (bubblesort) di un vettore di stringhe.
Il compilatore però mi segnali uso improprio del tipo void nel bubblesort,
ho ricontrollato più volte la sintassi, mi è abbastanza chiaro il modo in
cui ordina il vettore, ma non riesco a capire come mai il compilatore mi da
errore.
In teoria l'uso del tipo void dovrebbe consentirmi di riutilizzare tale
funzione per ordinare vettori di tipo differente da queeli del listato.
Spero che non mi siano sfuggiti errori di battiture, e se così non fosse mi
piacerebbe capire cosa c'è di sbagliato.
Grazie a tutti dell'attenzione.
ciao
#include <iostream.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
void get_words(char **pt_words, int words);
void list_words(char **pt_words, int words);
void words_to_lower_case (char **pt_words, int words);
void word_to_lower_case (char *pt);
void bubble_sort (void **pt_data, int elements, void (*order)(void**));
void order_strings(void **pt);
int main (int argc, char *argv[])
{
 if (argc!=2){
  cout<<"Utilizzo: sort<numero di parole>\n";
  exit(EXIT_FAILURE);
 }
 int words=atoi(argv[1]);
 if (words<1){
  cout<<"Non si possono inserire "<<words<<" parole\n";
  exit(EXIT_FAILURE);
 }
 char **pt_words=new char *[words];
 get_words(pt_words, words);
 cout<<"\nLista originaria:\n";
 list_words(pt_words, words);
 words_to_lower_case(pt_words, words);
 cout<<"\nLista delle parole in minuscolo:\n";
 list_words(pt_words, words);
 bubble_sort(pt_words, words, order_strings);
 cout<<"\nLista ordinata delle parole in minuscolo:\n";
 list_words(pt_words, words);
 return(EXIT_SUCCESS);
}
void get_words(char **pt_words, int words){
 char buffer[128];
 for (int entry=0; entry<words; ++entry){
  cin>>buffer;
  int length=1+strlen(buffer);
  pt_words[entry]=new char[length];
  memcpy(pt_words[entry], buffer, length);
 }
}
void list_words(char **pt_words, int words){
 cout<<"\n";
 for (int i=0; i<words; ++i)
  cout<<pt_words[i]<<"\n";
}
void words_to_lower_case (char **pt_words, int words){
 for (int i=0; i<words; ++i)
  word_to_lower_case(pt_words[i]);
}
void word_to_lower_case (char *pt){
 while(*pt){
  *pt=tolower(*pt);
  ++pt;
 }
}
void bubble_sort (void **pt_data, int elements, void (*order)(void**)){
 int n=elements-1;
 for (int i=0; i<n; ++i)
  for (int j=n; j>i; --j)
   order(pt_data+j-1);
}
void order_strings(void **pt){
 void *temp;
 if (strcmp((char*)pt[0], (char*)pt[1])>0){
  temp=pt[0];
  pt[0]=pt[1];
  pt[1]=temp;
 }
}

 
order( pt_data +j-1) e' un errore
Dato che il puntatore e' di tipo void, il compilatore non sa di quanto 
andare avanti se tu gli dici p = p +1
Per capirci meglio, se p fosse un pt a char, allora p=p+1 incrementerebbe 
di 1 byte; se fosse un puntatore a int, incrementerebbe di 4 byte (o 
meglio, di sizeof(int)).
Ma dato che e' void, di quant0 deve incrementare ?

    order(pt_data+j-1);
pt_data e` un puntatore a void*, e le operzioni su pt_data (come
pt_data+j-1) suppongono che pt_data punti a un array di void*.
Se la cosa funziona anche quando pt_data punta ad array di altri tipi,
e` pura fortuna.
        Mauro

 Butta via il libro prima che faccia troppi danni e prendine uno serio
A parte gli scherzi, ho comprato lo Stroustrup circa un mese fa (proprio
leggendo i post su questo ng), ma dai primi capitoli credo che per me sia un
po' troppo 'avanzato'.
Ho delle pessime basi di programmazione, e mi rendo conto di non aver
iniziato con il linguaggio più semplice (anzi!). Comunque ringrazio tutti,
proverò con Thinking in cpp, di Eckel. (Comprare il Lippman magari tra un
po'!)
Non per giustificare il testo che sto usando, ma il capitolo che riporta il
listato riguarda le tecniche di utilizzo dei puntatori, dopo aver introdotto
solo qualcosa sull'allocazione (e deallocazione) della memoria.
Cmq mi hai convinto!
Ciao

 po' troppo 'avanzato'.
Sullo Stroustrup ci sono opinioni contrastanti.
Secondo me non sono gli argomenti ad essere troppo avanzati, ma e`
Stroustrup che spiega da cani.  Non segue un ordine logico, gli esempi
sono contorti, alcuni argomenti sono ripetuti in varie parti del libro
senza mai essere approfonditi, ...
      Mauro