Gambas-it

Archivi (sola lettura) => Programmazione (Gambas 2) => Topic aperto da: Picavbg - 28 Marzo 2009, 02:12:48

Titolo: Operazioni sui bit
Inserito da: Picavbg - 28 Marzo 2009, 02:12:48
Nello studio che sto svolgendo sono incappato sulle funzioni di trattamento dei bit che compongono un valore. Ho trovato nella "A Beginner's Guide to Gambas" un capitolo dal titolo "Bit Operation" con tanto di esempio pratico. Ho allora voluto provare il programmino di esempio per conoscere meglio le funzioni disponibili (BTst, BClr, BSet, BChg, Shl, Shr, Rol, Ror). Dopo avere provato e capito le funzioni "BClr, BSet, BChg", ho provato anche "Shl", però ho risconrato differenza fra quanto detto nella guida, nello specchietto di pag.319 e quanto detto poi nell'esempio dio pag.322. Infatti nello specchietto, relativamente ad "Shl" é detto:
Citazione
Shl Value = Shl(Number , Bit)  Returns operand1 with the bit specified in operand2  shifted left one bit position.
Citazione

che credo voglia dire: "Restituisce operand1 con il bit specificato in opernd2 slittato a sinistra di una posizione

per cui se operand1 contiene "00010100" e operand2 contiene "2" il risultato prodotto da Shl dovrebbe essere "00101000".

A pag.322 leggo:
Citazione
      The   Shl   function   is   will   shift   the   value   of  MyInt  n  bits   left   where  n  is
specified by the second parameter.
Citazione

che credo voglia dire: "la funzione "Shl" svolge lo slittamento del valore di MYiInt(operand1) di n bit a sinistra dove n"n" è specificato dal secondo parametro (operand2).

ho eseguito la prova partendo da operand1=10010110 e operand2=3 il risultato é stato: "10010110000" cioè esattamente quello spiegato nell'esempio.
.
[/quote]
Purtroppo non conosco il linguaggio "C" e non posso trovare , se esiste, la corrispondente funzione.
La discordanza riscontrata, se non ho capito male, é da attribuire ad un errata spiegazione nella guida o, piuttosto, é proprio sbagliato il risultato che fornisce la funzione?
In ogni caso credo che bisognerebbe segnalare l'anomalia a Benoît Minisini.
 :hammer:
Ciao.
Titolo: Re: Operazioni sui bit
Inserito da: leo72 - 28 Marzo 2009, 12:27:27
Le funzioni sui bit avevano dei bug e sono state corrette in una delle ultime versioni di Gambas.
Quindi, intanto sarebbe interessante sapere quale versioni usi.

Detto questo, le funzioni sui bit operano in questo modo:
SHL(numero, spostamento): scorrimento a sinistra (SHift Left) di "spostamento" numero di posizioni i bit del numero "numero".
SHR(numero, spostamento):  scorrimento a destra (SHift Right) di "spostamento" numero di posizioni i bit del numero "numero"

Da tener presente che lo scorrimento implica la "scomparsa" dei bit che escono dal registro. Quindi, se vai a scorrere a sinistra il byte "10000000" di 1 bit, otterrai "00000000".

L'altra operazione fondamentale sui bit è la rotazione, effettuata dalle funzioni ROL (ROtate Left) e ROR (ROtate Right). A differenza dello scorrimento, però, la rotazione implica che i bit che escono dal registro da una parte ricompaiono dall'altra. Mi spiego...
Se ruoti a sinistra di 3 bit il valore "11100000" otterrai "00000111".

Detto questo, vanno tenute in considerazione alcune cose:
1) devi considerare che queste operazioni possono essere eseguite solo su numeri interi del tipo byte, short, integer e long, e che la "scomparsa" dei bit nello scorrimento o la rotazione dipende dalla lunghezza del tipo di numero. Se usi un byte, hai 8 bit ecc...
2) Gambas non ha il tipo "unsigned" per cui nelle operazioni devi sempre tener conto di questo. Esistono infatti 2 funzioni apposite che scorrono i numeri tenendo conto del segno, LSL e LSR, rispettivamente per scorrere a sinistra e per scorrere a destra.

