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

Per favore aiutatemi!!
Perchè questo programma funziona bene per n minore o uguale a 4, mentre per
valori maggiori l'array risulta "spostato", nel senso che l'ultimo valore
viene memorizzato fuori l'array.
Perchè poi fino a 4 funziona bene e poi no? Boh....
Io l'ho corretto, modificando la condizione che ho indicato nel commento.
Il problema è che questo codice è preso da un lucido del professore!!!
Quindi non credo abbia sbagliato lui(visto che usa gli stessi lucidi da
parecchi anni,e un eventuale errore sarebbe già stato corretto).
E allora secondo voi: perchè deve essere j<=n e non j<n?
#include<iostream>
#include<stdlib.h>
#include<personale.h>
void SelectionSort(int [],const int);
main()
{
int n=4;
int vett[n];
for(int i=0;i<n;i++)
cin>>vett[i];
stampa(vett,n);
SelectionSort(vett,n);
stampa(vett,n);
system("pause");
}
void SelectionSort(int a[],const int n)
{
  int i,j,piccolo,temp;
   for(i=0;i<n-1;i++)
      {
       piccolo=i;
       for(j=i+1;j<=n;j++) // qui secondo me dovrebbe essere j<n, perchè
altrimenti j esce "fuori" dall'array.
       if (a[j]<a[piccolo])
       piccolo=j;
       temp=a[piccolo];
       a[piccolo]=a[i];
       a[i]=temp;
      }
}
p.s.
vi assicuro che non è stato un errore di copiatura, perchè lo stesso lucido
che ha fatto vedere in facoltà, l'ho scaricato dal suo sito e risulta lo
stesso errore, se di errore si tratta ovviamente(questo me lo direte voi),
non ho la presunzione di correggere un docente(Il corso è Fondamenti I di
ingegneria).

 int vett[n];
Come riesci a compilare questo?

 ingegneria).
Non ci vedo niente di male.
--
Bye,
  Mirko



E' una feature del gcc.
--
Bye,
  Mirko

> E' una feature del gcc.
E' vero.
Ho guardato male il mio borland,
ho telnettato sul linux ed ho anche compilato:
#include <iostream.h>
main
{
int y;
cin>>y;
int vett[y];
}
in questo caso, y non č noto a tempo di compilazione.
vuoi dire che cio' viene tradotto con :
main
{
int y;
cin>>y;
int *vett;
vett=new int[y];
delete[] vett;
}
...marobedamatti.
non si finisce mai di imparare.

 }
Non esattamente. Il primo usa alloca() per allocare spazio sullo stack,
il secondo __builtin_vec_new() che non so esattamente cosa faccia.
(senza ottimizzazioni)
--
Bye,
  Mirko

 ingegneria).
Tu forse no. E forse fai bene. Ma io invece mi permetto di correggerlo. E
persino di giudicarlo (insieme a chi ti ha preceduto come studente). Soprattutto
perche' dici che e' codice che esiste da tempo. Potrei passargliela se lo avesse
scritto al volo durante la lezione (se si corregge la lezione successiva).
Ecco un esempio migliore (potrebbero esserci degli errori dato che lo scrivo
direttamente in Outlook):
// file SelectioSort.h
#ifndef MY_SELECTION_SORT
#define MY_SELECTION_SORT
#include<algorithm>
namespace My {
template <class ForwardIt>
    void SelectionSort( ForwardIt begin, ForwardIt end )
    {
        for ( ; begin != end; ++begin ) {
            ForwardIt litle=begin;
            for ( ForwardIt it=begin; ++it!=end; )
                if ( *it < *litle )
                    litle=it;
            if ( begin != litle )
                std::swap( *litle, *begin );
        }
    }
} // ends namespace My
#endif // MY_SELECTION_SORT
// file Test.cpp
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
#include "InsertionSort.hpp"
int main()
{
    std::vector<int> vett;
    std::cout << "Inserire degli interi separati da spazi.\n"
              << "Terminare con un carattere (esempio: '4 2 7 5 8.' ): ";
    std::copy( std::istream_iterator<int>(std::cin),
               std::istream_iterator<int>(),
               std::back_inserter(vett) );
    // commentata dato che non l'ho
    // va scritta
    // stampa(&
vett.at
[0],vett.size());
    My::SelectionSort( vett.begin(), vett.end() );
    // commentata dato che non l'ho
    // va scritta
    // stampa(&
