4° Esercizio in c++: Giro a cavallo. Dove è il bug?

[NK]

parte che non ho capito come fare

non so quale debugger usi

non riesco a capire che cosa cambia al 6°-7°

cambia lo stato del processo! cioè i valori delle variabili e quello che ritorna rnd...

[daemon_nio]

A parte la funzione rnd, che dovresti testare a parte e una volta verificata la correttezza chiudere la questione, ci spieghi qualcosa in più?

Che significa il programma deve simulare il movimento del cavallo e fare quante più mosse possibili?
Hai una scacchiera vuota e il cavallo in una posizione iniziale?
In tal caso le mosse sono infinite, vuoi farne fare le prime N a caso?
Come hai implementato la scacchiera?
E come hai indicato i movimenti del cavallo?

Io vedo quasi tutto il codice nel costruttore e nel metodo sposta... non riesco a capire un granché.
Se aggiungi qualche commento in più forse possiamo aiutarti.
E' più difficile capire cosa fa un codice che pensare una soluzione ad un problema e riscrivere il codice 

Inoltre mi sembra strana la tua progettazione ad oggetti... in fondo la sola classe Cavallo non è una buona soluzione.
Non ho capito cosa deve fare il programma, ma in una progettazione a oggetti è bene suddivere il problema in diversi oggetti.

P.S.
Ho modificato il metodo random come indicato nell'ultimo post (ma non ho neanche verificato la correttezza).
Inoltre le classi devono chiamarsi sempre con lettera maiuscola, quindi ho modificato anche questo.

Posto nuovamente il codice.
Ogni modifica che fai ti consiglio di aggiornare il codice così non si perdono le modifiche.

Ciao

Codice: Seleziona tutto

#include "./random.h"
#include <iostream>

using namespace std;

class Cavallo{
public:
    Cavallo();
    void displayMessage(int count01);
    void sposta();
    void gesioneErrore(int errore);
    int maxSpostamento(int tempPosColonna, int tempPosRiga);
    int generaMovimento();
    void dbgMossa(int mossa);

    ~Cavallo();
private:
//  variabili  di prova
    int dbg01;
    int dbg02;
//________________________

    int maxRangeColonna;
    int maxRangeRiga;
    //int mossa;
    int posRiga;
    int posColonna;
    int *arrayMosseCasuali;
    int *arrayMemorizzaScelte;
    int *arrayOrizontale;
    int *arrayVerticale;
    int **arrayMovimento;

};

int main(){
    Cavallo ilMioCavallo;
    ilMioCavallo.sposta();
    ilMioCavallo.~Cavallo();
    return 0;
}

Cavallo::~Cavallo(){

    delete [] arrayMemorizzaScelte;
    delete [] arrayMosseCasuali;
    delete [] arrayOrizontale;
    delete [] arrayVerticale;


    for (int i1 = 0; i1 < maxRangeColonna; i1++){
        delete []arrayMovimento[i1];
    }
    delete [] arrayMovimento;
}

Cavallo::Cavallo(){
    // Variabili di prova
    dbg01 = 0;
    int numeroMosse = 64;
//_______________________

    maxRangeColonna = 8;
    maxRangeRiga = 8;
    // possibile errore
    int arraySize = 64;
//__________________
    posRiga = 4;
    posColonna = 3;

    // crea lo spazio per la creazione degli array
    arrayMosseCasuali = new int [numeroMosse];
    arrayOrizontale = new int [arraySize];
    arrayVerticale = new int [arraySize];
    // NON EFFICIENTE
    arrayMemorizzaScelte = new int [arraySize];

    // azzera il contatore delle mosse già estratte
    for ( int i1 = 0; i1 < numeroMosse; i1++)
        arrayMosseCasuali[i1] = 0;

    // crea arrayBidimensionale
    arrayMovimento = new int *[maxRangeColonna];
    for (int i1 = 0; i1 < maxRangeColonna; i1++){
        arrayMovimento[i1] = new int [maxRangeRiga];
    }

    //inizializza arrayBidimensionale
    for (int i1 = 0; i1 < maxRangeColonna; i1++){
        for ( int i2 = 0; i2 < maxRangeRiga; i2++){
            arrayMovimento[i1][i2] = 0;
        }
    }

    // posizione il cursone nella tabella
    arrayMovimento[posColonna][posRiga] = 0;

    // poszioni possibili
    arrayOrizontale[0] = 2;
    arrayOrizontale[1] = 1;
    arrayOrizontale[2] = -1;
    arrayOrizontale[3] = -2;
    arrayOrizontale[4] = -2;
    arrayOrizontale[5] = -1;
    arrayOrizontale[6] = 1;
    arrayOrizontale[7] = 2;

    arrayVerticale[0] = -1;
    arrayVerticale[1] = -2;
    arrayVerticale[2] = -2;
    arrayVerticale[3] = -1;
    arrayVerticale[4] = 1;
    arrayVerticale[5] = 2;
    arrayVerticale[6] = 2;
    arrayVerticale[7] = 1;
}

void Cavallo::displayMessage(int count01){
    // mette a video i movimenti
    bool dbgSentinell01 = true;
    cout << "Scelte fatte ";
    for ( int i1 = 0; i1 < count01; i1++){
        cout << arrayMemorizzaScelte[i1] << " ";
    }

    cout << "\nNumero mosse " << count01 << endl;
    cout << endl;

    // MOMENTANEAMENTE ABILITATO
    if ( dbgSentinell01 == true ){
        for(int i1 = 0;i1 < maxRangeColonna;i1++){
            for(int i2 = 0;i2 < maxRangeRiga;i2++){
                cout << arrayMovimento[i1][i2];
            }
        cout << endl;
        }
    }
}

