[C#] Uso delle classi per costruzione di una tabella hash

[nakunita]

Sono studente universitario ed all'università abbiamo approfondito bene il C con le sue struct... ma il Java è stato trattato in maniera fin troppo leggera e la teoria che ci sta dietro le classi del Java, ora che mi sto esercitando a programmare in C# (molto richiesto in ambito lavorativo), mi sarebbe stata molto comoda.

Ora stavo cercando di costruire una libreria per la costruzione di una tabella di Hash (già fatto in C con risultati eccellenti: 30+ all'esame di laboratorio) ma ammetto che l'uso di un array di struct è decisamente più semplice che usare due classi annidate come si dovrebbe fare in Java/C#.

Il codice in C# che ho prodotto fino a questo momento è il seguente:

public class Table
{
    protected class Record
    {
        private string data;
        private bool deleted;

        public Record()     //costruttore generico
        {
            this.data = "";
            this.deleted = false;
        }

        public Record(string data) //costruttore specifico
        {
            this.data = data;
            this.deleted = false;
        }
       
        public void add(string data)
        {
            if (deleted == true)
                this.deleted = false;

            this.data = data;
        }
    }

    private int dimTable;
    private static Record[] table;

    public Table(int dimTable) //costruttore di Table
    {
        //dovrebbe creare n (dove n == dimTable) istanze di Record
        table = new Record[dimTable];
        this.dimTable = dimTable;
    }

    public void add(int idx, string data)
    {
        table[idx].add(data);
    }
}

Di seguito invece posto il codice del Main che utilizza la libreria Table postata sopra:

namespace Project1
{
    class main
    {
        static Table table = new Table(10);

        public static void Main(string[] args)
        {
            table.add(0, "ciao");
            Console.ReadLine();
        }
    }
}

Il compilatore mi compila correttamente il codice senza darmi alcunché riguardo ad errori di sintassi o balle simili... però quando arriva all'istruzione table.add(0, "ciao"); il compilatore si ferma alla funzione

public void add(int idx, string data)
{
    table[idx].add(data);
}

e mi segnala l'errore NullReferenceException. (ed a quanto ho capito, sembra che Table non vada ad istanziare Record)

Ci ho sbattuto più volte la testa ma non sono riuscito a tirar fuori nessuna soluzione... non riesco proprio a capire dove sto sbagliando e che tipo di errore faccio se di distrazione (caldo afoso/poca concetrazione) o se è proprio un errore concettuale.

A questo punto spero che qualcuno di voi riesca ad illuminarmi e spiegarmi meglio. Ringrazio tutti quanti per l'aiuto didattico...

[LeleFT]

Visto che C# (e tutti i linguaggi .NET) ha un forum dedicato e che lo stesso vale per Java e che di linguaggio bisogna per forza di cose sceglierne uno, opto per C# (di cui hai riportato il codice), modifico il titolo e sposto nella sezione corretta.


Ciao.

[nakunita]

sì vero hai ragione... ma più che di linguaggio, il problema mi sa che è proprio di concetto teorico... e credo che non solo gli sviluppatori .net ma anche quelli Java potrebbero essermi d'aiuto. Per questo avevo optato per il forum generico di Programmazione xD

[URANIO]

L'errore dovrebbe essere dovuto al fatto che cerchi di accedere ad un metodo di una classe non istanziata.

L'array interno lo dichiari in questo modo

private static Record[] table;

Con questo codice dai una dimensione all'array

table = new Record[dimTable];

Ma è un array di oggetti null.

Prova a modificare l'add:

    public void add(int idx, string data)
    {
        table[idx]= new Record(data);
    }

PS
Sai che esistono già librerie che fanno questo nel framework giusto?

PPS
-Record[] table; non lo farei static ma solo private
-La classe Record la farei di tipo struct (è una particolare classe .net)
-Il metodo ADD lo metterei solo nella classe table, è suo il compito di aggiungere oggetti all'array, Record non può "aggiungersi" ne eliminarsi dall'array (ne vederlo), chi comanda l'array interno è solo la classe Table.

[nakunita]

Originariamente inviato da URANIO
L'errore dovrebbe essere dovuto al fatto che cerchi di accedere ad un metodo di una classe non istanziata.

L'array interno lo dichiari in questo modo

private static Record[] table;

Con questo codice dai una dimensione all'array

table = new Record[dimTable];

Ma è un array di oggetti null.

Prova a modificare l'add:

    public void add(int idx, string data)
    {
        table[idx]= new Record(data);
    }

PS
Sai che esistono già librerie che fanno questo nel framework giusto?

PPS
-Record[] table; non lo farei static ma solo private
-La classe Record la farei di tipo struct (è una particolare classe .net)
-Il metodo ADD lo metterei solo nella classe table, è suo il compito di aggiungere oggetti all'array, Record non può "aggiungersi" ne eliminarsi dall'array (ne vederlo), chi comanda l'array interno è solo la classe Table.

cavolo hai ragione, in effetti ora funziona. Davo pr scontato che

table = new Record[dimTable];

si preoccupasse non solo di dare una dimensione all'array ma anche di istanziare anche le classi usando il costruttore generico Record() ._. cosa che giustamente non fa perché non glie l'ho detto. ._. e pensare che ci ho perso le ore dietro a sta cosa... *depressione* Eheh.

Anche se non mi sono informato sull'esistenza di tale libreria, immaginavo esistesse già (come esiste in Java), però ho bisogno di fare eserci... parecchi esercizi... visto che sia il C# che il Java ormai sono usati in larga scala in ambito lavorativo. Penso che questo sia un esercizio interessante se fatto bene. Come lo è stato quando l'ho fatto in C per un progetto all'università.

altra domanda: secondo i vostri "gusti" è più elegante modificare il costruttore di Table in questo modo:

public Table(int dimTable) //costruttore di Table
{
    table = new Record[dimTable];
    for(int i = 0; i < dimTable; i++)
    {
        table[i] = new Record();
    }

    this.dimTable = dimTable;
}

oppure lasciare il costruttore come prima ed istanziare Record solo quando vado ad aggiungere un nuovo record nella tabella?

[nakunita]

Originariamente inviato da URANIO
PPS
-Record[] table; non lo farei static ma solo private
-La classe Record la farei di tipo struct (è una particolare classe .net)
-Il metodo ADD lo metterei solo nella classe table, è suo il compito di aggiungere oggetti all'array, Record non può "aggiungersi" ne eliminarsi dall'array (ne vederlo), chi comanda l'array interno è solo la classe Table.

- seguito il consiglio
- con le struct ho già avuto modo di lavorare in C (anche se non so se nel .net si comporta nello stesso modo o è differente) e volevo fare qualcosa di diverso appunto per scopi didattici ._. se aspetto il mio docente di OOP, mi laureo senza capire 'na mazza di come funzionano le classi.
- hai perfettamente ragione. io avevo fatto un altro tipo di ragionamento: "le proprietà di Record sono modificabili solo dai metodi di Record e non da metodi esterni alla classe", però hai ragione te e visto che Table eredita da Record posso mettere le proprietà protected e modificarle da Table ^^ seguendo il tuo consiglio.