Per tutto il resto fai riferimento alla documentazione ufficiale:
http://gambasdoc.org/help/cat/bit

Tieni cmq presente che le operazioni sui bit in Gambas non sono certo facili e spesso bisogna operare delle "manipolazioni" per ottenere gli stessi risultati del C (me ne sono accorto io convertendo algoritmi di cifratura da C a Gambas, algoritmi che nella stragrande maggioranza dei casi contemplano operazioni a livello di bit).
Titolo: Re: Operazioni sui bit
Inserito da: Ceskho - 28 Marzo 2009, 13:43:40
Per la modifica di singoli bit in programmi che ad esempio modificano solo dati espressi in byte è possibile usare un metodo definito "con maschera".....mi spiego meglio....hai un numero binario 10000100 e vuoi controllare lo stato del sesto bit (il terzultimo) usi una "mashera", ovvero un numero di tanti bit quanti quello che vuoi esaminare (nel nostro caso 8) con un 1 nella posizione del bit da controllare....dopodichè si analizza il valore che viene restituito da una AND tra i due numeri.....nel nostro caso la maschera sarà 000000100 e l'operazione

10000100 AND 000000100

Se il bit in analisi e 0 si otterà un 0000000000 che in molti linguaggi di programmazione (come il C) vale 0 poichè tutti i bit valgono tanto, altrimenti si ottiene 00000100 che nel C viene riconosciuto come 1 (in quanto tutto ciò che non è 0 è 1).

In questo modo è possibile usare una maschera per modificare il valore di un dato numero...se vuoi che uno specifico bit diventi zero fai una AND con tutti i valori 1 tranne lo 0 nella posizione voluta oppure il contrario....

spero di essere stato chiaro..nel caso chiedi pure....
Titolo: Re: Operazioni sui bit
Inserito da: Picavbg - 29 Marzo 2009, 00:18:39
Citazione

leo72 ha scritto:
Le funzioni sui bit avevano dei bug e sono state corrette in una delle ultime versioni di Gambas.
Quindi, intanto sarebbe interessante sapere quale versioni usi.

Avevo immaginato quello che mi hai confermato con la tua risposta; solo che il malfunzionamento di alcune delle funzioni che trattano bit persistono ancora alla versione 2.9.0 che è l'unica che ho installato. Le funzioni che "... non funzionano" sono Shl, Rol, Ror, BTst. Stando le cose come mi hai detto non vale neanche la pena che entri nei dettagli delle anomalie riscontrate.

Citazione

leo72 ha scritto:
Detto questo, le funzioni sui bit operano in questo modo:
.............................

Si, tutto vero. Leggendo il manuale "A Beginner's Guide to Gambas", ho capito benissimo il la logica del funzionamente teorico delle funzioni Gambas sui bit, ma se manipolo con le funzioni Shl, Shr, Rol, Ror un campo grande 1 byte(8 bit), il risultato dopo la manipolazione non può tradursi nell'ottenimento di un campo da 4 byte o più. Quindi, se con le versioni successive alla 2.9.0 il bug é stato risolto, fai fintta di niente; io purtroppo in questo momento non posso verificarlo perchè aspetterò ancora un pò prima di passare ad una versione più recente.

Citazione

Ceskho ha scritto:
Per la modifica di singoli bit in programmi che ad esempio modificano solo dati espressi in byte è possibile usare un metodo definito "con maschera".....

Grazie per il cortesissimo suggerimento. Sono pienamente d'accordo con te dato che quello che mi hai suggerioto è un metodo che conosco perchè l'ho imparato quando ho cominciato a programmare, lavorando qualche volta anche in assembler.