void Cavallo::sposta(){
    int tempPosColonna = 0;
    int tempPosRiga = 0;
    int mossa = 0;

    int dbgVal01 = 0;

    for (int count01 = 0; mossa != 19; count01++){
        cout << "Inserisci un altra mossa ";
        //cin >> mossa;
        //dbgMossa();
        if ( count01 <= 64)
            mossa = generaMovimento();
        else
            mossa = 19;
        // prepara il a muovere il cursore
        tempPosColonna = posColonna;
        tempPosRiga = posRiga;
        tempPosColonna += arrayVerticale[mossa];
        tempPosRiga += arrayOrizontale[mossa];

        // se i movimenti sono corretti sposa il cursore
        if ( count01 == 5 )
            dbgVal01 = arrayMovimento[posColonna][posRiga];

        if ( maxSpostamento( tempPosColonna, tempPosRiga ) == 0){
           if (arrayMovimento[tempPosColonna][tempPosRiga] == 0 ){
                posColonna += arrayVerticale[mossa];
                posRiga += arrayOrizontale[mossa];

            // memoria e conta il numero delle mosse
                arrayMovimento[posColonna][posRiga] = count01;

            // memorizza le scelte fatte
                arrayMemorizzaScelte[count01] = mossa;

                tempPosColonna = 0;
                tempPosRiga = 0;
                cout << endl;
                        displayMessage(count01);
            }else{
                count01--;
                //mossa = generaMovimento();
            }
        }else{
            count01--;
            tempPosColonna = tempPosRiga = 0;
            gesioneErrore(1);
            //mossa = generaMovimento();
                    displayMessage(count01);
        }
        //displayMessage(count01);
    }
}

int Cavallo::generaMovimento(){
    int dbgSentinel001 = false;
    int dbgTemp001 = 0;
    int mossaCasuale = 0;
    int uscita = 0;

    mossaCasuale = rnd(0,7);
    do{
        if ( arrayMosseCasuali[mossaCasuale] == 0 ){
            arrayMosseCasuali[mossaCasuale] = 1;
            uscita = 1;
            break;
        }
        if ( arrayMosseCasuali[mossaCasuale] == 1 ){
            mossaCasuale = rnd(0,7);
            uscita = 0;
        }
    }while ( uscita == 0 );

    return mossaCasuale;
}

void Cavallo::gesioneErrore(int errore){
    switch (errore){
    case 1:
        cout << "Movimento errato\n";
        break;
    case 2:
        cout << "Non ci sono più mosse disponibili\n)";
        break;
    default:
        cout << "Errore imprevisto " << errore << endl;
        break;
    }
}

int Cavallo::maxSpostamento( int tempPosColonna, int tempPosRiga ){
    if ( tempPosColonna >= 0 and tempPosRiga >= 0
      and tempPosColonna <= maxRangeColonna and tempPosRiga <= maxRangeRiga)
        return 0;
    else
        return 1;
}

void Cavallo::dbgMossa(int mossa){
    switch (dbg01){
        case 0:
            mossa = 5;
            break;
        case 1:
            mossa = 1;
            break;
        case 2:
            mossa = 1;
            break;
        case 3:
            mossa = 7;
            //dbg02 = 200;
            break;
        case 4:
            mossa = 2;
            break;
        case 5:
            mossa = 8;
            break;
        case 6:
            mossa = 19;
            break;
    }
    dbg01++;
}

Codice: Seleziona tutto

#include <ctime>
using std::time;

#include <cstdlib>
using std::rand;
using std::srand;

int rnd(int inizio = 1, int fine = 5000){
    int val1 = 0;
    static bool s1 = true;
    if (s1 == true){
        srand(time(0));
        s1 = false;
    }
    val1 = inizio + (rand()%(fine-inizio))
;
    return val1;
}

[NK]

concordo pienamente con te daemon_nio
ho notato in rnd che la riga con il calcolo è errata, quella giusta è:

Codice: Seleziona tutto

val1 = inizio + (rand()%(fine-inizio + 1));

ci deve essere +1 altrimenti non genera mai l'estremo superiore (cioè fine).

[tomallevi]

ma cosa si intende per spostamento di un cavallo in una scacchiera?!?!?!?
a parte il codice che quello viene per ultimo, la progettazione del programma è fondamentale!!! come daemon_nio ha chiesto prima, come hai creato la scacchiera?!?!? e poi il cavallo si muove a L, giusto? quindi basta memorizzare in una variabile questa mossa e poi ribaltarla in tutte le direzioni possibili per fare tutte le mosse possibili da un punto. essendo una scacchiera quadrata 8x8 (spero di non sbagliarmi!! ) basta vedere se l'arrivo appartiene alla scacchiera e il gioco è fatto. prendi il punto di arrivo e lo setti come quello di partenza. e poi rinizia tutto!!! cmq spiegati meglio, deve attraversare la scacchiera?

[KubuntuChancellor]

Ciao a tutti,

@NK

non so quale debugger usi.

codeblocks + gnu gcc compiler

@daemon_nio
In anzi tutto grazie per il vostro interesse, come detto in precedenza ogni consiglio è il ben venuto.
Mi scuso se il mio modo di "programmare" a vuoi esperti può apparire osceno ma essendo un autodidatta armato di un libro, codeblock e tanta voglia di imparare e il massimo che fino a ora sono riuscito a dare.

A parte la funzione rnd, che dovresti testare a parte e una volta verificata la correttezza chiudere la questione, ci spieghi qualcosa in più?

Semplice, l'unico scopo di questa funzione è generare numeri a caso, è stato creata per non dover ogni volta inserire a mano dati come in questo caso:

for (int i1 = 1; i > inserisciDati;
}

quindi ho pensato che fosse più comodo costruire routine apposta per evitare di doverli scrivere a mano
for (int i1 = 1; i <= 100; i1++){
inserisciDati = rnd();
}

Che significa il programma deve simulare il movimento del cavallo e fare quante più mosse possibili?

Devo simulare il movimento a L di un cavallo nel gioco degli scacchi. Il matematico Eulero a dimostrato (spero) che è possibile muovere un cavallo all'interno di una scacchiera toccando una sola volta ciascun dei 64 quadrati.

Hai una scacchiera vuota e il cavallo in una posizione iniziale?

Si la scacchiera è vuota, attualmente il cavallo si trova nella posizione centrale. Più avanti la sposterò in un altra posizione..

In tal caso le mosse sono infinite, vuoi farne fare le prime N a caso?

In teoria se riuscissi a creare un algoritmo decente dovrei utilizzare SOLO 64 mosse, ma attualemte il mio programma si blocca al 6°-7° movimento quindi....... un disastro.

Come hai implementato la scacchiera?

