Ciao e bentornato. Vorrei fornire una dimostrazione una soluzione alla
nostra sfida precedente che aveva a che fare con la comprensione degli array di caratteri.
Principalmente, scriveremo funzioni per ottenere la lunghezza di una stringa, una funzione
per concatenare una stringa e una funzione per verificare se
due stringhe sono uguali.
Quindi creerò un progetto. Lo chiamerò solo per
capire le stringhe di caratteri.
E la prima cosa che faremo è implementare questa funzione di lunghezza.
Creeremo tre
dichiarazioni di funzione all'inizio.
Denomineremo la prima lunghezza di una stringa.
Useremo la custodia del cammello per la nostra denominazione.
Questo richiederà solo una stringa di caratteri costante.
Quindi come facciamo a sapere che è una stringa perché è un array di caratteri
e quindi metteremo un punto e virgola. Sarà il primo a creare, quindi per
ora ci fermeremo qui.
E creeremo questa funzione, definendola
di seguito in
modo che tu debba capire quella bella parola chiave const.
Const significa che è una stringa di caratteri che non può cambiare, non può essere modificata.
Il motivo per cui stiamo usando const
qui è perché non vogliamo modificare la stringa all'interno della
funzione, vogliamo semplicemente analizzarla e quindi restituire la lunghezza, restituire un numero intero.
Questa funzione è in realtà abbastanza facile da implementare perché stiamo solo esaminando un array.
Quindi possiamo effettivamente dire che il conteggio è
uguale a zero. Questa è una variabile locale.
Può essere utilizzato solo all'interno di questa funzione.
Ora potresti chiederti perché non possiamo usare la dimensione dell'operatore perché
la dimensione dell'operatore ci dirà la dimensione della stringa, non ci dirà quanti
caratteri ci sono all'interno di quella stringa.
Ma tutto ciò che dobbiamo fare è creare un
ciclo e scorrere l'array fino a quando non raggiungiamo il terminatore nullo.
Quindi possiamo guardare la nostra stringa. Possiamo dire wow
il conteggio delle stringhe non è uguale al terminatore nullo,
il terminatore nullo è rappresentato all'interno di un singolo
carattere come barra rovesciata zero.
E possiamo usare l'operatore non uguale perché confrontiamo con i caratteri.
E abbiamo solo una cosa nel corpo di questa istruzione while più
plus count, solo incrementando count.
E poi vogliamo restituirlo, diciamo solo return count e il gioco è fatto.
Questa è l'intera funzione di lunghezza della stringa. È abbastanza semplice perché la stringa
di caratteri si trova all'interno di un array
e la stringa termina con un terminatore nullo.
Quindi, per testare questo, possiamo iniziare
il nostro metodo principale e possiamo
creare alcuni caratteri costanti, basta
dire una parola
Jason.
Quindi è così che crei un array di caratteri in c.
Non devi avere la costante lì, ma questa non viene modificata.
Usa la parola chiave char, il tipo di dati char, l'identificatore e poi le parentesi.
È meglio non specificare la dimensione tra parentesi perché il
compilatore c aggiungerà automaticamente un terminatore nullo.
E poi, subito dopo
l'operatore di assegnazione, inserisci la stringa letterale tra virgolette doppie.
Ne creeremo un paio qui per assicurarci che funzioni.
Possiamo visualizzare le stringhe di caratteri molto facilmente perché possiamo semplicemente usare il
simbolo della percentuale s, tranne che ciò che vogliamo veramente visualizzare qui
sono le lunghezze. Quindi useremo la
percentuale d.
Quindi stamperemo solo i collegamenti di queste tre
stringhe, percentuale de avremo solo alcuni spazi in mezzo e quindi aggiungeremo
un avanzamento riga.
E questo chiamerà la funzione di lunghezza della stringa per ogni
parola, piuttosto semplice
qui, e questo è tutto. Quindi ora possiamo creare e testare e vedere se funziona davvero.
Quello che dovremmo vedere come output è che dovremmo vedere
la lunghezza di Jason che è 5, la lunghezza di okay che è 2 e
la lunghezza di qualunque cosa sembri essere circa 8.
Quindi qui abbiamo 5, 2 e 8, che sembra giusto.
Ecco come puoi scrivere una lunghezza di stringa. Passiamo alla funzione di concatenazione.
La funzione di
concatenazione prenderà solo tre stringhe e due costanti.
E questo non restituirà nulla. Metterà solo la
stringa risultante nel primo parametro.
Quindi lo chiameremo concat. Avremo un
risultato e avremo due stringhe,
una che vogliamo concatenarne due e poi una che vogliamo
avere solo una singola stringa. Quindi chiameremo la stringa uno, la stringa due.
E ci siamo. E questa è la nostra dichiarazione di funzione.
Quindi possiamo usarlo ovunque prima che sia definito.
Anche questo dovrà passare attraverso l'array. Dovrà solo passare attraverso due
array e mentre li esaminiamo aggiungere alla stringa risultante.
Creeremo un paio di variabili locali, che possiamo usare solo all'interno di questa funzione,
int I e j.
E poi useremo un ciclo for
per scorrere l'array. Diremo che io è uguale a 0.
Str sub 1 o sub dovrei dire non è
uguale al terminatore nullo e
quindi incrementa anche I.
Abbiamo familiarità con la nostra sintassi
del ciclo for in cui abbiamo l'identificatore del ciclo come prima cosa.
Prima del primo punto e virgola, la condizione in cui si salta prima del
secondo punto e virgola e quindi
si modifica la variabile di controllo del ciclo per assicurarsi di non avere un ciclo infinito.
Tutto quello che facciamo qui è salvare i
risultati, sub I è uguale a str uno sub I.
Ricorda, questi sono caratteri, quindi è perfettamente corretto usare qui i compiti uguali.
Non possiamo farlo negli array
di caratteri perché negli array di caratteri non è possibile assegnare array a un array.
Dovremmo usare una copia str.
Quindi sta copiando la prima stringa.
E ora vogliamo concatenare la seconda stringa
ai risultati, quindi faremmo qualcosa di molto molto simile tranne che
guarderemo nel secondo array e ci assicureremo di metterlo nel posto giusto nel risultato.
Quindi faremmo qualcosa del genere. Andremmo da j a
zero, str a j non è uguale al terminatore nullo ++ j.
E vedrai che il risultato sta solo dicendo io più j, quindi qualunque cosa ho finito con.
Se ho aggiunto dieci caratteri, ora inizierà
da quel decimo carattere perché è a base zero e
aggiungerà solo j, quindi 10 più 0, 10 più 1 e così via.
E questo è tutto.
Un'ultima cosa che devi fare che è davvero importante è che devi aggiungere quel terminatore nullo.
Quindi vogliamo dire risultato, io più j e quindi aggiungere un
singolo carattere, il terminatore nullo, che è
la barra rovesciata zero all'interno di una singola virgoletta.
E questa è la nostra funzione.
Non dobbiamo restituire nulla da questa funzione
perché stiamo solo copiando in str uno in str due.
Quindi proviamo questo.
Quello che mi aspetto di poter fare su questo è testarlo con un paio di personaggi.
Useremo i personaggi esistenti che abbiamo e ne
concateneremo solo un paio.
Quindi dobbiamo creare un altro
risultato. Quindi diremo
solo risultato solo per cancellarlo.
Qui, diremo che dovremo
specificare una dimensione per quella prima.
Quindi specificheremo solo una dimensione di 50. Lo limiteremo.
Quindi questi personaggi costanti dovrebbero funzionare.
Ora diremo solo printf,
stamperemo una stringa.
Quindi diremo percent s e poi diremo concat, che
è come l'abbiamo chiamato. Trasmetteremo i risultati e
poi la parola uno e la parola due.
Quindi cosa dovrebbe mostrare come output,
e ci assicureremo di metterlo su un paio di nuove righe.
Questo dovrebbe essere visualizzato come output Jason okay. Quindi concat in realtà non restituisce alcun dato,
quindi non posso metterlo direttamente in printf.
Quello che devo fare è chiamarlo e quindi visualizzare il risultato.
Quindi ci chiamiamo concat.
Tutto viene inserito nel risultato e noi visualizziamo il risultato.
Quindi, di nuovo, quando eseguiamo questo, dovremmo
vedere Jason bene e lo facciamo.
La terza funzione
che vogliamo implementare è una funzione di confronto per verificare se due stringhe sono uguali.
Questa funzione dovrebbe restituire un valore booleano.
Quindi vogliamo includere il nostro bool standard.
Quindi possiamo usare valori booleani e veri e falsi.
E questo sarà effettivamente definito come stringhe uguali.
Questo richiederà un array di caratteri costante, s1 e un
altro per verificare se due
stringhe sono uguali.
Solo per assicurarmi di aver incluso l'intestazione giusta, proverò a crearla e
penso di averlo fatto perché così ora sono in grado
di usare la parola chiave bool perché l'ho inclusa e posso anche usare true false.
Quindi implementiamo queste stringhe uguali.
Questo sarà più o meno
lo stesso solo attraversando l'array e controllando ogni carattere.
Quindi creeremo un paio
di variabili locali che è uguale a 0 per il nostro ciclo inizializzato 0.
In un booleano, ci dice
solo se sono uguali perché questo è ciò che restituiremo, qualcosa come è uguale. E potremmo effettivamente inizializzarlo su false.
Quello che vogliamo fare prima in realtà è che vogliamo ottenere il conteggio.
Vogliamo vedere quanto sono grandi
entrambi. Quindi possiamo avere un ciclo
while perché abbiamo bisogno del conteggio per guardare le
dimensioni fondamentalmente per controllare solo
quella terminazione nulla.
Quindi assumeremo che le stringhe che passiamo abbiano le stesse dimensioni.
Quindi possiamo scrivere un semplice ciclo while. Potresti anche scrivere dichiarazioni if.
In un certo senso ho incorporato tutto
in un ciclo while sono i miei confronti utilizzando gli operatori logici.
Non è necessario utilizzare operatori logici. Potresti usare un'istruzione if e semplicemente passare
attraverso l'intera seconda stringa.
Ma qui quello che ho fatto è che ho detto
mentre s1 sub I è uguale a uguale a s2
sub I e non sono uguali a terminatori nulli.
Perché se sono uguali a
terminatori nulli, vogliamo saltare se uno dei due è un terminatore nullo.
Quindi ora diciamo più più I. E poi l'ultima cosa che dobbiamo fare è
controllare se si tratta di terminatori nulli. E se lo sono, puoi impostare la tua variabile
booleana per restituire i dati corretti.
Quindi qui possiamo dire se s1 sub I è uguale
a un terminatore nullo e s2
sub è uguale a un terminatore nullo, impostare la nostra variabile
booleana è uguale a e poi vogliamo restituirlo.
E poi dì solo che il ritorno è uguale.
E per verificarlo, dovremo testare una buona stringa e una cattiva stringa.
Quindi andiamo avanti e diciamo stringhe uguali.
Stamperò solo il valore intero del booleano, quindi
percento d e diremo stringhe uguali qui, questo restituisce qualcosa in modo
che possiamo metterlo
nell'espressione di stampa uguale a stringa. Voglio solo assicurarmi che le
stringhe siano
uguali e poi passeremo Jason virgola Jason.
E lo chiameremo e questa
volta diremo Jason's.
E il primo dovrebbe restituire uno, il secondo per
restituire zero, uno rappresenta vero, zero rappresenta falso.
Quando eseguiamo questo, vediamo uno e
zero. Uno per vero e zero per falso tranne
che è difficile da leggere perché non abbiamo un avanzamento riga. Quindi aggiungiamo un avanzamento riga
e solo per mostrartelo di nuovo.
Ora vediamo uno zero,
vero falso. Jason Jason è uguale l'uno all'altro.
Jason's Jason non è uguale.
Quindi queste sono alcune funzioni
rapide da cui ora puoi imparare, imparare fondamentalmente sugli array di caratteri e
su come le stringhe sono rappresentate con questo concetto.
Grazie. Fornirò anche il file sorgente, in modo che tu possa esaminarlo in modo più dettagliato.
Si spera che questo ti abbia aiutato con il tuo incarico.