Il bello del Forum è che le discussione non sono circoscritte ai diretti partecipanti, ma quello che viene richiesto, proposto, indicato, suggerito o consigliato, è materia utile anche a chi affronterà l'ostacolo, se così posso dire, più avanti e, risalendo a quanto è stato già speso prima da altri amici del Forum, può facilmente trovare aiuto senza chiedere. Anch'io ho superato certi pit-stop con tale metodo. Comunque, grazie. :-)  :-)
:ciao:  :ciao:
Titolo: Re: Operazioni sui bit
Inserito da: leo72 - 29 Marzo 2009, 12:03:16
La 2.9 dovrebbe essere esente dai bug. Dal changelog (che ho ricontrollato) le operazioni sui bit sono state sistemate nella 2.8.2.

Citazione

ma se manipolo con le funzioni Shl, Shr, Rol, Ror un campo grande 1 byte(8 bit), il risultato dopo la manipolazione non può tradursi nell'ottenimento di un campo da 4 byte o più.

Beh, questo è logico: se stai manipolando un byte, ottieni un byte. Per la trasformazione da byte ad intero (4 byte di lunghezza), devi operare a livello di codice.
Potresti ad esempio scrivere
Codice: [Seleziona]

RisultatoIntero = &H000000 OR ValoreByte
Titolo: Re: Operazioni sui bit
Inserito da: Picavbg - 29 Marzo 2009, 20:16:27
Citazione

leo72 ha scritto:
La 2.9 dovrebbe essere esente dai bug. Dal changelog (che ho ricontrollato) le operazioni sui bit sono state sistemate nella 2.8.2.

Come ho detto all'inizio della discussione, ho soltanto costruito un piccolissimo programma inserendovi le istruzioni di utilizzo delle varie funzioni sui bit indicate nella guida "A Beginner's Guide to Gambas", a partire da pag.318. Dopo avere caricato le istruzioni ho eseguito il programma e per quanto riguarda la funzione "Shl" ho digitato il numero 197, impegnando così 8 bit (vedi allegato n.1). Poi ho inserito nella casella (scegli un bit (1-8)) il bit numero 3. Se condo quanto letto nel manuale, avrei dovuto ottenere lo slittamento di una posizione a sinistra di tutti bit a partire dal bit prescelto (il bit con progressivo 2). Invece come è possibile vedere dall'allegatio n.2, il campo originario è stato alterato ed è diventato di due byte con un risultato completamente inaspettato (1576).
Da tutto ciò devo ritenere che la versione 2.9.0 di Gambas contenga ancora i bug cui hai accennato prima tu.
Io ancora non ho nemmeno provato ad usare nessuna delle funzioni sui bit, perchè era mio desiderio ed interesse capirne prima l'applicazione nel liguaggio; però lo studio è andato a ... pallino.
Spero di essere stato più chiaro. ;-)
 :ciao:
Titolo: Re: Operazioni sui bit
Inserito da: leo72 - 29 Marzo 2009, 23:08:30
Sì, è vero.
Ho effettuato dei test ed ho notato che la funzione Shl non... funziona (scusate il gioco di parole).
Sembra che ci sia un bug per cui la funzione non valuta il tipo iniziale di dato (se byte, short, integer o long) e, conseguentemente, non calcola il bit sinistro più esterno.
Mi spiego...
Nel tuo esempio, 197 è rappresentato dal binario 11000101.
Shl(197,3) dà erroneamente 1576, che è rappresentato dal binario 11000101000.
Ora, se confrontiamo i 2 valori binari ci possiamo accorgere che in pratica il secondo è esattamente il primo con 3 zeri aggiunti a destra. La funzione ha cercato di spostare a sinistra i bit ma, non calcolando il margine esterno, ha ottenuto un valore costituito da 11 bit invece di ottenere 00101000 (40).
Lo stesso problema si ha con la funzione ROL, che dovrebbe ruotare i bit. Facendo ROL(197,3) si ottiene sempre erroneamente 1576 invece di 46 (00101110).
Segnalerò la cosa sulla mailing-list.
Titolo: Re: Operazioni sui bit
Inserito da: leo72 - 29 Marzo 2009, 23:32:24
Segnalato.
Titolo: Re: Operazioni sui bit
Inserito da: Picavbg - 30 Marzo 2009, 00:11:11
Citazione