Per ora ho creato solo un arraybidimensionale da 8 x 8 posizioni.

E come hai indicato i movimenti del cavallo?

Attraverso questi array, ho ricreato tutte le possibili posizioni

Codice: Seleziona tutto

    arrayOrizontale[0] = 2;
    arrayOrizontale[1] = 1;
    arrayOrizontale[2] = -1;
    arrayOrizontale[3] = -2;
    arrayOrizontale[4] = -2;
    arrayOrizontale[5] = -1;
    arrayOrizontale[6] = 1;
    arrayOrizontale[7] = 2;

    arrayVerticale[0] = -1;
    arrayVerticale[1] = -2;
    arrayVerticale[2] = -2;
    arrayVerticale[3] = -1;
    arrayVerticale[4] = 1;
    arrayVerticale[5] = 2;
    arrayVerticale[6] = 2;
    arrayVerticale[7] = 1;

e tramite queste istruzione creo la nuova posizione

Codice: Seleziona tutto

         posColonna += arrayVerticale[mossa];
         posRiga += arrayOrizontale[mossa];

            // memoria e conta il numero delle mosse
         arrayMovimento[posColonna][posRiga] = count01;

Inoltre mi sembra strana la tua progettazione ad oggetti... in fondo la sola classe Cavallo non è una buona soluzione.

Ho usato una classe solo per semplicità, se hai una idea migliore ben venga.

Non ho capito cosa deve fare il programma, ma in una progettazione a oggetti è bene suddivere il problema in diversi oggetti.

Veramente ero convinto di averlo fatto, ma vedo che non è cosi

Posto nuovamente il codice.
Ogni modifica che fai ti consiglio di aggiornare il codice così non si perdono le modifiche.

Vuoi che rimuova il file precedente e lo sostituisca con quello tuo nuovo?

Spero di avervi risposto alle vostre domande
Ciao
Lele

[tomallevi]

ecco!!!
ora si spiega: si tratta di un problema di grafi (almeno su google si trova sotto questa forma), dove i nodi sono le caselle e le "frecce non orientate"(non so come si chiamano ) sono le possibili mosse che un cavallo è in grado di fare. passo a spiegare.
ho un cavallo in una certa casella, mettiamo caso in B5. il nodo B5 sarà collegato ai nodi A3, C3, D4, D6 etc... si tratta di scoprire il percorso più breve ci dovrà essere una formula o un algoritmo che assolutamente io personalmente ignoro da morire
ecco il sito che potrebbe darti una mano http://www.webalice.it/vdepetr/t18/Text18.htm

[KubuntuChancellor]

Ciao Tomallevi,

ti ringrazio per il tuo interesse, ma onestamente non mi è stato utile perché è troppo difficile da capire, almeno per me.

Tutta via esiste un metodo più semplice per ottenere la stessa cosa è difficile da spiegare ci vorrebbe un sacco di tempo.

Anche se non riuscissi a completare il giro completo poco importa..... a me serve capire cosa non funziona nel programma che ho fatto e SOLO in un SECONDO lo sviluppo di un algoritmo che tenti di risolvere il problema.

Qualcuno sa darmi delle risposte esaudenti al mia domanda?

"Re: 4° Esercizio in c++: Giro a cavallo. Dove è il bug?"

Grazie
Lele

[daemon_nio]

Ho allegato un archivio zip con del codice (lo trovi in fondo alla pagina).
Non sono riuscito a scrivere tutto in un solo file (ho utilizzato diverse classi) quindi per comodità ho inserito tutto in un archivio zip.

Istruzioni:
Estrarre l'archivio;
Aprire un terminale;
Spostarsi all'interno dell'archivio;
Compilare ed eseguire con i seguenti comandi:

Codice: Seleziona tutto

g++ Cavallo.cpp ListaPezzi.cpp ListaSpostamenti.cpp main.cpp Pezzo.cpp Random.cpp Scacchiera.cpp Spostamento.cpp
./a.out

