Como NÃO não programar

[comonaonaoprogramar]

Como NÃO não limitar o tamanho de uma string em C

Por convenção, strings em C são terminadas pelo caractere de código 0, também chamado caractere nulo ou, apropriadamente, terminador (não confunda com o caractere que representa o dígito zero, cujo código é 48). Neste post, o programador usou a função strlen para determinar o tamanho da string e fechá-la com o caractere 0. O problema é que ele provavelmente não sabia como a função strlen funciona. Veja abaixo uma implementação bem simples desta função, que segue o padrão oficial:

int strlen(const char *str) { const char *p = str; int size = 0; while (*p++ != 0) size++; return size; }

Note que a função usa o próprio caractere nulo para determinar o tamanho da string. Dessa forma, o código x[strlen(x)] = 0 é redundante, não tem efeito.

[comonaonaoprogramar]

Como NÃO não iterar em uma lista STL

Neste post, vemos que o programador encontrou uma solução criativa para iterar sobre os elementos de uma lista STL, possivelmente decorrente de um desconhecimento do funcionamento dos iteradores desta biblioteca.

Veja abaixo um exemplo de uso dos iteradores STL:

#include <iostream> #include <list> #include <iterator> using namespace std; int main() { list<int> lst; lst.push_back(1); lst.push_back(2); lst.push_back(3); for (list::iterator i = lst.begin(); i != lst.end(); i++) cout << *i << endl; return 0; }

As funções begin() e end() retornam iteradores que agem como ponteiros para os objetos dentro da lista. Para todos os efeitos, eles podem ser usados como ponteiros. Por exemplo, usando o operador de dereferenciação * obtemos o elemento da posição correspondente e o operador de pós-incremento ++ é usado para avançar o iterador para o próximo elemento da lista. O operador de comparação == retorna true quando os dois iteradores apontam para o mesmo elemento dentro da lista. Assim sendo, o exemplo do post citado acima poderia ser reescrito da seguinte forma:

list lst; for (list::iterator i = lst.begin(); i != lst.end(); i++) { /* ... do something with *i ... */ }

[comonaonaoprogramar]

Simplificar operadores ternários

Uma das coisas que me incomoda muito em programação Java/C/C++/C# é o uso do operador ternário com valores booleanos. Na maioria das vezes isso é redundante, torna o código mais difícil de ler e pode ser facilmente substituído por uma expressão booleana mais simples que também tem a vantagem de ser branch-free em algumas linguagens, isto é, não exigem que a CPU selecione um caminho de execução baseado em uma condição, o que pode ser muito custoso. Os melhores compiladores vão otimizar estas expressões de forma similar à que vou descrever abaixo, mas eles não melhoram a legibilidade do código.

Daqui em diante vou usar a sintaxe de código Java/C/C++/C#. Uma expressão booleana é qualquer expressão válida que resulta em um valor booleano. Isto pode ser qualquer coisa desde as constantes true e false até expressões complexas como x == 1 && (y > 3 || z <= 1.25) && !verificarAlgo(x, y, z) (presumindo que verificarAlgo(...) retorne um valor booleano).

Suponha que você tem a condição c e as expressões booleanas p e q. A seguinte tabela contém todas as possíveis conversões de uma expressão ternária para uma expressão booleana equivalente:

# Expressão Ternária Expressão if-then-else Equivalente a 1 c ? p : q if (c) p else q (c && p) || (!c && q) 2 c ? p : true if (c) p else true !c || p 3 c ? p : false if (c) p else false c && p 4 c ? true : p if (c) true else p c || p 5 c ? false : p if (c) false else p !c && p 6 c ? true : false if (c) true else false c 7 c ? false : true if (c) false else true !c 8 c ? true : true if (c) true else true true 9 c ? false : false if (c) false else false false

Note que #1 pode ou não resultar em código mais legível; provavelmente é melhor usar o operador ternário neste caso. #6 até #9 são más práticas de programação e devem ser substituídas imediatamente pelas expressões booleanas equivalentes. #2 até #5 requerem atenção e quase sempre resultarão em código melhor e mais legível.

Note também que b = c ? p : q é equivalente a if (c) b=p else b=q. Em outras palavras, sempre que houver atribuição a quaisquer variáveis booleanas cujo valor depende da condição da cláusula if-then-else, este valor pode ser simplificado de acordo com a tabela de equivalência acima, desde que não haja efeitos colaterais indesejados.

[comonaonaoprogramar]

Como NÃO não confiar nos tipos estáticos

Vamos analisar o trecho de código deste post:

// getFlag() retorna um Boolean if (getFlag() == true) { putRequestAttribute("flag", true); } else { putRequestAttribute("flag", false); }

Primeiro de tudo: em Java, comparar um boolean com true ou false em uma condição if é desnecessário. Se você quer true, simplesmente use a expressão booleana por si só. Se você quer false, use o operador de negação lógica !.

Desde o Java 1.5, valores primitivos são automaticamente encapsulados nos objetos e vice-versa. Como o método getFlag() retorna um objeto Boolean, este será automaticamente convertido para a primitiva boolean.

O método putRequestAttribute(String, Object) insere um atributo no ServletRequest do contexto atual. Ou seja, do jeito que o código está escrito, é feita a conversão de objeto para primitiva na condição if, e de primitiva para objeto na invocação do método, desperdiçando processamento e memória. Nada muito grave nesse caso, mas se fosse dentro de um loop poderia causar problemas de performance.

O código todo poderia ser simplificado da seguinte forma:

putRequestAttribute("flag", getFlag());

o que economiza várias linhas de código e evita as duas auto-conversões entre primitiva e objeto.