leo72 ha scritto:
Sì, è vero.
Ho effettuato dei test ed ho notato che la funzione Shl non... funziona.

Scusa se insisto, ma il problema non è limitato solamenmte alle funzioni "Shl e Rol", bensì anche a "Ror" e "BTst", come avevo segnalato nella rispo n.4. Sempre con lo stesso numero ho preparato altri due allegati contenenti l'esito delle prove eseguite. :ciao:
Titolo: Re: Operazioni sui bit
Inserito da: leo72 - 30 Marzo 2009, 00:40:43
BTst lavora correttamente: BTst(197,3) prova il bit in posizione 3, non il 3° bit (nei numeri binari, il 1° bit è identificato con la posizione 0, il 2° bit con la posizione 1, ecc... infatti i bit di 1 byte sono in posizione 0..7).
Ror, invece, sbaglia alla grande. Ho segnalato anche questo.
Titolo: Re: Operazioni sui bit
Inserito da: Picavbg - 30 Marzo 2009, 13:18:42
Citazione

leo72 ha scritto:
BTst lavora correttamente: BTst(197,3).


Si, é vero, infatti non mi ero accorto che avevo commesso io un errore nel copiare le istruzioni. Ora ho riprovato ed  ho ottenuto un esito accettabile. Però ho visto anche che se il bit testato  è spento(0), il campo che riceve il risultato del test è giusto, cioè "0", mentre se il bit testato è acceso (1), il campo che riceve il risultato del test, stranamente, contiene un valotre negativo, cioè "-1" e non "1". Perché succede ciò? le istruzioni utilizzate sono le seguenti:
Codice: [Seleziona]

PRIVATE i AS Integer
.................
PUBLIC SUB TestBtn_Click()
  MioIntero = CInt(TextBox1.Text)  'converte la stringa digitata in un valore intero
  IF Int(MioIntero >= 0) AND (MioIntero < 256) THEN
      result = CInt(TextBox2.Text) - 1
      i = BTst(MioIntero, result) 'esegue il test sul bit indicatto in result
      TextLabel7.Text = "BTst(" & MioIntero & "," & result & ")=" & i
      TextLabel9.Text = Str$(i)   'restituisce il bit esaminato
  ENDIF
End

Ciao.
Titolo: Re: Operazioni sui bit
Inserito da: leo72 - 30 Marzo 2009, 15:06:10
BTst restituisce True o False. Non puoi usare il suo risultato come fosse un numero.
Titolo: Re: Operazioni sui bit
Inserito da: leo72 - 30 Marzo 2009, 15:10:54
P.S.:
abbiamo fatto una figura barbina sulla mailing-list...
Benoit mi ha risposto... La funzione agisce correttamente, solo che non determina da sola il tipo di dato passato per cui se vogliamo avere lo spostamento bit per bit su un valore di tipo Byte dobbiamo specificarglielo esplicitamente con
Codice: [Seleziona]

SHL(CByte(197),3)

Il risultato è (correttamente) 40.
Titolo: Re: Operazioni sui bit
Inserito da: md9327 - 30 Marzo 2009, 15:36:12
Figura barbina non direi, al massimo conferma l'assenza di una specifica più approfondita nella doc...