Inizio con il dire che sono un po' arrugginito con il C++ (da un po' uso solo Java) quindi qualche cosa non è implementata al massmo (costruttori e funzioni virtuali sono molto da migliorare).
Non ho usato allocazione dinamica per liste perché mi scocciavo.
Non ho risolto il problema degli scacchi in maniera totale, ma bisognerebbe pensare ad una struttura diversa a causa della complessità degli scacchi (pedoni si muovono in diagonale per mangiare e diritti se non devono mangiare, alfieri, torri e regina non possono attraversare pezzi spostandosi, re e torre possono arroccare, se in una casella c'è un pezzo di un altro colore è possibile mangiare mentre se il pezzo è dello stesso colore non è possibile andare in nessun caso in quella casella... e altre diavolerie degli scacchi).

Tutto sommato possono considerare risolto in pieno il tuo esercizio.

La struttura è stata pensata molto ad oggetti, ne esistono un bel po'.
La scacchiera contiene diversi pezzi.
Un pezzo è la base di una gerarchia per i cavalli ma anche per gli altri pezzi. Con questa struttura riesci a far muovere un altro pezzo (ad es. alfiere) sulla scacchiera senza grandi difficoltà (lo crei in un paio di minuti).
Ogni pezzo può effettuare dei particolare spostamenti.

E così via.

Leggendo la tua ultima spiegazione ho visto del teorema di Eulero. Non lo conoscevo... è interessante ma non lo risolverai sicuramente così.
Mi viene il dubbio se c'è una sola sequenza che sposta il cavallo nelle 64 caselle oppure tutte le sequenze che non portano il cavallo due volte sullo stesso punto sono una soluzione al teorema.
Nel primo caso non risolverai mai il problema se lo non lo studi più a fondo.
Nel secondo caso puoi provare a modificare la riga di codice nel main (se ricordo bene) che invece di spostare un cavallo in una posizione ne aggiunge un altro senza rimuovore il precedente. Non è complicato. Così il cavallo non potrà mai tornare indietro e occupare una casella in cui ci è già stato.

Ci sono un bel cose da controllare, poiché ho ampliato il problema pensando anche a pezzi futuri e spostamenti su scacchiere con più pezzi ma mai utilizzato quei metodi, potrebbero esserci dei bug oppure metodi inimplementati.



Per quanto riguarda il tuo codice ho notato un errore, utilizzi un array di 64 elementi in cui memorizzi le mosse da effettuare (se non erro si chiama mossaCasuale) e ci accedi anziché in maniera sequenziale (infatti dovresti memorizzare la prima, la seconda, la terza, ..., l'ennesima mossa) ci accedi in maniera casuale. Ossia scegli una mossa a caso, la quinta e la metti in posizione cinque. Ti fermi alla mossa sei perché dopo le prime sei mosse casuali hai riempito i primi sei elementi e tutte le mosse a caso già le hai usate (ma non c'è nessun vincolo che non puoi usare due volte la stessa mossa per spostare il cavallo).


Spero di essere stato chiaro nella spiegazione o che almeno il codice sia abbastanza intuitivo.

Se nel codice che ho inserito non capisci qualcosa chiedi pure.

Ciao e buono studio.


OFF TOPICS
Immagino quella di programmare sia una passione. Se sei giovane e stai studiando come farlo per lavoro, sei ancora in tempo per cambiare idea e fare il calciatore... la vita del programmatore fa schifo! (Scherzo! ma mica tanto :P).
Ma se sei proprio cocciuto e vuoi fare il programmatore ti consiglio di darci dentro con il C++, capire bene le classi, ereditarietà, polimorfismo (forse perdere un po' meno tempo su puntatori) e poi passare, non avere fretta però, al Java e dare uno sguardo anche al mondo del web (html e css).
Non c'è nulla di più richiesto dalle aziende.

Ah dimenticavo, non usare guide su internet come C++ in dieci minuti o cose del genere (sono tutte fregature).
Se puoi fai una spesa una volta per tutte compra un manuale di quelli con almeno 1000 pagine su un linguaggio e studialo bene. Sicuramente non sono soldi buttati.

Ciao.

[KubuntuChancellor]

Ciao daemon_nio,
ci vorrà qualche giorno per capire tutto il tuo lavoro, quindi ti farò sapere al più presto. Grazie mille per il tuo impegno. Tutta via OFFTOPIC meritava una risposta immediata  (good)

Immagino quella di programmare sia una passione.

Esattamente, amo i computer da ormai 11 anni, spazio da Windows a Linux e tra poco anche nella programmazione.

Se sei giovane e stai studiando come farlo per lavoro, sei ancora in tempo per cambiare idea e fare il calciatore...

Si sono giovane ma non quanto pensi tu, diciamo che sono un po vecchio per iniziare a fare il calciatore... Ho 30 anni e fortunatamente ho un lavoro stabile che di questi tempi c'è da ritenersi un eletto del Signore, quindi non preoccuparti non voglio fare il programmatore di mestiere  (b2b)

ti consiglio di darci dentro con il C++, capire bene le classi, ereditarietà, polimorfismo

Sto facendo il possibile, ma tu che sei un programmatore sai quanto sia difficile e frustrante studiare il c++ completamente da solo, meno male che ci siete voi... altrimenti non saprei dove sbattere la testa.

poi passare, non avere fretta però, al Java

Perché passare al Java? Onestamente mi sembra un sistema MOLTO pesante. L'Ide Eclipse per esempio è 100 volte più bello di Codeblock (IMHO) però è un macigno da 110mb solo per accenderlo.... per me è un po eccessivo..... Posso capire Java in un cellulare ma giusto li, puoi darmi una tua opinione??

Ah dimenticavo, non usare guide su internet come C++ in dieci minuti o cose del genere (sono tutte fregature).
Se puoi fai una spesa una volta per tutte compra un manuale di quelli con almeno 1000 pagine su un linguaggio e studialo bene. Sicuramente non sono soldi buttati.

Si ho già scoperto la poca utilità di quelle agghiaccianti guide da 10 min, ho optato per un doppio volume da 800 pagine  "I Fondamenti del c++" dei fratelli Deitel una mazzata in testa ma mi sembra molto valido

Ciao Lele

[KubuntuChancellor]

Ciao daemon_nio,

Inizio con il dire che sono un po' arrugginito con il C++

Dalla a me la tua ruggine, io mi accontento..... la vendi al kg?


ho provato a guardare il tuo codice per essendo scritto bene va ampiamente al di fuori dalle mie competenze logiche e sintattiche.....

Di la verità che ti sei fatto prendere la mano......
Per il momento mi accontento di capire come far funzionare il mio, ma sicuramente avrò ancora bisogno perché onestamente devo ancora trovarlo il mio bug.

Comunque grazie per il programmino anche se per me è troppo difficile spero che venga utile a qualcun'altro.

Ciao
lele

[daemon_nio]

Perché passare al Java? Onestamente mi sembra un sistema MOLTO pesante. L'Ide Eclipse per esempio è 100 volte più bello di Codeblock (IMHO) però è un macigno da 110mb solo per accenderlo.... per me è un po eccessivo..... Posso capire Java in un cellulare ma giusto li, puoi darmi una tua opinione??

Non conosco Codeblock, ma eclipse è molto bello anche per programmare in C++.
Se scrivi programmi che non servono esclusivamente a te un IDE potente ti serve, acceleri i tempi di sviluppo in una maniera impensabile. Ma se sei all'inizio ti consiglio di programmare con gedit (o simile) e compilare con g++.
Ho scritto proprio con gedit quel codice.
Poi una volta che impari tutte le regole e gli errori comuni puoi pensare di sviluppare con un IDE.

Perché passare al Java? Bella domanda.

Secondo me prima dipende dal programma che si sta facendo. Alcune cose devono essere scritte in C altre in Java.

Ma ti elenco un po' di cose che potrebbero farti pensare di dare uno sguardo al Java:

• Portabilità: Un programma in C++ funziona sul tuo computer. Cambiando computer potrebbe non funzionare e non funzionerà sicuramente cambiando sistema operativo. Il Java è nato come primo scopo per sopperire a questo problema (Write once, run everywhere).
• Sicurezza: Un programma Java essendo eseguito in una Java Virtual Machine può essere considerato sicuro, la macchina virtuale si occupa di gestire delle restrizioni su un computer. Ad esempio non devi aver paura di scaricare un gioco java all'interno di un browser (applet) e giocarci perché non potrà mai fare danni al tuo computer.
• Le librerie standard di Java hanno già tante funzionalità, per accedere a file, rete, liste e vettori, interfacce grafiche ed altro. In genere con le librerie standard riesci a scrivere i tuoi programmi, quindi non necessiti di imparare chissà quanta roba in più.
• Il Java non ha prestazioni così basse come tutti dicono. E' abbastanza veloce tanto da vedere la nascita dei primi server Java. Quindi se un giorno vuoi creare un sito internet che oltre a visualizzare un paio di pagine faccia operazioni più particolari non devi imparare altri linguaggi di programmazione come PHP o ASP, puoi farlo con il Java.
• Il Java non è così diverso dal C++. La sintassi per il 90% è la stessa. Cambiano alcune regole ma soprattutto porta a semplificare le cose e non a complicarle.
• Il Java ha un'ottima eccezione delle eccezioni (eventuali errori del sistema). Il che consente di scrivere programmi puliti, senza errori, e ottimizzando l'uso delle risorse (e facile non lasciare risorse "aperte" inutilizzate).
• In Java è semplice scrivere programmi multithreating o sistemi distribuiti in rete.
• Il Java è molto giovane ma molto utilizzato e si sviluppa rapidamente. In genere un linguaggio di programmazione si rinnova in una decina di anni. Per il Java ogni anno e mezzo circa esce una nuova versione (retrocompatibile al 99% con le vecchie).
• Il Java è molto richiesto (lavorativamente parlando). L'ho indicato per ultimo perché per te è sicuramente il meno valido... per altri invece potrebbe venire al primo posto. :P

Spero di averti intrigato abbastanza e di aver dato una giusta idea senza aver esagerato... sai io sono un po' di parte.  :-[
Da quando programmo in Java mi è venuto quasi il piacere di programmare.

[daemon_nio]

Di la verità che ti sei fatto prendere la mano......

Forse è un po' vero.

Comunque ho provato a tentativo a correggere l'errore che ti ho indicato al post precedente.

Ecco il codice modificato:

Codice: Seleziona tutto

#include "./random.h"
#include <iostream>

using namespace std;

class Cavallo{
public:
    Cavallo();
    void displayMessage(int count01);
    void sposta();
    void gesioneErrore(int errore);
    int maxSpostamento(int tempPosColonna, int tempPosRiga);
    int generaMovimento();
    void dbgMossa(int mossa);

    ~Cavallo();
private:
//  variabili  di prova
    int dbg01;
    int dbg02;
//________________________

    int maxRangeColonna;
    int maxRangeRiga;
    //int mossa;
    int posRiga;
    int posColonna;
    int *arrayMosseCasuali;
    int *arrayMemorizzaScelte;
    int *arrayOrizontale;
    int *arrayVerticale;
    int **arrayMovimento;

};

int main(){
    Cavallo ilMioCavallo;
    ilMioCavallo.sposta();
    ilMioCavallo.~Cavallo();
    return 0;
}

Cavallo::~Cavallo(){

    delete [] arrayMemorizzaScelte;
    delete [] arrayMosseCasuali;
    delete [] arrayOrizontale;
    delete [] arrayVerticale;


    for (int i1 = 0; i1 < maxRangeColonna; i1++){
        delete []arrayMovimento[i1];
    }
    delete [] arrayMovimento;
}

Cavallo::Cavallo(){
    // Variabili di prova
    dbg01 = 0;
    int numeroMosse = 64;
//_______________________

    maxRangeColonna = 8;
    maxRangeRiga = 8;
    // possibile errore
    int arraySize = 64;
//__________________
    posRiga = 4;
    posColonna = 3;

    // crea lo spazio per la creazione degli array
    arrayMosseCasuali = new int [numeroMosse];
    arrayOrizontale = new int [arraySize];
    arrayVerticale = new int [arraySize];
    // NON EFFICIENTE
    arrayMemorizzaScelte = new int [arraySize];

    // azzera il contatore delle mosse già estratte
    for ( int i1 = 0; i1 < numeroMosse; i1++)
        arrayMosseCasuali[i1] = 0;

    // crea arrayBidimensionale
    arrayMovimento = new int *[maxRangeColonna];
    for (int i1 = 0; i1 < maxRangeColonna; i1++){
        arrayMovimento[i1] = new int [maxRangeRiga];
    }

    //inizializza arrayBidimensionale
    for (int i1 = 0; i1 < maxRangeColonna; i1++){
        for ( int i2 = 0; i2 < maxRangeRiga; i2++){
            arrayMovimento[i1][i2] = 0;
        }
    }

    // posizione il cursone nella tabella
    arrayMovimento[posColonna][posRiga] = 0;

    // poszioni possibili
    arrayOrizontale[0] = 2;
    arrayOrizontale[1] = 1;
    arrayOrizontale[2] = -1;
    arrayOrizontale[3] = -2;
    arrayOrizontale[4] = -2;
    arrayOrizontale[5] = -1;
    arrayOrizontale[6] = 1;
    arrayOrizontale[7] = 2;

    arrayVerticale[0] = -1;
    arrayVerticale[1] = -2;
    arrayVerticale[2] = -2;
    arrayVerticale[3] = -1;
    arrayVerticale[4] = 1;
    arrayVerticale[5] = 2;
    arrayVerticale[6] = 2;
    arrayVerticale[7] = 1;
}

void Cavallo::displayMessage(int count01){
    // mette a video i movimenti
    bool dbgSentinell01 = true;
    cout << "Scelte fatte ";
    for ( int i1 = 0; i1 < count01; i1++){
        cout << arrayMemorizzaScelte[i1] << " ";
    }

    cout << "\nNumero mosse " << count01 << endl;
    cout << endl;

    // MOMENTANEAMENTE ABILITATO
    if ( dbgSentinell01 == true ){
        for(int i1 = 0;i1 < maxRangeColonna;i1++){
            for(int i2 = 0;i2 < maxRangeRiga;i2++){
		if (arrayMovimento[i1][i2]<10) {
                    cout << "0" << arrayMovimento[i1][i2] << "  ";
		} else {
		    cout << arrayMovimento[i1][i2] << "  ";
		}
            }
        cout << endl;
        }
    }
}

void Cavallo::sposta(){
    int tempPosColonna = 0;
    int tempPosRiga = 0;
    int mossa = 0;

    int dbgVal01 = 0;

    for (int count01 = 0; mossa != 19; count01++){
        cout << "Inserisci un altra mossa ";
        //cin >> mossa;
        //dbgMossa();
        if ( count01 <= 64)
            mossa = generaMovimento();
        else
            mossa = 19;
        // prepara il a muovere il cursore
        tempPosColonna = posColonna;
        tempPosRiga = posRiga;
        tempPosColonna += arrayVerticale[mossa];
        tempPosRiga += arrayOrizontale[mossa];

        // se i movimenti sono corretti sposta il cursore
        if ( count01 == 5 )
            dbgVal01 = arrayMovimento[posColonna][posRiga];

        if ( maxSpostamento( tempPosColonna, tempPosRiga ) == 0){
           if (arrayMovimento[tempPosColonna][tempPosRiga] == 0 ){
                posColonna += arrayVerticale[mossa];
                posRiga += arrayOrizontale[mossa];

            // memoria e conta il numero delle mosse
                arrayMovimento[posColonna][posRiga] = count01;

            // memorizza le scelte fatte
                arrayMemorizzaScelte[count01] = mossa;

                tempPosColonna = 0;
                tempPosRiga = 0;
                cout << endl;
                        displayMessage(count01);
            }else{
                count01--;
                //mossa = generaMovimento();
            }
        }else{
            count01--;
            tempPosColonna = tempPosRiga = 0;
            gesioneErrore(1);
            //mossa = generaMovimento();
                    displayMessage(count01);
        }
        //displayMessage(count01);
    }
}

int Cavallo::generaMovimento(){
    int dbgSentinel001 = false;
    int dbgTemp001 = 0;
    int mossaCasuale = 0;
    int uscita = 0;

    mossaCasuale = rnd(0,7);
    /*perche' vai sempre sugli stessi indici? non devi riempire tutti e sessantaquattro elementi del vettore?
    do{
        if ( arrayMosseCasuali[mossaCasuale] == 0 ){
            arrayMosseCasuali[mossaCasuale] = 1;
            uscita = 1;
            break;
        }
        if ( arrayMosseCasuali[mossaCasuale] == 1 ){
            mossaCasuale = rnd(0,7);
            uscita = 0;
        }
    }while ( uscita == 0 );*/
    for (int i=0; i<64; i++) {
	mossaCasuale = rnd(0,7);
	arrayMosseCasuali[mossaCasuale] = 1;
    }

    return mossaCasuale;
}

void Cavallo::gesioneErrore(int errore){
    switch (errore){
    case 1:
        cout << "Movimento errato\n";
        break;
    case 2:
        cout << "Non ci sono più mosse disponibili\n)";
        break;
    default:
        cout << "Errore imprevisto " << errore << endl;
        break;
    }
}

int Cavallo::maxSpostamento( int tempPosColonna, int tempPosRiga ){
    if ( tempPosColonna >= 0 and tempPosRiga >= 0
      and tempPosColonna <= maxRangeColonna and tempPosRiga <= maxRangeRiga)
        return 0;
    else
        return 1;
}

void Cavallo::dbgMossa(int mossa){
    switch (dbg01){
        case 0:
            mossa = 5;
            break;
        case 1:
            mossa = 1;
            break;
        case 2:
            mossa = 1;
            break;
        case 3:
            mossa = 7;
            //dbg02 = 200;
            break;
        case 4:
            mossa = 2;
            break;
        case 5:
            mossa = 8;
            break;
        case 6:
            mossa = 19;
            break;
    }
    dbg01++;
}

Codice: Seleziona tutto

#include <ctime>
using std::time;

#include <cstdlib>
using std::rand;
using std::srand;

int rnd(int inizio = 1, int fine = 5000){
    int val1 = 0;
    static bool s1 = true;
    if (s1 == true){
        srand(time(0));
        s1 = false;
    }
    val1 = inizio + (rand()%(fine-inizio+1));
    return val1;
}

Ho modificato il metodo genera movimento e il display della scacchiera.

Ora va in loop ma non ho capito perché.
Il metodo void Cavallo::dbgMossa(int mossa) non l'ho capito. Cosa sono tutte quelle costanti?

[NK]

ripeto il codice per la rnd è:

Codice: Seleziona tutto

val1 = inizio + (rand()%(fine-inizio+1));

con il +, fate copia e incolla 

Per quanto riguarda codeblock, ha un buon debugger. Precisamente puoi:
Aggiungere dei breackpoint nel codice. Cioè dei punto in cui il programma, durante la fase di debug, si ferma.
Per aggiungerli, vai con il cursore sulla riga e premi F5, per toglierlo di nuovo F5. Comparirà un pallino rosso sulla sinistra, se fai click con il tasto destro su quel pallino e selezioni "Edit Breackpoint" puoi dire al debugger dopo quanti passaggi per quel punto si deve bloccare, oppure puoi mettere una condizione che dirà al debugger se fermarsi o no.
Per avviare il debug devi premere F8, il debugger eseguirà il tuo codice e si fermerà sul primo breackpoint, lo vedi dalla presenza di un triangolino sulla sinistra. Quello sta indicando la prossima riga che viene seguita.
Se vuoi eseguire la prossima riga devi premere F7. Tutti i possibili comandi li vedi nel menu Debug.
Per vedere il contenuto delle variabili vai nel menù Debug -> Debugging windows -> Watches
Ok, ti ho indicato la via...

Ma ricordati sempre che la cosa fondamentale è progettare bene il programma, e poi codificarlo in modo giusto.
Come si dice? Chi ben comincia ... 

[daemon_nio]

ripeto il codice per la rnd è:

Codice: Seleziona tutto

val1 = inizio + (rand()%(fine-inizio+1));

con il +, fate copia e incolla 

Modificato! 

Ma ricordati sempre che la cosa fondamentale è progettare bene il programma, e poi codificarlo in modo giusto.
Come si dice? Chi ben comincia ...   ;)

Sono pienamente d'accordo, un programma si progetta prima sulla carta e solo dopo si codifica.

[KubuntuChancellor]

@NK

"Edit Breackpoint" puoi dire al debugger dopo quanti passaggi per quel punto si deve bloccare, oppure puoi mettere una condizione che dirà al debugger se fermarsi o no.

Tutto i resto lo conoscevo, ma cercavo proprio questa funzione :-)

