As atribuições na condição fazem parte de condicionais uma má prática?

Vamos supor que eu queira escrever uma função que concatene duas seqüências de caracteres em C. A maneira como eu a escreveria é:

void concat(char s[], char t[]){
    int i = 0;
    int j = 0;

    while (s[i] != '\0'){
        i++;
    }

    while (t[j] != '\0'){
        s[i] = t[j];
        i++;
        j++;
    }

    s[i] = '\0';

}

No entanto, a K&R em seu livro a implementou de maneira diferente, particularmente incluindo o máximo possível na parte de condição do loop while:

void concat(char s[], char t[]){
    int i, j;
    i = j = 0;
    while (s[i] != '\0') i++;

    while ((s[i++]=t[j++]) != '\0');

}

Qual o caminho preferido? É encorajado ou desencorajado a escrever código da maneira que a K&R faz? Acredito que minha versão seria mais fácil de ser lida por outras pessoas.

Sempre prefira clareza a esperteza. Nos últimos anos, o melhor programador era aquele cujo código ninguém podia entender. "Não consigo entender o código dele, ele deve ser um gênio" , disseram eles. Atualmente, o melhor programador é aquele cujo código qualquer um pode entender. O tempo do computador é mais barato agora do que o tempo do programador.

Qualquer tolo pode escrever código que um computador possa entender. Bons programadores escrevem código que os humanos podem entender. (M. Fowler)

Portanto, sem dúvida, eu optaria pela opção A. E essa é a minha resposta definitiva.

A regra de ouro, igual à da resposta de Tulains Córdova, é garantir que o código seja inteligível. Mas eu não concordo com a conclusão. Essa regra de ouro significa escrever um código que o programador típico que acabará mantendo o seu código possa entender. E você é o melhor juiz de quem é o programador típico que acabará mantendo o seu código.

Para os programadores que não começaram com C, a primeira versão é provavelmente mais fácil de entender, por razões que você já conhece.

Para aqueles que cresceram com esse estilo de C, a segunda versão pode ser mais fácil de entender: para eles, é igualmente compreensível o que o código faz, para eles, deixa menos perguntas por que está escrito do jeito que está e para eles. , menos espaço vertical significa que mais contexto pode ser exibido na tela.

Você terá que confiar no seu próprio bom senso. Para qual público você deseja tornar seu código mais fácil de entender? Esse código foi escrito para uma empresa? Então o público-alvo provavelmente são os outros programadores dessa empresa. Esse é um projeto de hobby pessoal em que ninguém trabalhará além de você? Então você é seu próprio público-alvo. Esse código você deseja compartilhar com outras pessoas? Então esses outros são o seu público-alvo. Escolha a versão que corresponde a esse público. Infelizmente, não existe uma maneira preferida única de incentivar.

EDIT: A linha s[i] = '\0';foi adicionada à primeira versão, corrigindo-a como descrito na variante 1 abaixo, portanto, isso não se aplica mais à versão atual do código da pergunta.

A segunda versão tem a vantagem distinta de estar correta , enquanto a primeira não está - ela não encerra a seqüência de destino corretamente.

A "atribuição em condição" permite expressar o conceito de "copiar todos os caracteres antes de verificar o caractere nulo" de maneira muito concisa e de maneira a facilitar um pouco a otimização para o compilador, embora muitos engenheiros de software hoje em dia achem esse estilo de código menos legível . Se você insistir em usar a primeira versão, terá que

1. adicione a terminação nula após o final do segundo loop (adicionando mais código, mas você pode argumentar que a legibilidade vale a pena) ou
2. altere o corpo do loop para "primeiro atribua, verifique ou salve o caractere atribuído e depois incremente os índices". Verificar a condição no meio do loop significa sair do loop (reduzindo a clareza, desaprovada pela maioria dos puristas). Salvar o caractere atribuído significaria introduzir uma variável temporária (reduzindo a clareza e a eficiência). Ambos aniquilariam a vantagem na minha opinião.

As respostas de Tulains Córdova e hvd cobrem muito bem os aspectos de clareza / legibilidade. Deixe-me mencionar o escopo como outra razão a favor de atribuições em condições. Uma variável declarada na condição está disponível apenas no escopo dessa instrução. Você não pode usar essa variável posteriormente por acidente. O para circuito vem fazendo isso há muito tempo. E é importante o suficiente que o próximo C ++ 17 introduza uma sintaxe semelhante para if e switch :

if (int foo = bar(); foo > 42) {
    do_stuff();
}

foo = 23;   // compiler error: foo is not in scope

Não. É um estilo C muito padrão e normal. Seu exemplo é ruim, porque deveria ser apenas um loop for, mas em geral não há nada errado com

if ((a = f()) != NULL)
    ...

por exemplo (ou com while).

Nos dias de K&R

• 'C' era código de montagem portátil
• Foi usado por programadores que pensavam em código de montagem
• O compilador não fez muita otimização
• A maioria dos computadores tinha "conjuntos de instruções complexos", por exemplo while ((s[i++]=t[j++]) != '\0'), mapearia para uma instrução na maioria das CPUs (espero que o VAC de dezembro)

Há dias

• A maioria das pessoas que lê o código C não é programadora de código de montagem
• Os compiladores C fazem muita otimização; portanto, o código mais simples de ler provavelmente será traduzido no mesmo código de máquina.

(Uma observação sobre o uso sempre de chaves - o primeiro conjunto de códigos ocupa mais espaço devido a algumas informações "desnecessárias" {}. Na minha experiência, isso geralmente impede o código mal mesclado do compilador e permite que erros com posicionamentos ";" incorretos sejam detectado por ferramentas.)

No entanto, nos velhos tempos, a segunda versão do código teria lido. (Se eu entendi direito!)

concat(char* s, char *t){      
    while (*s++);
    --s;
    while (*s++=*t++);
}

Mesmo sendo capaz de fazer isso é uma péssima idéia. É coloquialmente conhecido como "O último erro do mundo", assim:

if (alert = CODE_RED)
{
   launch_nukes();
}

Embora não seja provável que você cometa um erro tão grave, é muito fácil errar acidentalmente e causar um erro difícil de encontrar na sua base de código. A maioria dos compiladores modernos inserirá um aviso para atribuições dentro de uma condicional. Eles estão lá por uma razão, e você faria bem em atendê-los e apenas evitar essa construção.

Ambos os estilos são bem formados, corretos e apropriados. Qual é o mais apropriado depende em grande parte das diretrizes de estilo da sua empresa. Os IDEs modernos facilitarão o uso de ambos os estilos através do uso de fiapos de sintaxe ao vivo que destacam explicitamente áreas que de outra forma poderiam se tornar uma fonte de confusão.

Por exemplo, a seguinte expressão é destacada pelo Netbeans :

if($a = someFunction())

com base em "atribuição acidental".

Para dizer explicitamente ao Netbeans que "sim, eu realmente pretendia fazer isso ...", a expressão pode ser colocada em um conjunto de parênteses.

if(($a = someFunction()))

No final do dia, tudo se resume às diretrizes de estilo da empresa e à disponibilidade de ferramentas modernas para facilitar o processo de desenvolvimento.