Estilos de sintaxe de conversão C++

StackOverflow https://stackoverflow.com/questions/32168

  •  09-06-2019
  •  | 
  •  

Pergunta

Uma pergunta relacionada Elenco regular vs.static_cast vs.elenco_dinâmico:

Qual estilo de sintaxe de conversão você prefere em C++?

  • Sintaxe de conversão estilo C: (int)foo
  • Sintaxe de conversão no estilo C++: static_cast<int>(foo)
  • sintaxe do construtor: int(foo)

Eles podem não traduzir exatamente as mesmas instruções (serão?), mas seu efeito deve ser o mesmo (certo?).

Se você estiver apenas transmitindo entre os tipos numéricos integrados, acho a sintaxe de conversão no estilo C++ muito detalhada.Como ex-codificador Java, costumo usar a sintaxe de conversão no estilo C, mas meu guru local de C++ insiste em usar a sintaxe do construtor.

O que você acha?

Foi útil?

Solução

É a melhor prática nunca usar conversões no estilo C por três razões principais:

  • como já mencionado, nenhuma verificação é realizada aqui.O programador simplesmente não consegue saber qual das várias conversões é usada, o que enfraquece a digitação forte
  • os novos elencos são intencionalmente impressionantes visualmente.Como as conversões geralmente revelam um ponto fraco no código, argumenta-se que tornar as conversões visíveis no código é uma coisa boa.
  • isso é especialmente verdadeiro se você estiver procurando por conversões com uma ferramenta automatizada.Encontrar moldes no estilo C de maneira confiável é quase impossível.

Como palm3D observou:

Acho a sintaxe de conversão no estilo C++ muito detalhada.

Isto é intencional, pelas razões apresentadas acima.

A sintaxe do construtor (nome oficial:conversão de estilo de função) é semanticamente o mesmo como a conversão no estilo C e também deve ser evitada (exceto para inicializações de variáveis ​​na declaração), pelas mesmas razões.É discutível se isso deveria ser verdade mesmo para tipos que definem construtores personalizados, mas em C++ Efetivo, Meyers argumenta que mesmo nesses casos você deve evitar usá-los.Ilustrar:

void f(auto_ptr<int> x);

f(static_cast<auto_ptr<int> >(new int(5))); // GOOD
f(auto_ptr<int>(new int(5));                // BAD

O static_cast aqui vai realmente chamar o auto_ptr construtor.

Outras dicas

De acordo com Stroustrup:

Os "elencos novos de estilo" foram introduzidos para dar aos programadores a chance de declarar suas intenções com mais clareza e para o compilador capturar mais erros.

Então, realmente, é por segurança, pois faz verificações extras em tempo de compilação.

Em relação a este assunto, estou seguindo as recomendações feitas pelo Scott Meyers (C++ mais eficaz, Item 2 :Prefira conversões no estilo C++).

Concordo que o elenco do estilo C++ é detalhado, mas é disso que gosto neles:eles são muito fáceis de detectar e tornam o código mais fácil de ler (o que é mais importante do que escrever).

Eles também obrigam você a pensar no tipo de gesso que você precisa e a escolher o certo, reduzindo o risco de erros.Eles também o ajudarão a detectar erros em tempo de compilação, em vez de em tempo de execução.

Eu uso static_cast por dois motivos.

  1. Está explicitamente claro o que está acontecendo.Não consigo ler isso sem perceber que há um elenco acontecendo.Com os moldes estilo C, você pode passar por cima dele sem parar.
  2. É fácil pesquisar todos os lugares do meu código onde estou transmitindo.

Definitivamente estilo C++.A digitação extra ajudará a evitar que você transmita quando não deveria :-)

Sintaxe de conversão estilo C, não verifica erros.Sintaxe de conversão no estilo C++, faz algumas verificações.Ao usar static_cast, mesmo que não faça verificação, pelo menos você sabe que deve ter cuidado aqui.

O elenco estilo C é o pior caminho a percorrer.É mais difícil de ver, inegável, combina ações diferentes que não deveriam ser combinadas e não pode fazer tudo o que as conversões no estilo C++ podem fazer.Eles realmente deveriam ter removido as conversões de estilo C da linguagem.

Atualmente usamos conversões de estilo C em todos os lugares.Eu perguntei ao outro pergunta de elenco, e agora vejo a vantagem de usar static_cast, pelo menos por ser "greppable" (gosto desse termo).Provavelmente vou começar a usar isso.

Não gosto do estilo C++;parece muito com uma chamada de função.

Escolha o estilo C++ e, na pior das hipóteses, os feios trechos de código detalhados que compunham o typecast explícito do C++ serão um lembrete constante do que todos sabemos (ou seja, a conversão explícita é ruim - o que leva à criação de palavrões).Não escolha o estilo C++ se quiser dominar a arte de rastrear erros de tempo de execução.

A sintaxe do construtor.C++ é OO, existem construtores, eu os uso.Se você sentir necessidade de anotar esses fatores de conversão, faça isso para todos os tipos, não apenas para os integrados.Talvez você use a palavra-chave 'explícita' para ctors de conversão, mas a sintaxe do cliente imita exatamente o que a sintaxe do ctor para tipos integrados faz.Sendo grepável, isso pode ser verdade, mas que grande surpresa é que digitar mais caracteres facilita as pesquisas.Por que tratar esses como especiais?Se você estiver escrevendo fórmulas matemáticas com muitos int/unsigned/...de e para double/float - gráficos - e você precisa escrever um static_cast toda vez, a aparência da fórmula fica confusa e muito ilegível.E é uma batalha difícil de qualquer maneira, pois muitas vezes você se converterá sem nem perceber que está.Para ponteiros de downcast, eu uso o static_cast, pois é claro que não existe nenhum ctor por padrão que faria isso.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top