vett.at
[0],vett.size());
    // commentata dato che non e' standard
    // andrebbe scritta!
    // system("pause");
}
--
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

 wrote in message
news:upueha...@VOBIS500MHZ.i-did-not-set--mail-host-address--so-shoot-me...

Questo non significa che debba essere usata quando si spiega il C++. Nel C++
quella feature non esiste. Se le features specifiche di un compilatore fossero
valide potrei anche scrivere:
#include <iostream>
usign namespace std;
char s[]={ 'c', 'i', 'a', 'o' };
int main() {
    char *base=s;
    for ( int i=0; i<4; i++ )
        cout << *(char __based( base )*)i;
    cout << endl;
}
e dire che e' C++. Ma non lo e'.


> Questo non significa che debba essere usata quando si spiega il C++.
Meno male!
Avevo paura a dire, ma ora lo dico:
ma non vi sembra diseducativo per chi deve imparare?
e per chi ha gia imparato:
che vantaggi comporta?

 wrote in message
news:kHDB6.3139$lu5....@news1.tin.it...

Cercati i messaggi passati circa un mesetto (o forse anche due fa) e vedrai che
mega threads (o mini flames) ci sono state sull'università, i suoi prof e altre
cosette correlate!


Purtroppo anche se questo codice non è scritto seguendo lo standard c++, io
sono costretto a continuare ad usare questa sintassi, e a seguire il mio
prof.(che probabilmente è poco aggiornato allo standard), altrimenti questo
mi
boccia all'esame!!!.
E l'università che mi sta insegnando a programmare in questo modo,
purtroppo!!!
Per quanto riguarda il parametro passato per valore e dichiarato costante,
concordo pienamente, anche per me è un'assurdità.
Ma probabilmente il prof. vuole che una funzione che non modifichi il numero
degli elementi di un vettore, abbia la dimensione dichiarata costante, per
avere l'immediatezza del fatto che non modifica la dimensione stessa.
Il compilatore che uso è dev c++ e compila senza problemi il codice così
come l'ho postato(è il compilatore adottato dal prof., che dovrò usare anche
all'esame)
Ciao...e grazie dei preziosi suggerimenti...
...che però non potrò usare almeno fino a giugno(e se le cose vanno bene!!!)

 Questa poi non fa parte neppure dello standard!
Però fa parte della libreria standard del C e quindi è utilizzabile
anche in C++ ponendo l'opportuno include (cstdlib). Ovviamente, anche
essendo standard la funzione, non lo è il parametro ad essa passato e
quindi l'effetto della chiamata è system-dependent.
EMG

 wrote in message
news:3AD8A31B...@flashnet.it...

Infatti mi riferivo a pause piu' che a system.
Ci vuole molto a fare qualche cosa del genere:
// esempio: header "hitkey.hpp"
#ifndef _HITKEY_HPP_D
#define _HITKEY_HPP_D
void hitKey();
#endif
// esempio: implementazione
#include "hitKey.h"
/* Warning: this code is platform dependent */
/* In case of porting rewrite the hitKey
implementation from scratch */
#include <conio.h>
void hitKey()
{
    int c=_getch();
    if ( c==0 || c==0xE0 )
        _getch();


 ha scritto nel messaggio
news:4RxB6.3581$s93.2...@news.infostrada.it...



... snip
Il codice non e' sbagliato, ma e' veramente pedestre. Valido ovviamente per
motivi didattici, ma in una vera implementazione e' inutile riscrivere codice
esistente. Pertanto:
// file SelectioSort.h
#ifndef MY_SELECTION_SORT
#define MY_SELECTION_SORT
#include<algorithm>
namespace My {
template <class ForwardIt>
    void SelectionSort( ForwardIt begin, ForwardIt end )
    {
        for ( ; begin != end; ++begin ) {
            ForwardIt litle=std::min_element(begin,end);
            if ( begin != litle )
                std::swap( *litle, *begin );
        }
    }
} // ends namespace My
#endif // MY_SELECTION_SORT


 quella feature non esiste.
Forse il professore di Max è a conoscenza del nuovo Standard per il
C....
Saluti   Manlio Perillo