Riguardo alle funzioni sui bit, queste non sono compatibili a quelle usate in altri linguaggi, anche se Gambas è costruito su base C++. Il significato dei parametri, e la logica usata, sono indicati più per un uso non professionale, cosa alquanto usata da quando i linguaggi si sono evoluti in qualcosa non strettamente legato alla macchina su cui girano. Quello che voglio dire, è che queste funzioni sono più una costrizione, ovvero un'appendice storica, di cui ormai se ne fà poco uso, dati gli enormi mezzi che abbiamo oggi a disposizione (memoria, memoria e ancora memoria, a iosa...).
Le funzionalità in questione, sono la base della programmazione, ancora oggi è vero, però legate a logiche di basso livello (assembler, C, ecc.), che sono ora soppiantate dall'utilizzo moderno di oggetti e funzioni più orientate alle macro istruzioni; per fare un esempio, l'usilizzo di carratteri piuttosto che di bit, per indicare una determinata cosa, e via dicendo.
Anche se a me non piace molto lo spreco inutile di risorse, devo constatare che ora l'orientamento è quello di trascurare l'aspetto risorsa, a favore di una più facilitata gestione di un'applicazione. Già l'uso di linguaggi ad alto livello, slegati dall'hardware, e interpretati, sono un enorme spreco di risorse a cui, al giorno d'oggi, nessuno fà più caso (un hd da 1Tera costa 50/60euri...). A seguito di questo, e sperimentazione a parte, il voler introdurre nuovamente logiche usate più di 15/20 anni fà, penso sia ormai controproducente.

Questo, ovviamente, escludendo lo studio e la pura sperimentazione...
Titolo: Re: Operazioni sui bit
Inserito da: leo72 - 30 Marzo 2009, 16:10:49
L'unica cosa per cui ormai si adoperano le funzioni sui bit sono gli algoritmi crittografici che, a causa della loro struttura, operano a livello di singoli bit di informazione. Per il resto concordo con te: sono ormai funzioni desuete e che non servono quasi più a nulla.
Titolo: Re: Operazioni sui bit
Inserito da: Picavbg - 31 Marzo 2009, 11:19:27
Citazione

leo72 ha scritto:
P.S.:
abbiamo fatto una figura barbina sulla mailing-list...
Benoit mi ha risposto... La funzione agisce correttamente, solo che non determina da sola il tipo di dato passato per cui se vogliamo avere lo spostamento bit per bit su un valore di tipo Byte dobbiamo specificarglielo esplicitamente con
Codice: [Seleziona]

SHL(CByte(197),3)

Il risultato è (correttamente) 40.


Mi spiace averti creato involontariamente sensi di "cattiva immagine del Forum" con Benoit, ma la documentazione fornita nella guida ufficiale non dice quello che mi hai suggerito con la tua rispo, quindi io non potevo sapere di scrivere un codice formalmente sbagliato. Aggiungo anche che in fase di avvio del prgramma non ho ricevuto nessuna segnalazione di errore di sintassi. A pag. 322 della guida "A Beginner's Guide to Gambas" la funzione Shl é illustrata così:
Citazione

       The   Shl   function   is   will   shift   the   value   of  MyInt  n  bits   left   where  n  is
specified by the second parameter.  When our user clicks the Shl button, we will
execute this code:
Codice: [Seleziona]

PUBLIC SUB SHLBtn_Click()
  DIM i AS Integer
  DIM result AS Integer
  DIM myInt AS Integer
  myInt = CInt(textbox1.text)
  IF Int(myInt >= 0) AND (myInt < 256) THEN
     result = CInt(TextBox2.Text)

     i = Shl(myInt, result)

     label5.Text = "SHL: " & Bin(i)
     label7.Text = Str$(i)
  ENDIF
END


Dopo l'applicazione del codice che mi hai suggerito ho appurato che funzionano bene sia la funzione SHL che la SHR; anche se, in base a quanto detto sempre nella guida ufficiale, mi aspettavo lo slittamento a sinistra o destra di una sola posizione di tutti i bit a partire dalla posizione scelta, mentre vengono slittati tanti bit quanto è il valore indicato nell'istuzione stessa( nel mio esempio "3"), a partire dalla posizione scelta , verso sinistra o verso destra. Quindi se così come stanno le cose la funzione si comporta bene lo specchietto di pag.319 dell guida si esprime in maniera errata:
Citazione

