ASM51

Alguém aqui gostou dos novos recursos do C++11 ?

Eu não gostei do seguinte:
expressões lambda (acho que eu num entendi direito pra que vai servir)
tipos automáticos (esse eu num gostei mesmo, mas pode facilitar a vida de muita gente)

o que eu achei interessante foram:
implementações de threads ( mas num sei ainda como usa, apenas li)
tipos atômicos.
suporte a unicode (pelo que eu vi já tem nativo as rotinas de conversão).
controle do alinhamento de memória.
poder inicializar vetores de forma automática ao invés de um monte de push_back()
tipo nullptr ( esse acho que vai ajudar muito )


e vocês?

passa o link que voce leu para o pessoal opinar...

Li em vários sites, pesquisei no google: "C++11 new features" link:

https://www.google.com.br/search?source ... 20features

São recursos interessantes, quase necessários, embora vários deles (threads e construções atômicas) já fossem mais ou menos previstos. Bem, alguém pode argumentar que multitarefa precisaria necessariamente ser parte da linguagem (há estudos apontando neste sentido) para que se atinja o melhor da escalabilidade, construções atômicas sendo algo positivo neste sentido, pois threads da maneira como são usadas tem aplicabilidade limitada (http://web.stanford.edu/~ouster/cgi-bin/papers/threads.pdf), etc.

A questão é que eu não sei se foi dado um ponto positivo em C++ rumo a extrapolar estas limitações ou se simplesmente foram adotadas técnicas já tradicionais de programação que ao final das contas resultam em threads e locks.

Mas o que eu queria comentar mesmo é que quanto as construções de linguagem, honestamente, toda vez que implementam algo novo em C++, eu vejo nascer um novo monstro de sete cabeças. A linguagem perdeu muito da simplicidade e elegância que C tinha. Eu não gosto de Objective C, mas até sua sintaxe alienígena parece mais legível pra mim do que alguns códigos em C++ modernos. Tudo bem que sintaxe não tem influência direta sobre a qualidade do código gerado, mas a "readability" (como traduz isso pra português?) é essencial para trabalhar com múltiplas equipes (ou mesmo pra você revisar aquele projeto de anos atrás sem dizer "quem foi o tosco que escreveu isso? ah, fui eu mesmo"). Uma linguagem que tenda a simplicidade faz com que você não precise ter manuais de boas práticas de 500 páginas. Uma linguagem que tenda ao caos precisará de um manual de 500 páginas, isto tem impacto nos custos de desenvolvimento, em C eu coloco um estagiário para fazer 70% do que eu faço em não mais do que 90 dias de treinamento in house, em C++ tenho que pagar um curso pro cara e esperar ele aprender algo antes de mandá-lo para a mina de carvão.

Eu concordo que tem programas escritos em C++ que são ridículos pela abordagem que o cara usa para resolver coisas simples, veja um exemplo:


Veja o que o cara sugeriu para converter um int para um BCD:
stackoverflow.com/questions/1408361/decimal-to-bcd-conversion
cpp code

#include <algorithm>
#include <vector>

template <class Uint>
std::vector<unsigned char> bcd(Uint x) {  
  std::vector<unsigned char> ret;
  if (x==0) ret.push_back(0); 
  // skip the above line if you don't mind an empty vector for "0"
  while(x>0) {
    Uint d=x/10;
    ret.push_back(x-(d*10)); // may be faster than x%10
    x=d;
  }
  std::reverse(ret.begin(),ret.end());
  // skip the above line if you don't mind that ret[0] is the least significant digit
  return ret;
}

Eu gosto de C, faço as coisas o mais simples possível, mas também gosto de C++ e uso classes e outras coisas, mas sem muita frescura e até hoje resolvi tudo que precisei.

A questão maior é que quando dá muito recurso os caras usam sem noção nenhuma, e muitas vezes sem pensar e de qualquer jeito só para resolver logo.

Vide o exemplo acima, eu num acreditei quando vi isso! O cara usou vetores imagina o tempo que consome isso: alocar memoria, desalocar etc...

Esse exemplo acima é o mais ridículo que eu consegui achar até hoje.

Uma das formas sugeridas para fazer a mesma coisa:
cpp code

uint8_t bcdToDec(uint8_t val)
{
  return ( (val/16*10) + (val%16) );
}

uint8_t decToBcd(uint8_t val)
{
  return ( (val/10*16) + (val%10) );
}

Ou seja... num dá nem pra comentar. o cara que escreveu o código com vetores é um dos piores programadores que eu já vi na minha vida.

Rodrigo_P_A escreveu:o cara que escreveu o código com vetores é um dos piores programadores que eu já vi na minha vida.

Eu nem sei se gostaria de entrar nessas de lembrar dos absurdos que já vi, tem coisas que a gente tenta esquecer!

Este exemplo que você deu é interessante pois o cara conseguiu cometer várias arbitrariedades, além de usar construções dinâmicas de alto nível para um problema de baixo nível, ele ainda enfiou isso num template mal escrito e que dificilmente seria usado em mais de uma hierarquia de classes - se é que usa em mais de uma classe.

E é exatamente esta qualidade de código que se espera de uma linguagem complexa quando o treinamento do indivíduo (ou pior, me causa arrepio em pensar: do grupo) é superficial.

Eu já lembro de ter dito a alguém algo nessas linhas:

"Parabéns, o compilador entendeu. Agora reescreva de modo que um humano possa entender"

polesapart escreveu:

Rodrigo_P_A escreveu:...
"Parabéns, o compilador entendeu. Agora reescreva de modo que um humano possa entender"

Essa foi boa, vou copiar a tua frase e usar em algumas situações!

Uma vez eu li num livro do Jack Ganssle que a função do código-fonte não é um humano dizer ao computador o que ele deve fazer, é um humano dizer a outro humano o que ele quer que o computador faça. Se outro humano não entender o código, então a missão não foi cumprida. O fato do computador executar o código é mera consequência.

Particularmente, eu concordo com a afirmação acima, e tento convencer outras pessoas que a função de um diagrama esquemático de um circuito eletrônico tem exatamente a mesma característica, mas eu conheço uma penca de pessoas que acham que só serve prá gerar uma netlist e uma BOM, nada mais. Isso me tira do sério.

Acho que nem 10% dos projetos que trabalhei foram coisas de uma vez só. Nem que fosse pra prestar suporte técnico, eu fatalmente tinha que dar uma olhada no código um ou mais anos depois que escrevi. E é impressionante como aquela gambiarra sintaxicamente linda mas mal documentada que você faz se torna proporcionalmente ilegível com o passar dos anos. Tive que aprender a documentar mais por mim do que pelo cliente. Duplamente importante quando trabalhando em equipe, mas posso dizer que a pedra de toque veio mesmo quando comecei a editar ou revisar código de terceiros. Você começa a pensar que realmente o mundo dá voltas, hoje eu escrevo um código safado aqui, o universo me devolve um pior amanhã. O negócio é semear boa documentação por aí, afinal de contas, como eu falei, amanhã pode ser você mesmo relendo o código que você escreveu e pensando "quem foi o tosco que fez isso? não faz sentido!". Só pra 15 segundos depois a memória reavivar e bater aquela culpa

Boa pessoal. eu também já passei por pegadinhas escritas por mim mesmo, e hoje eu escrevo comentários enormes e sempre tentar o mais legível possível.

Eu gosto de usar o Doxygen (www.doxygen.org). Vem em toda distro linux que se preze, e tem pra windows também (mas nunca usei).

Aí você usa uma sintaxe do tipo:

Código: Selecionar todos

/**
 * Retorna a raiz quadrada de um numero inteiro.
 * Desconsidera as implicações fracionarias no cálculo.
 * @param num Numero inteiro
 * @return raiz quadrada do numero
 */
uint32_t isqrt(uint32_t num)
{
 /* Insira o codigo aqui */
}



E ele gera documentação por arquivo, hierarquia de classes, funções, estruturas de dados, etc.
Tudo extraindo metadados dos comentários. Você pode criar sessões (na forma de capítulos) tbm, pra montar um manual. Ele gera índice navegável no pdf e pode gerar um html com frames e javascript que cria um navegador do lado esquerdo, semelhante ao que o acrobat reader usa no pdf.
Quem já usou javadoc vai notar as similaridades, embora o doxygen seja mais amplo. Gera saída em html, pdf, latex, até no obscuro formato chm (help do windows).
Gera grafos de chamada (tanto funções chamadas quanto chamadoras) para todo o projeto. São bem úteis.