Author Archives: OpenCode Scapigliato

Didattica Gambas: Passaggio parametri da riga di comando


Un paio di post fa ho spiegato molto sinteticamente come creare applicazioni in C che permettessero il passaggio al programma di argomenti da riga di comando.

Ora vedremo come eseguire la stessa procedura ma con codice scritto in Gambas. Anche se la potenza di questo linguaggio si basa sulla facilità con cui si possono scrivere software con interfaccia grafica, alle volte può essere molto più utile scrivere codici di programmi per terminale.

Proprio come accade per il linguaggio C, anche con il gambero è possibile passare argomenti che verranno poi salvati in un vettore di tipo stringa dove ogni elemento corrisponde ad un parametro.

Avviamo un nuovo progetto e selezioniamo “Applicazione a riga di comando”. Fatto ciò si presenterà il solito IDE ma con la mancanza dei tipici oggetti grafici.
Si nota subito la mancanza del form FMain sostituito dal modulo MMain.

Spostiamoci nell’editor del codice e scriviamo:

PRINT "Nome programma: " & Application.Args[0]
PRINT "Argomenti passati: " & Application.Args.Count
PRINT "Primo argomento: " & Application.Args[1]
PRINT "Secondo argomento: " & Application.Args[2]

Analizziamo gli elementi fondamentali del codice. L’uso di Application.Args[x] permette di controllare il contenuto dell’array degli argomenti passati. Bisogna tenere presente che il primo elemento del vettore Application.Args[0] contiene sempre il nome del programma stesso. Proseguendo così si trovano il primo argomento passato (Application.Args[1]), il secondo (Application.Args[2]), ecc…..

Di notevole importanza è anche l’elemento Application.Args.Count che altri non è che una variabile di tipo integer contenete il numero degli elementi passati al programma. Specifico che se al programma vengono passati 3 elementi Application.Args.Count varrà 4 poichè in esso è conteggiato anche il nome del programma stesso.
Esso inoltre è importanti per scrivere programmi dei quali non si conosce preventivamente il numero di argomenti passati. Grazia a Application.Args.Count, infatti, è possibile gestire un ciclo che legga tutti i dati anche senza conoscerne il numero preventivamente.

Compilando e lanciando il codice precedente e scrivendo nel terminale ad esempio:

./mio_programma uno due

Ci verrà restituito:

Nome programma: mio_programma
Argomenti passati 3
Primo argomento: uno
Secondo argomento: due

Le potenzialità di questo codice sono molte ed è possibile creare programmi molto versatili usabili comodamente da terminale.

Inoltre voglio precisare che questo tipo di gestione può essere utilizzata anche con programmi ad interfaccia grafica. Infatti è possibile lanciare questi programmi da terminale passando eventuali argomenti magari per settare delle impostazioni iniziali.

Didattica C: Passaggio parametri da linea di comando

Quando si opera in ambito shell solitamente si creano programmi capaci di accettare diversi parametri che serviranno per impostare o modificare diverse componenti del software stesso. Vediamo come scrivere del codice in C per abilitare e gestire argomenti passati al programma da linea di comando.

Iniziamo col vedere il codice utile a svolgere tale scopo:

int main(int argc, char* argv[])

Quello che si vede è il classico main presente, necessariamente, in ogni programma scritto in C. Chi ha dimestichezza con il linguaggio in questione noterà che tra le parentesi che normalmente si lasciano vuote sono presenti due nuove variabili, argc ed argv[].

int Argc è un intero che contiene il numero di parametri passati al programma mediante la riga di comando. Si noti che se i parametri passati sono n, argc varrà n+1 poichè esso conteggia anche il programma stesso.

char* Argv[] (o equivalentemente **argv) è un array di tipo puntatore a char (carattere) e contiene le stringhe equivalenti ai vari parametri. Ogni elemento del vettore infatti contiene il parametro salvato come stringa. Da notare che in argv[0] è salvato il nome del programma stesso.

Vediamo un esempio.

Prendiamo un semplice codice C che legge i dati passati da riga di comando r gli stampa nuovamente nel terminale.

int main(int argc, char* argv[])

{
  int i;

  //-- leggiamo ogni parametro presente in linea di comando
  for ( i=0 ; i!=argc ; i++ ){  
     printf("%s\n", argv[i]);
  }

return 0;

}

Il codice in questione è molto semplice. Esso, grazie ad un ciclo for, controlla di volta ogni parametro passato.

Compilando il programma e scrivendo nel terminale:

./programma cane gatto topo

Il terminale restituirà:

./programma
cane
gatto
topo

Infatti eseguendo il ciclo for si vede che per i=0 si ha argv[0] ovvero il nome del programma stesso, per i=1 si ha il primo parametro cioè cane per i=2 si ha il secondo parametro e così via.

Come si vede l’uso dei parametri è abbastanza facile e permette una versatilità del software abbastanza potente pur non avendo a disposizione una GUI con la quale impostare i valori.

Calcolatrice in Gambas


Quando si inizia a programmare la prima cosa che si fa è creare una calcolatrice. Non interessa che essa sia bella o sia la semplice riga comando, l’importante è che il primo programma funzionante che si scrive sia una calcolatrice. Non ho mai capito il perchè ma ovviamente non potevo non arricchire il mondo dell’informatica con la più semplice delle calcolatrici scritte in Gambas.

In realtà l’idea non è stata mia ma è nata dall’esigenza di un utente di inserire nel suo progetto una pratica calcolatrice per fare semplici calcoli per un gestionale.

Il progetto è veramente basilare e sarà ampliato a seconda delle funzionalità richieste. La cosa di cui sono davvero fiero è che ho dato quel tocco in più per eseguire la visualizzazione in perfetto stile vera calcolatrice, ovvero, quando si preme il tasto dell’operazione che si vuole eseguire il numero sullo schermo rimane e scompare solo quando successivamente si inizia ad immettere il nuovo operando.

Questo progetto può essere utile per fini didattici e come sempre trovate il download nella colonna di destra.

EDIT: Alla versione 1.0.2 è stata aggiunta la visualizzazione del nastro, cioè l’area nella quale vengono elencate le operazioni effettuate in precedenza.

EDIT: L’attuale versione 1.1.0 prevede il nuovo tasto percentuale intelligente; ovvero è possibile effettuare le normali operazioni in cui però il secondo membro è una data percentuale del primo.

ESEMPIO:

1000 + 20% = 1000 + 200 = 1200


EDIT: Con la versione 1.1.1 si risolve un piccolo bug per il calcolo della percentuale ed è possibile effettuare la stessa direttamente da tastiera con il tasto % [shift + 5]

EDIT: Corretto l’auto-aggiornamento della nastro nella versione 1.2.0. Ora lo stesso scorre automaticamente ad ogni operazione in modo da mostrare sempre l’ultima eseguita.

EDIT: Riscontrato piccolo bug nelle operazioni con primo membro decimale. Risolto nella versione 1.2.2