Shl Value = Shl(Number , Bit)  Returns operand1 with the bit specified in operand2  shifted left one bit position.
Shr Value = Shr(Number , Bit)  Returns operand1 with the bit specified in operand2  shifted right one bit position.

La mia non vuole essere una polemica, ma credo che un qualsiasi insieme di istruzioni, siano esse usate correntemente o, come nel caso di cui stiamo discutendo, come giustamente dice md9327, siano ormai cadute nel desueto, un manuale debba esprimersi con conforme completezza.
Io non so se quel manuale è manutenuto, ma se così fosse, dovrebbe essere corretto ed aggiornato.
Spero che la mia curiosità, destinata ad aumentare le mie conoscenze di Gambas e portata avanti, forse in maniera anche un pò esagerata, non abbia creato effetti negativi; il mio voleva essere soplo un contributo costruttivo. :-)  Saluti a tutti
Titolo: Re: Operazioni sui bit
Inserito da: md9327 - 31 Marzo 2009, 13:00:27
Non credo sia un problema, a mio avviso... domandare è lecito, rispondere è d'obbligo...

La richiesta fatta da leo mi è sembrata logica e giustificata, specialmente nel caso di una non ben chiara documentazione; se poi viene fatta a seguito di una svista, o di un non intendimento, siamo umani, per cui non siamo esenti da errori .

Riguardo al manuale che hai citato, a suo tempo gli avevo dato un'occhiata, e mi era sembrato buono a livello iniziale; però è da tener conto che è stato scritto da una persona che, come noi, ha sperimentato Gambas, e in particolare vecchie versioni.
Ovviamente, gran parte di quanto descritto è sempre e comunque valido, ma di certo non approfondisce molti degli aspetti.
Poi, come ho già detto, il manuale è basato su una vecchia versione di Gambas, e da quei tempi di acqua ne è passata...

Il manuale non mi pare sia manutenuto, dopotutto era scritto all'epoca con l'intendimento di fornire un approccio iniziale al linguaggio; aggiornarlo o farne uno nuovo è un'impresa abbastanza onerosa, e un esempio lo abbiamo con la documentazione ufficiale. Ad ogni modo, faccio i miei complimenti al coraggio avuto dall'autore, e alla sua fatica.

[per leo]
sicuramente esistono situazioni in cui non è possibile fare altrimenti; come nel tuo esempio sulla crittografia, la cosa viene da sè.
Comunque, di senso ne avrebbe, se non fosse che oggi nessuno si preoccupa del consumo delle risorse; il problema è che poi si preoccupa delle prestazioni... mah...
Il bello che questo discorso è, a mio avviso, la causa dell'ideologia generale attuale: basta vedere gli sprechi che si fanno in tutti i campi, e la monnezza che prima o poi ci sommergerà davvero...
Titolo: Re: Operazioni sui bit
Inserito da: leo72 - 01 Aprile 2009, 10:56:20
@Pietro:
la mia non era una forma di richiamo nei tuoi confronti. Solo ammettevo con una frase enfatizzata ("figura barbina") che la domanda era risultata sì un po' "sciocca" ma solo perché io, come te, sono rimasto vittima per l'ennesima volta della documentazione lacunosa con cui abbiamo a che fare.
Tornando alle funzioni, lo spostamento è inteso sempre come numero di avanzamenti, non come identificativo del bit su cui operare. Quindi la guida in questo è errata.

@Luigi:
lo spreco di risorse è ormai implicito in ogni software che viene realizzato. Il problema deriva dal fatto che non abbiamo più a che fare con HW che non veniva modificato per anni (perché non era aggiornabile o era troppo costoso farlo) come negli anni '80. Se qualcosa non gira veloce, si prende e si cambia la macchina, non si pensa che magari con un'ottimizzazione del software si potrebbe ottenere lo stesso risultato.