Ma ricordati sempre che la cosa fondamentale è progettare bene il programma, e poi codificarlo in modo giusto.

Cerco sempre prima far funzionare le logiche sulla carta e DOPO lo metto su computer.... Purtroppo non sempre tutto va per il verso giusto....

@daemon_nio
Adesso controllo il codice che hai modificato dopo ti faccio sapere

Il metodo void Cavallo::dbgMossa(int mossa) non l'ho capito. Cosa sono tutte quelle costanti?

Tutte quello che inizia con dbg* non fa parte del programma ma serve a me per fare delle prove....
Ciao
lele

[KubuntuChancellor]

Ciao a tutti,

@daemon_nio

Comunque ho provato a tentativo a correggere l'errore che ti ho indicato al post precedente....../*perche' vai sempre sugli stessi indici? non devi riempire tutti e sessantaquattro elementi del vettore?

Codice: Seleziona tutto

    do{
        if ( arrayMosseCasuali[mossaCasuale] == 0 ){
            arrayMosseCasuali[mossaCasuale] = 1;
            uscita = 1;
            break;
        }
        if ( arrayMosseCasuali[mossaCasuale] == 1 ){
            mossaCasuale = rnd(0,7);
            uscita = 0;
        }
    }while ( uscita == 0 );*/

Effettivamente l'errore era banale, l'intento non voleva essere questo......

