Come possiamo definire un concetto nel nostro codice?

Ci eravamo lasciati nel precedente articolo dicendo che se vogliamo esplorare la possibilità di fare coding con i concetti, dobbiamo risolvere tre problemi, il primo dei quali è legato proprio alla domanda scelta come titolo per questo articolo:

Come possiamo definire un concetto nel nostro codice?

Sempre nell’articolo già citato abbiamo definito il concetto* di concetto** in questo modo:

Un concetto può essere visto come una etichetta che rimanda ad una entità reale o astratta.

In questo senso l’etichetta concetto* potrebbe rimandare all’entità astratta “cerchio” (concetto**) che a sua volta potrebbe rimandare all’entità reale “ruota avente raggio di 22cm”.

Proviamo a partire con le nostre riflessioni proprio dalla definizione che abbiamo dato.

Innanzitutto suddividiamola nelle sue parti costitutive per verificare se possiamo tradurle in codice:

  • un concetto è identificato da una etichetta;
  • un concetto rimanda ad una entità reale o astratta.

Concentriamoci per il momento sulla sola prima frase e facciamo entrare nel flusso dei nostri pensieri anche gli argomenti trattati nella nostra Guida al FreeBASIC. Sappiamo che uno dei sinonimi del verbo identificare è far coincidere. Facendo ora un parallelo con quanto abbiamo imparato studiando il FreeBASIC, ci dovrebbe venire in mente l’articolo dedicato alla dichiarazione delle variabili: ad una variabile, infatti, coincide uno spazio in memoria. In altri termini, all’etichetta scelta come nome della variabile corrisponderà un certo valore: quindi una certa informazione.

Tenendo a mente questa idea e passando alla seconda frase, il rimando ad entità reali o astratte porta il nostro pensiero al tema più specifico della dichiarazione di un tipo di dato definito ad hoc che possa rappresentare queste entità.

Attenzione! Nell’ambito dell’informatica, rappresentare una qualsiasi cosa significa, in ultima analisi, costruire un modello.

Le nostre riflessioni ci hanno quindi per ora condotto ad un altro concetto, quello di modellizzazione.

Il processo di modellizzazione avviene attraverso l’interazione tra l’atto dell’osservazione e l’atto del pensare. Questa interazione permette di creare un modello, cioè una classe generica (concetto**) che rappresenta una certa entità astratta che a sua volta rappresenta idealmente una entità reale o astratta (cioè il cosiddetto oggetto o istanza della classe).

Esprimendo il problema in questi termini ci sembra di giungere come logica conseguenza al paradigma della programmazione orientata agli oggetti.

Ma allora questo ipotetico nuovo paradigma di programmazione per concetti che andiamo vagheggiando non è altro, in realtà, che l’arcinoto paradigma di programmazione ad oggetti?

Apparentemente sembrerebbe di sì, ma cè un aspetto che facilmente può sfuggire ad una prima analisi.

Proviamo ad approfondire la questione dicendo quanto segue:

Nella programmazione per concetti non si vogliono creare dei modelli, ovvero delle classi al fine di istanziarle per ottenere degli oggetti con cui lavorare, ma si vuole rimanere al solo livello concettuale del tipo (type), e solo con questo lavorare. Non si creano quindi delle classi e non si istanziano oggetti.

Si abbandona quindi l’idea della rappresentazione: ovvero la creazione arbitraria e soggettiva di un modello (concetto**), nella convinzione che il modello non potrà mai essere la realtà.

Si persegue invece l’idea dello sviluppo dinamico di una rete di concetti* interconnessi.

Nel nuovo paradigma di programmazione per concetti che andiamo definendo il ruolo fondamentale spetta alla riflessione del programmatore: sarà il suo pensare riflessivo che creerà dinamicamente le connessioni concettuali che sveleranno l’idea che di volta in volta informa una determinata realtà.

Un esempio pratico

''definiamo il tipo di dato "concetto*"
type concetto
  id as integer ''identificativo del concetto
  etichetta as string
end type

''dimensioniamo e creiamo il vettore dei concetti
''del tipo di dato "concetto"
dim vettore_concetti(1 to 2) as concetto

''valorizziamo i membri dei diversi concetti
vettore_concetti(1).id = 1
vettore_concetti(1).etichetta = "albero"
vettore_concetti(2).id = 2
vettore_concetti(2).etichetta = "pioppo"

Bene. Possiamo per oggi fermarci qui.

Nel prossimo articolo affronteremo il secondo quesito:

Come possiamo far entrare in relazione più concetti?

FreeBASIC – tipo di dato definito da noi

Nonostante i tipi di dato standard ci permettano di risolvere la maggior parte dei problemi che affrontiamo quando scriviamo un programma, può verificarsi il caso che si renda utile, se non addirittura necessario, utilizzare un tipo di dato creato ad hoc direttamente da noi.

Anche questo tipo di dato dovrà essere identificato da una etichetta che dovrà rispettare le stesse regole viste per le variabili.

Il tipo di dato creato dall’utente (user-defined type o UDT) può essere visto come una specie di array, con la particolarità che un UDT può contenere anche tipi di dato differenti. È proprio questa caratteristica a rendere utile un UDT.

Un UDT può contenere sia variabili che procedure che prendono il nome di membri (o elementi).

Utilizzo di un UDT attraverso una variabile

Per creare un UDT si utilizza l’istruzione type.

Per accedere ai singoli membri attraverso una variabile si utilizza l’operatore . (notazione puntata):

'definizione di un nostro tipo di dato
type automobile
  cavalli as integer
  cilindrata as integer
end type

'dimensionamento e creazione di una variabile
'del tipo appena definito
dim mia_auto as automobile

'valorizzazione dei membri
mia_auto.cavalli = 75
mia_auto.cilindrata= 999

'stampa dei valori
print "CV = "; mia_auto.cavalli
print "Cilindrata = "; mia_auto.cilindrata

Utilizzo di un UDT attraverso un puntatore alla sua variabile

Come abbiamo visto nell’articolo dedicato ai puntatori, anche per i tipi di dato definiti da noi (UDT) possiamo creare il relativo puntatore alla sua variabile.

La creazione di questo tipo di puntatore è simile a quella per un puntatore ad una variabile relativa a un tipo di dato standard. Ciò che cambia è la modalità di accesso ai singoli membri che dovrà avvenire attraverso l’operatore ->.

Riprendendo l’esempio precedente, aggiungiamo le seguenti righe di codice:

'creazione di un puntatore alla variabile
dim p as automobile pointer = @mia_auto

'valorizzazione dei membri attraverso il puntatore
p->cavalli = 90
p->cilindrata= 1500

'stampa dei valori
print "CV = "; p->cavalli
print "Cilindrata = "; p->cilindrata

Nel prossimo articolo inizieremo a parlare delle procedure.

A presto. 🙂