Normalmente, quando vejo código publicado aqui como o seu, edito-o, porque odiamos a rolagem horizontal. Mas como isso faz parte da sua pergunta, mostrarei a edição aqui:
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;
}
}
}
Essa pausa pode ser surpreendente, mas é mais legível do que a versão com rolagem horizontal, e é melhor do que encurtar os nomes de i
, j
e k
.
Não é que você nunca deve usar i
, j
e k
. Esses são nomes bons ao indexar 3 for
loops aninhados . Mas aqui os nomes são realmente minha única pista sobre o que você esperava que estivesse acontecendo. Especialmente porque esse código não faz nada.
A melhor regra a seguir no tamanho do nome da variável é o escopo. Quanto maior a vida de uma variável, mais variáveis variáveis o seu nome deve competir. O nome CandiedOrange é exclusivo na troca de pilhas. Se estivéssemos em uma conversa, você poderia me chamar de "doce". Mas agora, você está em um escopo em que esse nome pode ser confundido com Candide , Candy Chiu ou Candyfloss . Portanto, quanto maior o escopo, maior o nome. Quanto menor o escopo, menor o nome.
O comprimento da linha nunca deve ditar o comprimento do nome. Se você achar que é, encontre uma maneira diferente de definir seu código. Temos muitas ferramentas para ajudá-lo a fazer isso.
Uma das primeiras coisas que procuro é barulho desnecessário para me livrar. Infelizmente, este exemplo não faz nada, por isso é um ruído desnecessário. Eu preciso de algo para trabalhar, então primeiro vamos fazer alguma coisa.
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;
}
Lá, agora faz alguma coisa.
Agora que faz alguma coisa, posso ver do que posso me livrar. Esse material de comprimento nem é usado. Isso continue
também não faz nada.
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;
}
Vamos fazer alguns ajustes menores no espaço em branco, porque vivemos em um mundo de controle de origem e é bom quando a única razão pela qual uma linha é relatada como alterada é porque ela está fazendo algo diferente, não porque parte dela teve que se alinhar em uma coluna.
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;
}
Sim, eu sei que é um pouco menos legível, mas, caso contrário, você enlouquecerá as pessoas que usam as ferramentas vdiff para detectar alterações.
Agora vamos corrigir essas quebras de linha tolas que temos, porque estamos tentando permanecer abaixo dos limites de comprimento de linha.
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;
}
Agora, a lógica do loop está focada no que muda no loop. De fato, tudo, exceto cipherColumn
poderia ser marcado final
. E ei! Olhe para isso. Agora temos espaço para fazê-lo.
Tudo o que fiz foi adicionar mais 3 variáveis, renomear uma e reorganizá-las um pouco. E o resultado aconteceu para tornar as linhas curtas o suficiente para caber sem quebras de linha !=
.
Claro que os nomes key
e keyNext
não são tão descritivos, mas cada um deles é usado apenas uma vez, não dura tanto tempo e, o mais importante, não está fazendo nada tão interessante no circuito. Então eles não precisam ser. Ao introduzir variáveis extras, agora temos espaço para prolongar seus nomes, se necessário. As coisas mudam, então, eventualmente, podemos precisar. Se o fizermos, é bom termos espaço para respirar.
Também tomei a liberdade de mostrar a você o estilo variante de Jeff Grigg, no formato 6 , de definir parâmetros de entrada para respeitar as restrições de comprimento de linha.
cipherColumn + (rowSize*nextWord) + nextWord
a deixar claro o que esse cálculo é de , por exemplo? Aposto que esse nome é mais curto que o cálculo, então você obtém um benefício de legibilidade e um comprimento de linha reduzido. Além disso, não alinhe as atribuições ou precisará movê-las todas se renomear a variável mais longa.