Normalmente quando vedo il codice pubblicato qui come il tuo, lo modifico, perché odiamo lo scroll orizzontale. Ma dal momento che fa parte della tua domanda, ti mostrerò la modifica qui:
int extractMessage(char keyWord[25], char cipherText[17424],
int rowSize, char message[388])
{
int keyColumn = 0;
int cipherColumn = 0;
int offset = 1;
int nextWord = 1;
int lengthOfWord = 0;
int lengthOfCipher = 0;
lengthOfWord = length(keyWord);
lengthOfCipher = length(cipherText);
while (keyWord[keyColumn] != cipherText[cipherColumn]) {
cipherColumn++;
if (keyWord[keyColumn + offset]
!= cipherText[cipherColumn + (rowSize*nextWord) + nextWord]) {
cipherColumn++;
continue;
}
}
}
Questa interruzione potrebbe sorprendere, ma è più leggibile rispetto alla versione con scorrimento orizzontale, ed è meglio che abbreviare i nomi a i , j e k .
Non è che non dovresti mai usare i , j e k . Si tratta di nomi fini quando si indicizzano 3 cicli nidificati for . Ma qui i nomi sono davvero il mio unico indizio su cosa ti aspettavi che accadesse. Soprattutto perché questo codice in realtà non fa nulla.
La migliore regola da seguire sulla lunghezza del nome della variabile è l'ambito. Più una variabile è lunga, più variabili con cui il nome deve competere. Il nome CandiedOrange è unico nello scambio di pile. Se fossimo in una chat, potresti chiamarmi semplicemente "Candy". Ma al momento, sei in un ambito in cui quel nome potrebbe essere confuso con Candido , Candy Chiu o Candyfloss . Più lungo è il raggio d'azione, più lungo dovrebbe essere il nome. Più corto è lo scope, più breve è il nome.
La lunghezza della linea dovrebbe mai dettare la lunghezza del nome. Se ritieni che sia quindi trovare un modo diverso di disporre il codice. Abbiamo molti strumenti per aiutarti a farlo.
Una delle prime cose che cerco è il rumore inutile da eliminare. Sfortunatamente questo esempio non fa nulla, quindi è tutto rumore inutile. Ho bisogno di qualcosa su cui lavorare, quindi prima facciamolo fare qualcosa.
int calcCipherColumn(char keyWord[25], char cipherText[17424],
int rowSize, char message[388])
{
int keyColumn = 0;
int cipherColumn = 0;
int offset = 1;
int nextWord = 1;
int lengthOfWord = 0;
int lengthOfCipher = 0;
lengthOfWord = length(keyWord);
lengthOfCipher = length(cipherText);
while (keyWord[keyColumn] != cipherText[cipherColumn]) {
cipherColumn++;
if (keyWord[keyColumn + offset]
!= cipherText[cipherColumn + (rowSize*nextWord) + nextWord]) {
cipherColumn++;
continue;
}
}
return cipherColumn;
}
Ecco, ora fa qualcosa.
Ora che fa qualcosa, posso vedere di cosa posso sbarazzarmi. Questa roba di lunghezza non è nemmeno usata. Anche questo continue non fa nulla.
int calcCipherColumn(char keyWord[25], char cipherText[17424],
int rowSize, char message[388])
{
int keyColumn = 0;
int cipherColumn = 0;
int offset = 1;
int nextWord = 1;
while (keyWord[keyColumn] != cipherText[cipherColumn]) {
cipherColumn++;
if (keyWord[keyColumn + offset]
!= cipherText[cipherColumn + (rowSize*nextWord) + nextWord]) {
cipherColumn++;
}
}
return cipherColumn;
}
Facciamo qualche piccolo aggiustamento dello spazio bianco, perché viviamo in un mondo di controllo del codice sorgente ed è bello quando l'unica ragione per cui una riga viene segnalata come modificata è perché sta facendo qualcosa di diverso, non perché una parte di essa doveva allinearsi in una colonna.
int calcCipherColumn(char keyWord[25], char cipherText[17424],
int rowSize, char message[388])
{
int keyColumn = 0;
int cipherColumn = 0;
int offset = 1;
int nextWord = 1;
while (keyWord[keyColumn] != cipherText[cipherColumn]) {
cipherColumn++;
if (keyWord[keyColumn + offset]
!= cipherText[cipherColumn + (rowSize*nextWord) + nextWord]) {
cipherColumn++;
}
}
return cipherColumn;
}
Sì, lo so che è leggermente meno leggibile, ma altrimenti farai impazzire la gente che usa gli strumenti di vdiff per rilevare i cambiamenti.
Ora risolviamo queste sciocche interruzioni di linea che abbiamo perché stiamo cercando di rimanere al di sotto dei limiti di lunghezza della linea.
int calcCipherColumn(
char keyWord[25],
char cipherText[17424],
int rowSize,
char message[388]
) {
int keyColumn = 0;
int keyOffset = 1;
int nextWord = 1;
int cipherColumn = 0;
int cipherOffset = (rowSize * nextWord) + nextWord;
char key = keyWord[keyColumn];
char keyNext = keyWord[keyColumn + keyOffset];
while (key != cipherText[cipherColumn]) {
cipherColumn++;
if (keyNext != cipherText[cipherColumn + cipherOffset]) {
cipherColumn++;
}
}
return cipherColumn;
}
Ecco, ora la logica nel ciclo è focalizzata su quali cambiamenti nel ciclo. Infatti, tutto tranne cipherColumn potrebbe essere contrassegnato come final . Ehi! Guarda quello. Ora abbiamo spazio per farlo.
Tutto ciò che ho fatto è stato aggiungere altre 3 variabili, rinominarne una e riorganizzarle un po '. E il risultato è appena accaduto per rendere le linee abbastanza corte per adattarsi senza una stupida interruzione di riga su != .
Sicuramente i nomi key e keyNext non sono così descrittivi, ma vengono usati solo una volta, non vivono a lungo e, cosa più importante, non fanno nulla di interessante nel ciclo. Quindi non hanno bisogno di essere. Introducendo variabili extra ora abbiamo spazio per rendere i loro nomi lunghi se necessario. Le cose cambiano, quindi alla fine potremmo aver bisogno di farlo. Se lo facciamo, è bello che abbiamo il respiro.
Mi sono anche preso la libertà di mostrarti la variante di forma 6 di Jeff Grigg per definire i parametri di input in modo da rispettare le restrizioni sulla lunghezza della linea.