Qual é a diferença entre o valor (tipo) e o tipo (valor)?

Qual é a diferença entre

(type)value 

e

 type(value) 

em C ++?

Não há diferença; pela norma (§5.2.3):

Um especificador de tipo simples (7.1.5) seguido de uma lista de expressões entre parênteses constrói um valor do tipo especificado, dada a lista de expressões. Se a lista de expressão é uma expressão única, a expressão de conversão de tipo é equivalente (em definição, e se definido em significado) à expressão de conversão correspondente (5.4).

Como a questão especificou a diferença entre o type(value) e (type)value , não há absolutamente nenhuma diferença.

Se e somente se você estiver lidando com uma lista de valores separados por vírgula, pode haver uma diferença. Nesse caso:

Se a lista de expressões especificar mais de um único valor, o tipo deve ser uma class com um construtor adequadamente declarado (8.5, 12.1), e a expressão T (x1, x2, …) é equivalente em efeito à declaração T t. (x1, x2, …); para alguma variável temporária inventada t, com o resultado sendo o valor de t como um valor r.

Como Troubadour apontou, há certos nomes de tipos para os quais a versão de type(value) simplesmente não compila. Por exemplo:

 char *a = (char *)string; 

irá compilar, mas:

 char *a = char *(string); 

não vou. O mesmo tipo com um nome diferente (por exemplo, criado com um typedef ) pode funcionar:

 typedef char *char_ptr; char *a = char_ptr(string); 

Não há diferença; o padrão C ++ (edições de 1998 e 2003) é claro sobre este ponto. Experimente o programa a seguir, certifique-se de usar um compilador compatível, como a visualização gratuita em http://comeaucomputing.com/tryitout/ .

 #include  #include  int main() { int('A'); (int) 'A'; // obvious (std::string) "abc"; // not so obvious unsigned(a_var) = 3; // see note below (long const&) a_var; // const or refs, which T(v) can't do return EXIT_SUCCESS; } 

Nota: unsigned(a_var) é diferente, mas mostra de uma maneira que os tokens exatos podem significar outra coisa. Ele está declarando uma variável chamada a_var do tipo não assinada e não é uma a_var . (Se você estiver familiarizado com pointers para funções ou arrays, considere como você tem que usar um parens ao redor de p em um tipo como void (*pf)() ou int (*pa)[42] .)

(Os avisos são produzidos porque essas declarações não usam o valor e, em um programa real, isso quase certamente seria um erro, mas tudo ainda funciona. Eu simplesmente não tive coragem de mudá-lo depois de fazer tudo alinhar.)

Não há diferença quando ambos são lançados, mas às vezes ‘type (value)’ não é um casting.

Aqui está um exemplo do rascunho padrão N3242, seção 8.2.1:

 struct S { S(int); }; void foo(double a) { S w( int(a) ); // function declaration S y( (int)a ); // object declaration } 

Nesse caso, ‘int (a)’ não é convertido porque ‘a’ não é um valor, é um nome de parâmetro cercado por parênteses redundantes. O documento afirma

A ambiguidade decorrente da semelhança entre um casting de estilo de function e uma declaração mencionada em 6.8 também pode ocorrer no contexto de uma declaração. Nesse contexto, a escolha é entre uma declaração de function com um conjunto redundante de parênteses em torno de um nome de parâmetro e uma declaração de object com uma conversão de estilo de function como o inicializador. Assim como para as ambiguidades mencionadas em 6.8, a resolução é considerar qualquer construção que possa ser uma declaração uma declaração.

Em c não há nenhum type (value) , enquanto em c / c + + ambos os valores de type (value) e (type) value são permitidos.

Para ilustrar suas opções em C ++ (somente uma tem uma verificação de segurança)

 #include using std::cout; using std::endl; int main(){ float smallf = 100.1; cout << (int)smallf << endl; // outputs 100 // c cast cout << int(smallf) << endl; // outputs 100 // c++ constructor = c cast cout << static_cast(smallf) << endl; // outputs 100 // cout << static_cast(smallf) << endl; // not allowed cout << reinterpret_cast(smallf) << endl; // outputs 1120416563 cout << boost::numeric_cast(smallf) << endl; // outputs 100 float bigf = 1.23e12; cout << (int)bigf << endl; // outputs -2147483648 cout << int(bigf) << endl; // outputs -2147483648 cout << static_cast(bigf) << endl; // outputs -2147483648 // cout << static_cast(bigf) << endl; // not allowed cout << reinterpret_cast(bigf) << endl; // outputs 1401893083 cout << boost::numeric_cast(bigf) << endl; // throws bad numeric conversion }