Codice: Seleziona tutto

    for (int i=0; i<64; i++) {
        mossaCasuale = rnd(0,7);
	arrayMosseCasuali[mossaCasuale] = 1;
    }

Ma anche questo scrive sempre sugli stessi indici, anzi 64 volte. Perché questa scelta?

In un tuo post precedente, lamentavi il fatto che il programma non è stato suddiviso in maniera decente, ovvero ho messo tutto il codice in una unica classe.

Tralasciando il fatto che il programma non funziona e ha tutti i difetti che l'uomo sia in grado di immaginare, potresti partendo dal mio codice dividere il programma in modo che possa capire ???

La modifica di displayMessage() mi è piaciuta, l'avrei fatta anch'io.
grazie Lele

[daemon_nio]

Okay.

Secondo me non sei pronto per passare alla programmazione ad oggetti, quindi andiamo per gradi.

Io non posso spezzettare il tuo codice in quanto non l'ho capito.
Per esempio un errore commesso (nell'ottica della programmazione a oggetti) è l'inserimento di molta roba nel costruttore.
Un costruttore di un oggetto (in questo caso di un Cavallo) deve unicamente inizializzare delle sue proprietà: ad esempio il colore del cavallo bianco o nero, la sua posizione sulla scacchiera, la sua rappresentazione a video (che potrebbe essere anche un'immagine della pedina cavallo), etc... tu invece hai inserito tante variabili che non riesco proprio a comprendere.


Non riuscendo a modificare il tuo codice vediamo di trovare una via di mezzo.

Eliminiamo la programmazione ad oggetti e scriviamo tutto il codice in maniera procedurale.

Io ho implementato per te il main del problema e ho inserito la firma di tutte le funzioni necessarie, commentando ciò che esse debbano fare.
Ora tocca a te implementare le funzioni in modo corretto  .

Ecco di seguito il codice:

Codice: Seleziona tutto

#include "./random.h"
#include <iostream>

using namespace std;

const int DIM_SCACCHIERA = 8;

void inizializzaScacchiera(int scacchiera[DIM_SCACCHIERA][DIM_SCACCHIERA]) {
	// DA IMPLEMENTARE

	// inizializza la scacchiera con tutti 0
}

// restituisce uno spostamento possibile del cavallo sulla scacchiera
int getRandomMossa(const int scacchiera[DIM_SCACCHIERA][DIM_SCACCHIERA], int contatoreMosse) {
	// DA IMPLEMENTARE

	// l'algoritmo e':
		// scegli un numero casuale X da 0 a 7 utilizzando la funzionie rnd
		// controlla le coordinate della casella su cui dovra' andare il cavallo
		//	se c'e' uno zero
		//		restituisci il numero della mossa indicata
		// 	altrimenti
		// 		si incrementa X modulo 8 ( x = (x + 1) % 8 )  e si ricontrolla
		// 		tutto questo per max 8 iterazioni. Se all'ottava iterazione ancora non è valida si restituisce -1;
	
}

// visualizza la scacchiera sulla console
void displayScacchiera(const int scacchiera[DIM_SCACCHIERA][DIM_SCACCHIERA]) {
	// DA IMPLEMENTARE

	// stampa tutti i valori dell'array bidimensionale
}

// trova il cavallo sulla scacchiera e restituisce le sue coordinate in un vettore
void getPosizioneCavallo(const int scacchiera[DIM_SCACCHIERA][DIM_SCACCHIERA], int contatoreMosse, int coordinateCavallo[2]) {
	// DA IMPLEMENTARE
}

// data una mossa e la posizione iniziale di un cavallo restituisce la sua posizione dopo la mossa
// a seconda della mossa ritorna le ipotetiche coordinate successive
void getPosizioneSuccessiva(const int coordinateCavallo[2], int mossa, int coordinateSuccessive[2]) {
	// DA IMPLEMENTARE

	// Questi sono gli spostamenti relativi di un cavallo. Ti trovi?
	// 0 corrisponde alla mossa x += 2; y += 1
	// 1 corrisponde alla mossa x -= 2; y += 1
	// 2 corrisponde alla mossa x += 2; y -= 1
	// 3 corrisponde alla mossa x -= 2; y -= 1
	// 4 corrisponde alla mossa x += 1; y += 2
	// 5 corrisponde alla mossa x += 1; y -= 2
	// 6 corrisponde alla mossa x -= 1; y += 2
	// 7 corrisponde alla mossa x -= 1; y -= 2
}

// muove il cavallo sulla scacchiera 
void muoviCavallo(int scacchiera[DIM_SCACCHIERA][DIM_SCACCHIERA], int mossaScelta, int contatoreMosse) {
		// DA IMPLEMENTARE

		// cerca gli indice in cui si trova il valore "contatoreMosse" nell'array bidimensionale
		// (in pratica cerca la posizione in cui si trovata il cavallo).
		// a seconda della "mossaScelta" calcola i nuovi indici in cui andra' il cavallo.
		// inserisce nei nuovi indici "contatoreMosse+1" il cavallo.
}



// MAIN DEL PROGRAMMA TUTTO IMPLEMENTATO
int main() {

	cout << "Cavallo in movimento su Scacchiera." << endl;

	// definisce la scacchiera
	// 0 vuol dire che la posizione e' vuota un numero maggiore di 0 vuol dire
	// che il cavallo e' passato in quella posizione alla ennesima mossa
	int scacchiera[8][8];

	inizializzaScacchiera(scacchiera);

	// variabile che conta le mosse del cavallo
	int contatoreMosse = 1;

	// mettiamo inizialmente il cavallo in una casella centrale
	scacchiera[3][3] = contatoreMosse;

	// mostra la scacchiera
	displayScacchiera(scacchiera);

	// ciclo infinito che muove il cavallo finche' possibile
	while (true) {
		// genera una mossa
		int mossaScelta = getRandomMossa(scacchiera, contatoreMosse);

		if (mossaScelta>=0) {
			// muove il cavallo
			muoviCavallo(scacchiera, mossaScelta, contatoreMosse++);

			// mostra la scacchiera
			displayScacchiera(scacchiera);
		} else {
			// esce dal ciclo infinito in quanto non ci sono piu' mosse possibili
			break;
		}

	}
	
	cout << "FINE." << endl;
}

Codice: Seleziona tutto

#include <ctime>
using std::time;

#include <cstdlib>
using std::rand;
using std::srand;

int rnd(int inizio = 1, int fine = 5000){
    int val1 = 0;
    static bool s1 = true;
    if (s1 == true){
        srand(time(0));
        s1 = false;
    }
    val1 = inizio + (rand()%(fine-inizio+1));
    return val1;
}

Il codice e' già compilabile ed eseguibile perché ha tutto ciò che è necessario per farlo girare... ma ovviamente non fa nulla perché manca l'implementazione delle funzioni.

Un approccio di questo tipo si chiama top-down in quanto riesco a definire tutto ciò che mi occorre per scrivere il mio programma senza pensare (in maniera molto dettagliato) all'implementazione.
Questo è ciò che intendo dire con l'espressione "si programma sulla carta".
In questo modo prevedi delle funzioni da un livello alto di astrazione che ti permettono di risolvere dei sotto-problemi. L'insieme di tutti i sotto-problemi da il programma funzionante.
La cosa più difficile è creare quanto meno sotto-problemi possibili, quanto più semplici possibili e soprattutto controllare che un sotto-problema è risolvibile con i dati indicati (ossia tutti i parametri di ingresso sono sufficienti e necessari per calcolare il corretto parametro di uscita).

Credo di aver scritto abbastanza nei commenti da farti procedere da solo, ovviamente se hai dei problemi continua a chiedere.

P.S.
Spero solo di non aver sbagliato la suddivisione altrimenti:  >:(

Ciao, al prossimo post. 

[NK]

Buona strutturazione! un suggerimento per la funzione getRandomMossa, la si può implementare così:
Si estrae un numero a caso X tra 0 e 7 e poi  si controlla se la mossa X è fattibile, se si si ritorna X, se non lo è si incrementa X modulo 8 ( x = (x + 1) % 8 )  e si ricontrolla, tutto questo per max 8 iterazioni. Se all'ottava iterazione ancora non è valida si restituisce -1;
Questo algoritmo è semplice ed esatto

[daemon_nio]

Buona strutturazione! un suggerimento per la funzione getRandomMossa, la si può implementare così:
Si estrae un numero a caso X tra 0 e 7 e poi  si controlla se la mossa X è fattibile, se si si ritorna X, se non lo è si incrementa X modulo 8 ( x = (x + 1) % 8 )  e si ricontrolla, tutto questo per max 8 iterazioni. Se all'ottava iterazione ancora non è valida si restituisce -1;
Questo algoritmo è semplice ed esatto

Giustissimo, non ci avevo proprio pensato. Se la mossa non è buona invece di sceglierne un'altra a caso prende la successiva 

Ho implementato tutte le funzioni e mi sono accorto di aver sbagliato una firma (quindi se hai già copiato il codice devi modificarlo, altrimenti ho modificato anche su):

Codice: Seleziona tutto

int getRandomMossa(int scacchiera[DIM_SCACCHIERA][DIM_SCACCHIERA]);

diventa

Codice: Seleziona tutto

int getRandomMossa(int scacchiera[DIM_SCACCHIERA][DIM_SCACCHIERA], int contatoreMosse);

Giustamente se non si indica dove si trova il cavallo non si può scegliere una mossa a caso corretta, e senza conoscere la variabile "contatoreMosse" non si possono recuperare le coordinate del cavallo.

Inoltre come consiglio posso dirti che per sviluppare il codice mi sono servito di altre due funzioni:

Codice: Seleziona tutto

// trova il cavallo sulla scacchiera e restituisce le sue coordinate in un vettore
void getPosizioneCavallo(const int scacchiera[DIM_SCACCHIERA][DIM_SCACCHIERA], int contatoreMosse, int coordinateCavallo[2]);

// data una mossa e la posizione iniziale di un cavallo restituisce la sua posizione dopo la mossa
void getPosizioneSuccessiva(const int coordinateCavallo[2], int mossa, int coordinateSuccessive[2]);

In queste funzioni ho utilizzato un vettore di due elementi per rappresentare le coordinate di un punto (il primo elemento del vettore rappresenta la x il secondo la y).

Inoltre presta molta attenzione ai parametri. Per entrambi le funzioni i primi parametri sono di solo ingresso il terzo è di ingresso uscita. infatti è proprio quello lo scopo delle due funzioni, impostare il terzo parametro.

Ciao.

[KubuntuChancellor]

Ok grazie per le dritte, ci lavoro un po sopra e vedo cosa riesco a combinare.

grazie mille per l'interesse!!!!

Ciao
lele