Forum Ubuntu-it

Ciao daemon_nio,

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

Sicuramente hai ragione, ma se MAI inizio MAI imparo. La programmazione è l'unica cosa in cui non riesco a imparare facilmente di conseguenza è una questione personale.

Un costruttore di un oggetto (in questo caso di un Cavallo) deve unicamente inizializzare delle sue proprietà:

Scusami ma è quello che fa, ti elenco passo per passo quello che avrei voluto fare.

cavallo::cavallo(){
    // Variabili di prova
    dbg01 = 0;  <- Non serve a nulla, tutte le variabili, funzioni che iniziano con dbgX hanno lo scopo di fare da debug e vedere risultati. dbg = debug

In origine sarebbe servita a capire se una casella era già occupata o no, ma non funziona
    arrayMosseCasuali = new int [numeroMosse];
    int numeroMosse = 64;


// Crea la tabella di 8*8
    maxRangeColonna = 8;
    maxRangeRiga = 8;

    int arraySize = 64; In teoria le mosse dovrebbero essere 64 quindi la dimensione massima pensata per le mosse da fare sono 64

Posiziona il cavallo al centro della scacchiera
    posRiga = 4;
    posColonna = 3;

    // crea lo spazio per la creazione degli array
Sono gli array che permettono al cavallo di spostasi orizzontalmente e verticalmente al interno della scacchiera.
    arrayOrizontale = new int [arraySize];
    arrayVerticale = new int [arraySize];

// questo tiene traccia di TUTTI gli spostamenti effettuati dal cavallo
    arrayMemorizzaScelte = new int [arraySize];

Inizializza a 0 tutti gli array del programma
    // 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;
        }
    }


Attraverso posColonna e posRiga segna che in questa posizione c'è la mossa 0
    arrayMovimento[posColonna][posRiga] = 0;

Qui mia colpa DOVEVO documentare meglio eccovi una tabella che chiarirà tutto. Queste sono le posizione possibili che il cavallo può fare con arrayOrizontale[0] e arrayVerticale[0] la lettara K è la posizione dove il cavallo si trova in questo momento

0 0 0 0 0 0 0 0
0 0 2 0 1 0 0 0
0 3 0 0 0 0 0 0
0 0 0 K 0 0 0 0
0 4 0 0 0 7 0 0
0 0 5 0 6 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 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;
}

Spero di essere stato chiaro, alla luce di queste nuove informazione cosa NON dovevo mettere all'interno del costruttore?

Ciao
Lele

Già il fatto che inizializzi nel costruttore del cavallo la scacchiera è sintomo di una cattiva strutturazione. (bad)
Devi separare il codice per competenza, altrimenti se in futuro devi cambiare qualcosa o correggere un errore su una classe o in generale un concetto, impazzirai nel capire dove fai una cosa e dove vai un'altra. Non so se mi sono spiegato.

Discorso simile va fatto anche per i dati. Infatti anche le possibili mosse del cavallo le avrei memorizzate diversamente...


(b2b)

KubuntuChancellor ha scritto:

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

Sicuramente hai ragione, ma se MAI inizio MAI imparo. La programmazione è l'unica cosa in cui non riesco a imparare facilmente di conseguenza è una questione personale.

E' naturale, programmare non è facile.
Programmare è come parlare, tutti possono imparare, lo si fa pian piano e non ci si deve fermare subito credendo di aver imparato tutto.

Come detto da NK bisogna separare il codice.
Forse io nel primo esempio ho esagerato. Ho iniziato a pensare a concetti più complessi come ereditarietà e polimorfismo che sono la base di una programmazione ad oggetti senza pensare se fossero chiari dei concetti più elementari.

Qualunque programma potrebbe essere scritto in un unico file, anche programmi di milioni di righe di codice, ma pensa poi che macello.

La programmazione a oggetti ti permette di separare un programma non pensando più a funzionalità ma a strutture dati, e funzioni che agiscono unicamente su quei dati. Facendo così si riesce a tenere ordinato molto più codice di quanto si riesce con la programmazione procedurale. Oggi i programmi sono molto più complessi (di conseguenza più codice) di 20 anni fa quindi una programmazione ad oggetti è quasi indispensabile (ciò non significa che il C deve essere buttato, ancora oggi si scrivono tanti programmi ancora in C).

Per il momento ti consiglio di studiare un po', poi potresti tornare sul programma che ti ho passato nell'archivio zip. Non è così complesso quanto sembra.
Ho diviso il problema in tanti oggetti, e ogni oggetto risolve un piccolo problema.

Ad esempio l'oggetto Scacchiera è l'insieme di due proprietà:
ArrayBidimensionale di booleani: di dimensioni 8x8 che rappresenta la pedana, un true indica che in una casella c'è un pezzo, un false indica che la casella è vuota;
Lista di pezzi: insieme di pezzi che sono presenti sulla scacchiera;

Il costruttore non fa altro che inizializzare una lista vuota e una pedana con tutti false (inizialmente non ci sono pezzi sulla scacchiera).

Inoltre sono implementate alcune funzionalità base su una scacchiera come:
display: che visualizza la scacchiera a video;
addPezzo: che aggiunge un pezzo sulla pedana (utile in fase di riempimento della scacchiera);


Le funzioni membro non fanno altro che modificare le proprietà di un oggetto.


La stessa cosa puoi verificarla con il pezzo Cavallo:

Il costruttore non fa altro che inizializzare le proprietà del cavallo:
colore, posizione, simbolo da stampare a video per riconoscerlo su una scacchiera,
e la lista degli spostamenti possibili che può effettuare sulla scacchiera (uno spostamento è definito ancora come un oggetto).

La cosa più complessa di un cavallo è il fatto che eredita funzioni dalla classe Pezzo in quanto la specializza. Le funzioni sono scritte lì perché sono le stesse sia per un cavallo che per un qualunque altro pezzo della scacchiera. A questo serve l'ereditarietà.


Puoi provare inizialmente a modificare il main e a provare le classi singlarmente, può facilitarti a farti un'idea sull'utilizzo delle classi.


Comunque credo che la cosa migliore sia prendere una guida con i soliti esempi studiati ad hoc per spiegare le classi.
Ho trovato questo. Non l'ho letto ma ho visto che in fondo alla pagina è riportato il solito esempio persona-studente che all'università spiegano all'infinito.

Ciao.

Ciao a tutti,
scusate per il ritardo nella risposta ma in questi gg mi sono un po perso nei meandri di Linux.

In ogni caso continuerò a studiare programmazione, anche se ( almeno per me ) è davvero complicato, personalmente a parità di fatica è più facile utilizzare Linux anche a livelli medio-alti.

Grazie per la pazienza, mi sentirete ben presto.
Ciao
Lele

KubuntuChancellor ha scritto: In ogni caso continuerò a studiare programmazione, anche se ( almeno per me ) è davvero complicato.

L'importante è non arrendersi mai 

Spero che hai risolto.
Comunque appena ho un po' di tempo, ti metto anche la mia risoluzione del problema. Ora non posso perché la ho su un altro computer.

Ciao, è stato un piacere.