救援队长!
如果是,
int(value)
这是所谓的explicit打字的转换,受第5.2.3条管辖。 确切的措辞是:
简单类型的审查者(7.1.5)之后,根据表述清单,括号的表述清单构成特定类型的价值。 如果表述清单是单一表述,则转换表述的类型(定义,如果定义)与相应的表达方式相同(,5.4)
(My emphasis). So this means that
int(value)
以及
(int)value
两者完全相同。 不管你发现哪一部分人更容易书写。
As for your second question, in the example you gave with the templates 以及 array, I believe that what you meant to write was something like this.
template <typename T, size_t N>
size_t (T (&)[N]) {
return N;
}
页: 1 以及<代码>T是一个模板参数,允许你在汇编者填入时,通过你喜欢的任何阵容,同时填写阵列中的内容数目。 如果出现这种混淆(地球上有T (&)[N]?),则是因为这一功能的参数为T (&)[N]。 为了便于阅读,请将这一参数命名为:
template <typename T, size_t N>
size_t (T (&array)[N]) {
return N;
}
我认为,这使我们更容易阅读。 但这一声明意味着什么?
T (&array)[N]
兹宣布一个称为<条码>的变量。 这是指一系列<代码>。 Ts of originallyNs. 你的确可以宣布提及阵列,就像你可以宣布阵列点一样。 这种做法在实践中并不常见,但在这个特定模板中,由于汇编者试图将阵列与模板论点相匹配,因此是使汇编者对你阵列规模进行推断的重要途径。
本案中父母一方的理由是,如果你写了字的话。
T& array[N]
The compiler would parse this as "a variable called array that s an array of N objects, each of which is a T&. However, the C++ spec specifically disallows arrays of references, 以及 this would be illegal. The parentheses explicitly disambiguate this. This is similar to function pointers - you write
void (*functionPointer)()
instead of
void *functionPointer()
To make the compiler realize that the * means that functionPointer is a pointer, rather than a function that returns a void *.
As for how the compiler determines when to treat parentheses in each way, the rules are fairly complex 以及 there are actually a few circumstances in which the compiler will not parse your expression in the intended way. One of these cases is something colloquially referred to as "the most vexing parse" in which the compiler treats what looks like object construction as a function prototype. As an example, this code:
vector<int> v();
Does not create a vector<int> called v initialized using the default constructor. Instead, it treats this as a function prototype for a function called v that takes no arguments 以及 produces a vector<int>! However, if you were to write
vector<int> v(10);
Then the compiler can unambiguously infer that this is a declaration of a vector<int> passing 10 as a constructor argument, because there s no way that it could be treated as a function prototype. §6.8 以及 §8.2 of the spec h以及les these cases by saying that anything that can be treated as a declaration will be, 以及 anything that can be treated as a function prototype will be as well.
The case of parentheses in the context of the array (that is, T (&array)[N]) is h以及led by a different piece of logic because in the context in which you re declaring a variable or defining a parameter whose type requires explicit parenthesis, there can be no ambiguity about your intention because it s clear from context that you re naming a type in order to declare a variable.
To summarize -
- Casts of the form
T(value) 以及 (T)value are identical.
- The parentheses in
T (&array)[N] are to prevent the compiler from binding the & to T instead of to array as intended.
- The particular use of parenthesis is usually inferred from context, though some issues can come up between variable declarations 以及 function prototypes.
希望这一帮助!