Riguardo a quella guida, che è del 2005, va detto che è stata scritta per la versione 1.0 del linguaggio. E' normale che tante cose siano cambiate, soprattutto le funzioni sui bit che, come detto, sono state notevolmente riviste nella 2.8.2.
Sul fatto che non sia aggiornata, bisogna dire che Rittinghouse, così ho letto sulla mailing-list di Gambas, non sta bene in salute e non ha più intenzione di metterci le mani.
Titolo: Re: Operazioni sui bit
Inserito da: vuott - 12 Maggio 2012, 16:39:22
Detto questo, le funzioni sui bit operano in questo modo:
SHL(numero, spostamento): scorrimento a sinistra (SHift Left) di "spostamento" numero di posizioni i bit del numero "numero".
SHR(numero, spostamento):  scorrimento a destra (SHift Right) di "spostamento" numero di posizioni i bit del numero "numero"

Tieni cmq presente che le operazioni sui bit in Gambas non sono certo facili e spesso bisogna operare delle "manipolazioni" per ottenere gli stessi risultati del C (me ne sono accorto io convertendo algoritmi di cifratura da C a Gambas, algoritmi che nella stragrande maggioranza dei casi contemplano operazioni a livello di bit).

Mi viene da pensare che, nel caso della necessità di effettuare uno spostamento a sinistra dei bit, almeno la funzione SHL potrebbe essere sostituita con una semplice operazione, dato che - lo ricordo qui  a me stesso - lo spostamento a sinistra equivale al valore iniziale moltiplicato 2 elevato ad una potenza determinata dal numero dello spostamento delle posizioni.
Quindi, ad esempio, 6 << 3  equivale a 6 * 23 .

http://www.gambas-it.org/wiki/index.php?title=Sostituire_gli_operatori_logici_di_spostamento_dei_bit_con_semplici_operazioni
Titolo: Re: Operazioni sui bit
Inserito da: Top Fuel - 12 Maggio 2012, 22:08:08
Magari mi sbaglierò, ma ho sempre saputo che le elevazioni a potenza sono molto più onerose come risorse di uno shift o anche semplicemente di una moltiplicazione.
Io mi ricordo che 2*2*2 è fatto molto più velocemente di 2^3.
Titolo: Re: Operazioni sui bit
Inserito da: md9327 - 13 Maggio 2012, 12:36:13
I ricordi srvono a poco, in quanto tocca vedere com è stata implementata la routine di base.
Su esperienza avuta su linguaggi a basso livello, tra cui pure l'asm, le modalità con cui scrivere una determinata routine sono molteplici.
Se stiamo in ambito programmazione-ad-oggetti, lo scopo finale di tale approccio non ha come principio base l'ottimizzazione del codice di basso livello, ma altre cose. E' ovvio che la ricerca di miglioramenti e ottimizzazione è sempre attiva, e questo si può vedere già con linguaggi tipo java (se qualcuno ha domestichezza con esso), che ha fatto miglioramenti enormi rispetto a poco tempo fà (vedi grafica...).
Ribadisco ancora che Gambas è un linguaggio ad altissimo livello, e questo non implica che sia migliore, ma solo che è situato su uno strato software molto astratto, e si basa fondamentalmente su software esterno. Di suo ha pochissimo, quasi niente, e quindi dipende completamente dal funzionamento di questo substrato. Se vogliamo possiamo andare ad analizzare cosa c'è oltre, ma poi rischiamo di uscire fuori dal seminato.
Tanto per fare un esempio, già java si fonda su librerie scritte in C/C++, e già l'uso di una String ha valenza diversa dall'uso di una serie di caratteri in una determinata cella di memoria. La String è un oggetto, e quindi si porta dietro tutta una serie di cose che esulano dal concetto di ottimizzazione. La prova da fare è estremamente semplice, ma dato che questo studio l'ho fatto tanti anni fà, priprio perchè sviluppavo procedure real-time, è inutile e credo che chi l'ha già affrontato sà quanto è vero.