Bentornati, ragazzi.
In questo video, iniziamo a imparare il somalo e lo facciamo passo dopo passo, partendo da una componente
davvero importante, forse la più importante.
E sì, se abbiamo capito questo, anche il resto non sarà più così difficile.
Va bene.
Ok, andiamo.
Diamo un'occhiata ai registri in somalo.
Così ho tirato fuori la mia tavoletta grafica e ho fatto dei disegni fantasiosi per spiegarlo.
Bene, prima di addentrarci troppo nell'argomento registro, diamo un'occhiata a questa
funzione di base.
In base a ciò, analizziamo il modo in cui la CPU gestisce questi sì.
Queste singole istruzioni e poi capiremo come funzionano i registri in somalo.
Va bene.
Ok.
Supponiamo di avere la seguente funzione.
Abbiamo.
Già.
Pubblico.
La funzione che restituisce un valore intero in questa funzione prende due parametri e li somma.
Per questo motivo abbiamo dato il nome di "add power".
E qui abbiamo tutti e due i parametri in A e in B.
Questa funzione ha anche una variabile locale chiamata some.
E questo viene inizializzato con zero.
Poi abbiamo la somma che è uguale.
Ora questi due parametri vengono sommati e iniziano a formare una somma.
Quindi oops.
La somma è uguale ad A più B.
E poi restituiamo questa variabile.
Qual è il valore di questa variabile?
Perché la somma dei rendimenti?
Va bene.
Si tratta di una funzione molto semplice, scritta in un linguaggio di programmazione di alto livello.
Ma la CPU non può gestirlo in questo modo.
Pertanto, questa funzione viene compilata e il compilatore traduce questa funzione di alto livello in singole
istruzioni che possono essere gestite dalla CPU.
Quindi diamo un'occhiata a questo aspetto, ma non preoccupatevi solo di un livello molto alto.
Pertanto.
E tracciamo questa linea qui.
Va bene.
Ora abbiamo la nostra CPU.
Questa è la nostra CPU.
E questo ha, ovviamente, anche delle spille.
Alcuni di essi sembrano non essere collegati e altri potrebbero essere in cortocircuito.
Ma sì, questo non ha importanza perché non li usiamo.
Va bene.
Quindi la CPU non capisce cose come in una guerra e B bene, inoltre non capisce una variabile chiamata somma.
Ciò che la CPU capisce sono i registri.
Quindi una CPU ha un registro.
In questo, ad esempio, o in questo, o forse anche in questo.
E questi registri sono ora una sorta di segnaposto per questi valori o queste variabili.
In questo caso, ad esempio, questo registro può contenere la variabile A, questo la
variabile B e questo la somma.
Se si parla di smartphone, è molto probabile che si tratti di un'architettura ARM.
L'architettura ha registri che vanno dallo zero all'uno o al due o al tre, e anche altri registri come il contatore
di programma, per esempio.
Va bene.
Ora, se compiliamo questo codice qui.
Poi il compilatore traduce queste istruzioni in istruzioni singole e il risultato è il seguente.
Ad esempio, se chiamiamo questa funzione qui, il primo argomento, il parametro uno,
verrà memorizzato nel registro r zero.
Quindi il nostro zero ora contiene una B che sarà memorizzata in r uno.
Per quanto riguarda gli altri parametri o registri, non abbiamo nessun altro parametro.
Pertanto, questi registri non vengono utilizzati nella nostra convenzione di chiamata qui.
Il contatore di programma contiene il valore o l'indirizzo dell'istruzione successiva.
Ma per ora ignoriamo questo aspetto.
Quindi viene semplicemente impostato sull'istruzione successiva, che verrà eseguita dalla CPU.
Va bene.
La somma sarà successiva a quella memorizzata nel registro e nell'architettura.
Il valore di ritorno di una funzione sarà memorizzato nel nostro zero.
Così, dopo, il nostro zero non regge più.
Tiene il valore di ritorno, che è un po'.
Questo è il modo in cui la CPU gestisce questi valori o riferimenti.
Insomma, è un po' più complesso, ma ad alto livello si presenta esattamente così.
Va bene.
Ma cosa succede se si esauriscono i registri?
Ad esempio, nell'architettura del braccio, vengono utilizzati come parametri da zero a tre.
Questi registri contengono i parametri di una funzione.
Ma se la nostra funzione ora ha dieci parametri e la CPU memorizza i primi quattro parametri
nei registri qui sopra: zero, uno, due e tre, mentre gli altri vengono inseriti nello stack.
Lo stack è la memoria del programma.
Quindi questo qui.
Questo è il cervo e tiene gli altri parametri in modo che vengano spinti nella memoria.
Questo è il ricordo.
Potreste chiedervi perché vi sto dicendo tutto questo.
E, a dire il vero, non ne avevo la minima idea.
Scherzo.
Smiley agisce sullo stesso comportamento, quindi anche Smiley utilizza i registri per memorizzare i propri valori o le proprie variabili.
È praticamente identico a quello della CPU, ma naturalmente Smiley ha altri registri.
Altrimenti, sarebbe assolutamente ridicolo se Smiley utilizzasse questi registri anche qui.
Naturalmente non è questo il caso.
Quindi Smiley ha i propri registri.
E che tipo di registri?
Ma diamo un'occhiata.
Facciamo un taglio qui.
Questo è il nostro angolo dei sorrisi.
Ecco fatto.
L'output in Somalia dipende dallo strumento che stiamo utilizzando, ad esempio, per scambiare il compilatore.
Riassumere tutti questi registri in un unico blocco.
Lo strumento APK invece li divide.
Ecco perché mi piace molto usare lo strumento APK.
Lo strumento APK li divide in due parti.
La prima parte è costituita dai registri locali.
Sono i registri locali utilizzati in una funzione.
Ad esempio, nel nostro caso abbiamo int some e questo è un registro locale.
I registri locali hanno effetto solo su questa funzione, quindi solo i registri che vengono inizializzati
o utilizzati in questa funzione qui e nell'altro tipo.
Avete un'idea di cosa potrebbe essere?
Sono abbastanza sicuro che si tratti dell'altro tipo di parametri.
E intendo parametri.
Già.
Non è così difficile.
I parametri sono semplicemente registri o valori passati a una funzione, ad esempio in questo e in questo.
Va bene.
In Smiley, se stiamo compilando un'applicazione con lo strumento APK, questi parametri
sono denominati da p zero a p qualcosa.
Anche P zero è un caso speciale.
Quindi P zero è il più delle volte l'operatore in questione.
Si tratta quindi di un registro davvero speciale.
Pertanto, questi parametri iniziano normalmente da p uno e contano semplicemente verso l'alto.
Quindi questo sarebbe P ai registri locali.
Si chiamano con la V.
Quindi nei registri locali abbiamo V zero e si conta semplicemente verso l'alto.
Nel nostro caso, abbiamo un registro locale o una variabile locale denominata sum e questo sarà il nostro registro
v zero.
Ma i registri non riguardano solo due variabili locali, come in questo caso, ad
esempio, V0, a cui si fa riferimento come ad esempio questo valore qui, questo valore zero SPU non può gestire tre compiti.
In un primo momento, la CPU suddivide questa istruzione in diverse istruzioni e quindi il
valore zero viene memorizzato in un registro.
Questo può essere lo zero, ma potrebbe anche essere un altro.
Ad esempio, b uno.
Non si tratta di una variabile locale, ma di un valore locale temporaneo, memorizzato in un registro.
Quindi, per semplificare un po' le cose.
I registri sono solo una sorta di segnaposto per i valori.
Va bene.
Una cosa importante da ricordare quando si lavora con questi registri è che questi registri, se vengono
inizializzati all'inizio, non devono essere uguali alla fine, non solo per quanto riguarda i
valori, ma anche per quanto riguarda le variabili.
Ad esempio, se si estende questa funzione qui.
Quindi all'inizio inizializziamo B0 a zero con la variabile somma e poi diciamo che abbiamo un gruppo
di altre variabili che vogliamo tenere.
La B due sta tenendo.
I.
E così via.
In seguito, stiamo tornando, ad esempio, vogliamo.
Restituire alcune lettere mancanti, credo.
Già.
Ecco fatto.
Va bene.
Quindi il compilatore sta generando questo codice e a un certo livello, per esempio tra qui, il compilatore
potrebbe riconoscere che non sto più usando la variabile sum.
Questa non sarà più referenziata o restituita da questa funzione.
Pertanto, possiamo riciclare questo registro perché anche questi registri sono molto preziosi per l'intero flusso
del programma.
Ad esempio, per quanto riguarda le prestazioni in fase di esecuzione o l'utilizzo della memoria o altro, il compilatore
cerca di ottimizzare al meglio il codice.
Pertanto, se il compilatore riconosce che la variabile sum non verrà più utilizzata,
ricicla il registro che contiene questa variabile, che in questo caso è zero, e lo inizializza
con una variabile completamente diversa, ad esempio set.
E ora supponiamo che il programma non restituisca l'uno, ma che alla fine sia zero.
Se guardiamo all'inizio di questa funzione, potremmo pensare: "Oh, ok, questa funzione restituisce
la variabile somma, ma questo registro è stato riciclato e quindi sovrascritto a questo punto.
E sì, il programma restituisce invece questo set di variabili.
Si tratta quindi di un aspetto che dobbiamo tenere presente.
Pertanto, il mio approccio è quello di tenere traccia di ogni registro e lo vedrete durante questo corso.
Quindi scrivo ogni riga di smiley in una sorta di riga di codice, con l'indicazione di cosa fa e di cosa registra effettivamente
il valore.
In questo modo, possiamo tenere traccia di questi registri e non perdere il controllo o essere sopraffatti da tutte
queste cose.
A mio parere, questo è il modo migliore per imparare.
SMILEY Perché se si analizza il codice del programma, per esempio questa parte qui, questo
codice del programma, abbiamo invertito ogni singola riga che si trova nel codice smiley qui.
Lo faremo durante questo corso e vedrete che all'inizio potrebbe essere un po' difficile,
ma se continuerete a esercitarvi più volte insieme a me, dopo questo capitolo sarete in grado
di invertire e scrivere il vostro codice smiley, il che è davvero incredibile.
Vi prometto che se continuerete a lavorare con me durante il capitolo sugli smiley e a svolgere
tutti gli esercizi insieme a me, sarete in grado di leggere ogni singola riga di smiley e sarete anche in
grado di scrivere il vostro codice smiley, in modo da poter modificare un'applicazione nel modo che preferite.
Va bene.
Riassumiamo rapidamente questo punto.
Cioè, noi all'inizio.
Qual è dunque la chiave di lettura?
Ok.
Così gli atti sorridenti sui registri.
Se si utilizza lo strumento APK per decompilare l'applicazione, i file smiley o i registri vengono
divisi in due parti.
Uno riguarda i registri locali e l'altro i parametri.
Quindi i registri locali iniziano con V e i parametri iniziano con P.
I nostri parametri iniziano normalmente con P, uno e semplicemente verso l'alto, p due e così via.
Abbiamo un registro di parametro speciale che è p zero.
Scriviamolo qui.
P zero è questo oggetto per la maggior parte del tempo.
Quindi, al 99%, il p zero contiene questo oggetto.
Quindi, ad esempio, se state scrivendo codice Java, abbiamo ottenuto questo punto, questo è esattamente il registro P zero.
Non preoccupatevi troppo di questo al momento.
Lo scopriremo più avanti.
Va bene.
Occorre inoltre ricordare che se si inizializza o si assegna una variabile a un valore di registro, questo
registro può essere riciclato.
Quindi, se questo accade all'inizio, non significa che questo registro contenga questa variabile.
Qual è il valore alla fine di questa funzione?
Quindi può essere sovrascritto, ma anche completamente riciclato.
Quindi, invece di avere la stessa variabile, potrebbe essercene una completamente diversa.
Ad esempio, la variabile set.
È necessario tenerne traccia e durante il corso imparerete come farlo.
È facile.
Semplicemente, facciamo il reverse engineering di ogni singola riga di Somali e scriviamo cosa fa questa istruzione.
E poi non perdiamo il filo di questo discorso.
Forse un'ultima cosa che devo menzionare qui.
Quindi, secondo me, il modo migliore per imparare il somalo è avere un approccio sulla nostra tavoletta grafica
qui, ma anche qualche esperienza di apprendimento sulle diapositive.
Quindi prendiamo questo codice, lo modifichiamo un po' e lo esaminiamo ancora una volta nelle
diapositive.
A volte potrebbe essere un po' frustrante affrontare un argomento due volte sulla tavoletta grafica
e sulle diapositive.
Ma per me personalmente e anche per il feedback che ho ricevuto, questo approccio è il modo migliore per imparare il somalo.
Perché il somalo si basa sulla pratica e sulla ripetizione di ciò che si è appreso, applicandolo a nuove
funzioni.
Quindi, avendo questo, a volte è un po' noioso.
Se ne è parlato due volte sulla tavoletta grafica qui sopra e anche sulle diapositive, ma vedrete i progressi
su voi stessi se lo faremo e continueremo a farlo.
Ok.
Quindi, a volte è anche un po' meglio averlo sulle diapositive, invece di commettere un errore disordinato nel
girare qui intorno.
Va bene.
E scriviamo questo codice.
Lo compilano e poi analizzano gli smiley pad presenti.
In seguito applicheremo alcune patch e daremo un'occhiata alle modifiche sulle nostre diapositive.
Pertanto, andiamo.
Torniamo alla macchina virtuale Ubuntu.
Ok.
Eccoci ora con la nostra macchina virtuale ubuntu.
Scriviamo questa funzione e vediamo un'applicazione reale.
Quindi apriamo Android Studio.
Verso Android Studio uno studio di bash come H.
Ok.
Ora entriamo in questa classe ed estendiamo questo metodo.
Quindi andiamo in playoff e aderiamo a un nuovo metodo chiamato public int at power e forniamo due valori
interi.
E poi abbiamo questa somma che viene inizializzata con zero.
Poi abbiamo alcuni uguali ad A più B e restituiamo alcuni OC.
Compiliamo questa applicazione e poi esaminiamola con lo strumento APK e confrontiamola
con l'esclusione commerciale.
Quindi andiamo a costruire l'APK.
Non abbiamo nemmeno bisogno di chiamare questo metodo, perché sarà decompilato o sarà compilato in quei
file smiley in seguito in questa classe di player.
A volte c'è qualche tipo di ottimizzazione di decompilazione che elimina i metodi non utilizzati, ma nel nostro caso dovremmo
essere a posto.
Ecco il nostro APK.
E rendiamo tutto più pulito.
Aggiungiamo quindi una nuova directory all'interno dell'applicazione.
In modo intelligente.
Registro di un metodo.
Rinominare i registri e lo strumento OC APK.
Tutti i registri di destra.
Sorriso.
Com.
Hacking.
Smiley 1 e 2.
Abbiamo la nostra classe di smiley per i giocatori.
Apriamo questo con il codice di Visual Studio.
Quindi apro questa cartella qui, poi entro in questa.
Chiudiamo questo?
Già.
Questo è il vecchio giocatore, Smiley.
Sì.
Quindi abbiamo chiuso questo e ora tracciamo il nuovo in questo.
E abbiamo visto che qui sotto c'è questo.
Questo è il nostro nuovo metodo.
Diamo un'occhiata a questo aspetto.
Pertanto, passiamo prima alla sintassi Java.
Diamo un'occhiata a questo aspetto.
Abbiamo un metodo pubblico chiamato power e non sappiamo cosa sia questo qui.
Questa è solo una distrazione per noi in questo momento.
Ne parleremo più avanti in una sezione separata.
Ma per ora non ci interessa.
Ok.
Poi, abbiamo questo spawn locale.
E questo è l'aspetto sorprendente dello strumento APK.
Lo strumento APK divide i registri in locali e parametri.
Apriamo quindi il codice sorgente e teniamolo accanto a noi per poi fare il confronto.
E quindi, permettetemi di aprire questo.
Ecco fatto.
Va bene.
Quindi abbiamo il nostro registro locale e il registro locale.
Nel nostro caso, è zero.
Possiamo trovare questo nome qui.
Qui e qui possono essere una sorta di segnaposto, ma anche un nome di variabile con il nostro codice Java.
Quindi, se si dà un'occhiata a questo, possiamo vedere che questo è in una variabile locale qui e che questo
è il nostro registro locale o è referenziato dal nostro registro locale V0.
Come facciamo a sapere che è così?
Possiamo trovare queste informazioni qui.
Inizia anche con il punto locale.
Quindi, facciamo questo da qui.
Qui.
Va bene.
Possiamo vedere.
Permettetemi di pulire rapidamente quei punti.
Ok.
Possiamo vedere.
Abbiamo il nostro registro locale.
Noi zero.
E questo è ora riferito da questa etichetta qui, in qualche modo.
Questo non ci interessa.
E ora sappiamo che questo registro locale che abbiamo azzerato è una variabile locale nel nostro
codice sorgente Java in questa funzione qui e questa variabile si chiama some.
Quindi some è referenziato da v zero come registro locale.
Va bene.
Quindi sappiamo cosa significa questo.
Poi abbiamo queste due linee.
Ci liberiamo di loro.
Ma ora possiamo vedere i parametri di questa funzione.
E abbiamo anche questa etichettatura accanto a loro.
Questo è l'aspetto positivo dello strumento APK che vediamo direttamente.
Ok, abbiamo una variabile locale in questo caso variabile, perché abbiamo questa etichetta qui e abbiamo
due parametri.
Quindi possiamo trovarli anche qui, p uno e p due.
L'etichetta relativa ai parametri ad essi allegati sempre in modo da poterli trovare direttamente qui.
Per quanto riguarda la variabile locale, dobbiamo andare nel codice sorgente e capire se si tratta di una variabile
locale o semplicemente di un ordine di posto.
Poi abbiamo questo qui.
Quindi segniamo rapidamente questo punto.
Questi sono chiari.
Sì.
Poi abbiamo questo qui.
E questo è molto bello.
È davvero bello.
Abbiamo questa riga nove e questa riga nove significa che possiamo andare nel codice sorgente originale di Java
e controllare cosa c'è alla riga nove e possiamo trovare questo qui.
Ecco fatto.
Non sappiamo quindi che cosa significhi questo concerto "slash something".
Ci liberiamo di questo.
Ma questo si riferisce all'istruzione che si trova alla riga nove del codice Java.
Quindi, se diamo un'occhiata al nostro codice Java, possiamo vedere direttamente cosa sta succedendo qui.
Abbiamo ottenuto che alcuni siano uguali a zero e questo è esattamente ciò che fa questa linea.
Sappiamo che lo zero è il nostro sole.
E possiamo anche vedere questo qui.
Zero zero è il valore esadecimale di zero.
Quindi.
E qui, avendo questo, possiamo cercare l'istruzione e capire cosa fa, oppure possiamo dare un'occhiata
al codice sorgente originale di Java.
Ma questi numeri di riga non sempre corrispondono.
Ad esempio, in questo caso, se apriamo l'applicazione in un browser, perché siamo degli hacker
e non abbiamo il codice sorgente, avremo un numero di riga diverso perché il compilatore ha fatto
un'ottimizzazione e non sta memorizzando questo valore in una variabile separata.
Sta semplicemente restituendo una classe P e quindi i numeri di riga non corrispondono.
Ma per quanto riguarda le applicazioni del mondo reale, direi che questi numeri di linea corrispondono almeno nel 90%
dei casi.
Quindi questi sono un ottimo indicatore.
Non sempre sono corretti o non sempre corrispondono alla parte corretta, ma il più delle volte lo sono.
E se facciamo sempre più pratica all'interno di Smiley, vediamo direttamente se queste linee corrispondono o se non corrispondono, ok,
quindi possiamo fare affidamento su di esse per la maggior parte del tempo.
E questo è molto bello, perché metterli uno accanto all'altro, ad esempio l'output di ogni sfumatura, o il testo
in caratteri e il codice degli smiley, rende l'intero processo di reverse engineering molto più semplice.
Ok.
Quindi sappiamo anche cosa significa questo.
Poi abbiamo la riga 11.
Diamo un'occhiata alla riga 11.
Possiamo anche vedere che saltiamo la riga dieci.
Super bello.
Quindi si tratta sempre di mantenere queste linee vuote.
È come avere il codice assembly con i simboli di debug, ma a mio parere è ancora meglio.
Così super bello OC.
Vediamo, alla riga 11, questa qui che possiamo vedere, stiamo aggiungendo questi due valori.
Ma OC, cioè, non sappiamo cosa significhi questo.
Questa istruzione qui, ne abbiamo già parlato.
Questo è il riferimento alla variabile locale nel nostro codice sorgente Java.
Questo.
Possiamo anche scriverlo nell'altro senso.
Noi zero fa riferimento ad alcuni.
Credo che questo sia più preciso a questo punto.
Va bene.
Quindi non sappiamo di più sull'annuncio nelle istruzioni.
Possiamo vedere che questi due valori vengono sommati, questi due parametri, e
poi vengono insegnati in qualche modo.
E questo è, ovviamente, ciò che fa questa istruzione.
Ma vogliamo concentrarci solo su questi registri.
E anche questo ci aiuta molto, perché dobbiamo dare un'occhiata a questo aspetto.
Possiamo vedere che abbiamo il nostro V0 qui, poi abbiamo P uno o il colore sbagliato.
P1 e abbiamo P2, quindi sappiamo che lo zero è la nostra somma.
Quindi ne conosciamo alcuni e sappiamo anche che P uno è la nostra etichetta A, la nostra variabile denominata A e a si trova qui lo stesso
per P due.
P due è pp2.
Quindi abbiamo anche p due e non sappiamo cosa fa questa istruzione, ma sappiamo che queste tre variabili sono coinvolte
in questa istruzione e questa è almeno un'informazione molto bella, anche se non possiamo leggere il
codice a sinistra, non è vero?
Purtroppo c'è un piccolo inconveniente, ma non è un vero problema.
Possiamo occuparcene noi.
Se in seguito si esegue il reverse engineering di un'applicazione, è necessario tenerne traccia.
Nella maggior parte dei casi, credo in tutti i casi, il parametro non cambia.
Quindi anche P one farà sempre riferimento a questa variabile, ma i nostri registri locali potrebbero essere riciclati.
Diciamo che stiamo usando la stessa variabile.
Allora abbiamo un sacco di codice sotto di esso e la variabile sum non verrà più utilizzata.
Quindi può accadere che il compilatore ricicli questo registro, che sia zero, e vi inserisca un nuovo
valore.
Quindi, all'inizio abbiamo capito: ok, abbiamo il nostro spawn locale.
Local spawn è una variabile reale nel nostro codice sorgente Java e qui stiamo restituendo questo valore.
Quindi non abbiamo parlato di questo.
Ma sì, diciamo che stiamo facendo qualcosa con questo, con questo registro qui.
Quindi può accadere che questo registro contenga qualcosa di diverso perché non verrà utilizzato nel
codice sorgente e nei registri dei nostri sorgenti che il compilatore vuole ottimizzare e riutilizzare.
E poi il compilatore dice, per esempio, ok, sto usando il registro zero per memorizzare un altro valore.
Ad esempio, il valore dieci.
E alla fine pensiamo: "Ok, stiamo facendo qualcosa con la variabile somma, ma stiamo facendo qualcosa
con il valore dieci".
E questo è un aspetto che dobbiamo tenere sotto controllo.
Al momento non sappiamo quale sia l'istruzione che modifica questo registro.
Quindi non possiamo saperlo al momento.
Vogliamo concentrarci anche su questi registri.
E ora, forse, mi sono addentrato un po' troppo in questo argomento, ma vorrei fornirvi il maggior numero di informazioni
possibili all'inizio, in modo che possiate imparare il più possibile.
Ok.
Spero che questo non sia troppo opprimente in questo momento.
Quindi, se in seguito si effettua il reverse engineering di un'applicazione, è sufficiente tenere traccia di questi registri.
Lo scriviamo semplicemente in questo modo.
Non sono più alcuni.
È ora, per esempio, numero e poi andremo a spostarci nel codice sorgente.
Va bene.
Abbiamo quindi parlato anche di questo.
E infine, alla riga 13, facciamo lo stesso.
Quindi raccolgo il mio colore rosso e poi diamo un'occhiata alla riga 13.
Non sappiamo cosa faccia realmente return, ma voglio dire, ok, questo è esattamente come nel nostro codice
Java.
Quindi return significa che stiamo tornando dalla funzione e che stiamo anche restituendo il valore memorizzato nel registro
che stiamo per restituire.
Nel nostro caso stiamo restituendo v zero e v zero contiene la nostra somma.
Non è cambiato.
Al momento si tratta di una funzione breve e il registro non è ancora stato riciclato.
Ma se avete una funzione più ampia, tenetene conto.
E sì, questo è tutto.
Non comprendiamo il codice smiley, ma se guardiamo il risultato in questo momento, anche solo sapendo
quali sono i registri, possiamo capire qualcosa.
Questa è un'ottima base su cui lavorare e d'ora in poi impareremo sempre di più sui codici smiley
up e cose del genere, e in poche sezioni sarete già pronti a capire il vostro primo programma
smiley completo, il che è davvero incredibile.
Ok.
Bello.
Torniamo alle diapositive e ricapitoliamo ancora una volta perché, ripetendo più volte,
imparerete molto più velocemente.
Ok, allora torniamo indietro.
Ok, eccoci di nuovo alle diapositive.
Diamo un'occhiata a questo aspetto.
Ho nascosto il codice sorgente Java e sì, parliamo prima di questo.
Quindi date un'occhiata al codice smiley e ignorate tutto il resto.
Concentratevi solo su ciò che abbiamo imparato in questo argomento del registro.
È possibile sapere quanti parametri e variabili locali abbiamo in questo momento in questa funzione?
E forse potete pensare a come appare nel codice sorgente di Java; questo potrebbe essere
un po' troppo impegnativo per me, quindi non preoccupatevi, non è necessario.
Ma per quanto riguarda la quantità di parametri e di variabili locali, sarebbe molto bello se si riuscisse
a scoprirlo.
Potete pubblicare questo video proprio ora e riflettere su questo punto e tra pochi secondi mi sposterò su questo punto.
Diamo quindi un'occhiata.
Ma torno e approfondiamo insieme la questione.
Quindi abbiamo questo qui.
Anche gli abitanti del luogo.
Questo significa che abbiamo due variabili locali e che possiamo vedere le etichette in basso.
Abbiamo una nuova etichetta, che è un fattore, e abbiamo le nostre etichette familiari.
Nel nostro codice Java abbiamo quindi un nuovo nome di variabile, che è vector.
Si tratta solo di un'ipotesi di massima per quanto riguarda i parametri.
Diamo un'occhiata: abbiamo ora p uno, p due e p tre.
Sembra che abbia aggiunto un nuovo parametro.
E la cosa divertente è che, se si guarda a questa linea di parentesi, si può anche vedere che c'è
stato un EI aggiuntivo in questa parentesi.
E sì, credo che possiamo risolvere la questione in questo momento e parlarne più dettagliatamente nella prossima sezione.
Questo è il tipo di parametro che forniamo qui e significa intero.
Quindi forniamo qui tre valori interi.
Ma questa è solo un'anteprima della prossima sezione.
Non ne abbiamo parlato e non mi aspettavo che identificaste anche questo tipo qui, ma sarebbe
molto bello se aveste identificato due variabili locali e tre parametri.
Tre, da questa parte.
Va bene.
Scusate se vi interrompo brevemente.
Non voglio confondervi, ma credo che dovremmo essere molto precisi su questo punto.
La linea tre punti individua due significa che abbiamo due registri locali con zero e uno.
E successivamente questi registri locali vengono assegnati alle variabili.
Questo è nella riga 12 e anche nella riga 20 decade.
Pertanto, in seguito possiamo parlare di variabili.
Ma all'inizio abbiamo solo due registri locali e questi registri locali possono essere anche dei segnaposto.
Quindi non devono essere assegnati a variabili locali.
Va bene.
Scusate l'interruzione, ma credo che questa dichiarazione sia molto importante in questo contesto.
Ora andiamo avanti.
Ok, diamo un'occhiata al codice sorgente Java.
Come si presenta?
Sì, ora abbiamo tre parametri e due variabili locali.
Uno è un fattore e l'altro è un po'.
Contrassegniamoli qui velocemente in modo da poter vedere: ok, noi zero e V uno.
Queste sono ora le nostre variabili locali e non devono essere distratte da tutto quello che c'è intorno alle nostre variabili
e ai nostri registri.
Impareremo a conoscere questo aspetto affrontando il capitolo sugli smiley.
Va bene.
Ok, ecco cosa volevo insegnarvi in questa sezione.
Abbiamo imparato qualcosa sui registri.
Sappiamo che si tratta di registri locali e di registri dei parametri.
E sappiamo anche che un registro contiene il nostro valore in caso di nome di una variabile o di un altro valore.
Ad esempio, il valore zero può essere mantenuto anche da un registro.
Il registro può essere modificato anche durante la funzione.
Quindi, se inizializziamo e registriamo all'inizio, come qui, ad esempio, inizializziamo lo
zero con due.
Non significa che il registro contenga ancora questo valore.
Due Al termine di questa funzione, il registro potrebbe essere riutilizzato, sovrascritto o potrebbe
essere oggetto di operazioni aritmetiche che ne modificano il valore.
Va bene.
Nella prossima sezione daremo un'occhiata ai tipi di dati e potremo capire già metà del
problema.
Quindi, non vedo l'ora di vedervi nella prossima sezione.