【C++注意事項】5 Top-level const,The auto and decltype Type Specifier
top-level const
As we’ve seen, a pointer is an object that can point to a different object. As a result, we can talk independently about whether a pointer is const and whether the objects to which it can point are const. we use the top-level const to indicate that the pointer itself is a const. When a pointer can point to a const object, we refer to that const as a low-level const.
More generally, top-level const indicates that an object itself is const. Top-level const can appear in any object type,i.e., one of the built-in arithmetic types, a class type, or a pointer type. Low-level const appears in the base type of compound types such as pointer or reference. Note that pointer types, unlike most other type, can have both top-level and low-level const independently:
The auto Type Specifier
It is not uncommon to want to store the value of an expression in a variable. To declare the variable, we have to know the type of that expression. When we write a program, it can be surprisingly difficult–and sometimes even impossible–to determine the type of an expression. Under the new standard, we can let the compiler figure out the type for us by using the auto type specifier. Unlike type specifiers, such as double, that names a specifier type, auto tells the compiler to deduce the type from the initializer. By implication, a variable that uses auto as its type specifier must have initializer:
Here the compiler will deduce the type of item from the type returned by applying + to val1 and val2.
First, as we’ve seen, when we use a reference, we are really using the object to which the reference refers. In particular, when we use a reference as in initializer, the initializer is the corresponding object. The compiler uses that object’s type for auto’s type deduction:
Second, auto ordinarily ignores top-level consts. As usual in initializations, low-level consts, such as when an initializer is a pointer to const, are kept:
If we want the deduced type to have a top-level const, we must say so explicitly:
We can also specify that we want a reference to the auto-deduced type. Normal initialization rules still apply:
when we ask for a reference to an auto-deduced type, top-level consts in the initializer are not ignored. As usual, consts are not top-level when we bind a reference to an initializer.
When we define several variables in the same statement, it is important to remember that a reference or pinter is part of a particular declarator and not part of the base type for the declaration. As usual, the initializers must provide consitent auto-deduced types:
The decltype Type Specifier
Sometimes we want to define a variable with a type that the compiler deduces from an expression but do not want to use that expression to initialize the variable. For such cases, the new standard introduced a second type specifier, decltype, which returns the type of its operand. The compiler analyzes the expression to determine its type but does not evaluate the expression:
Here, the compiler does not call f, but it uses the type that such a call would return as the type for sum. That is, the compiler gives sum the same type as the type that would be returned if we were to call f.
The way decltype handles top-level const and references differs subtly from the way auto does. When the expression to which we apply decltype is a variable, decltype returns the type of that variable, including top-level const and references:
Because cj is a reference, decltype(cj) is a reference type. Like any other reference, z must be initialized.
It is worth nothing that decltype is the only context in which a variable defined as a reference is not treated as a synonym for the object to which it refers.
decltype and References
When we apply decltype to an expression that is not a variable, we get the type that expression yields.
Here r is a reference, so decltype(r) is a reference type. If we want the type to which r refers, we can use r in an expression, such as r+0, which is an expression that yields a value that has a nonreference type.
On the other hand, the dereference operator is an example of an expression for which decltype returns a reference. As we’ve seen, when we dereference a pointer, we get the object to which the pointer points. Moreover, we can assign to that object. Thus, the type deduced by decltype(*p) is int&, not plain int.
Another important difference between decltype and auto is that the deduction done by decltype depends on the form of its given expression. What can be confusing is that enclosing the name of variable in parentheses affects the type returned by decltype. When we apply decltype to a variable without any parentheses, we get the type of that variable. If we warp the variable’s name in one or more sets of parentheses, the compiler will evaluate the operand as an expression. A variable is an expression that can be the left-hand side of an assignment. As a result, decltype on such an expression yields a reference:
Remember that decltype((variable))(note,double parentheses) is always a reference type, but decltype(variable) is reference type only if variable is a reference.
ご訪問ありがとうございます.ご協力をお願いします.注目、コレクション、コメントを歓迎します.
私の更なるブログの文章:NoMaspブログのガイド
斧正と質問を得るために、転載は出典を明記してください.http://blog.csdn.net/nomasp
本文はNoMasp柯于旺のオリジナルの文章で、許可を得ずに転載することを厳禁します!私のブログへようこそ:http://blog.csdn.net/nomasp
As we’ve seen, a pointer is an object that can point to a different object. As a result, we can talk independently about whether a pointer is const and whether the objects to which it can point are const. we use the top-level const to indicate that the pointer itself is a const. When a pointer can point to a const object, we refer to that const as a low-level const.
More generally, top-level const indicates that an object itself is const. Top-level const can appear in any object type,i.e., one of the built-in arithmetic types, a class type, or a pointer type. Low-level const appears in the base type of compound types such as pointer or reference. Note that pointer types, unlike most other type, can have both top-level and low-level const independently:
int i= 0;
int *const p1= &i; // we can't change the value of p1;const is top-level
const int ci= 42; // we can't change ci;const is top-level
const int *p2= &ci; // we can't change p2;cosnt is low-level
const int *const p3= p2; // right-most const is top-level,left-most is not
const int &r= ci; // const in reference types is always low-levelThe auto Type Specifier
It is not uncommon to want to store the value of an expression in a variable. To declare the variable, we have to know the type of that expression. When we write a program, it can be surprisingly difficult–and sometimes even impossible–to determine the type of an expression. Under the new standard, we can let the compiler figure out the type for us by using the auto type specifier. Unlike type specifiers, such as double, that names a specifier type, auto tells the compiler to deduce the type from the initializer. By implication, a variable that uses auto as its type specifier must have initializer:
// the type of item is deduced from the type of the result of adding val1 and val2
auto item= val1+val2; // item initialized to the result of vad1+vad2Here the compiler will deduce the type of item from the type returned by applying + to val1 and val2.
First, as we’ve seen, when we use a reference, we are really using the object to which the reference refers. In particular, when we use a reference as in initializer, the initializer is the corresponding object. The compiler uses that object’s type for auto’s type deduction:
int i= 0; &r= i;
auto a= r; // a is an int(r is an alias for i, which has type int)Second, auto ordinarily ignores top-level consts. As usual in initializations, low-level consts, such as when an initializer is a pointer to const, are kept:
const int ci= i, &cr= ci;
auto b= ci; // b is an int(top-level const in ci is dropped)
auto c= cr; // c is an int(cr is an alias for ci whose const is top-level)
auto d= &i; // d is an int*(& of an int object is int*)
auto e= &ci; // e is cosnt int*(& of a const object is low-level const)If we want the deduced type to have a top-level const, we must say so explicitly:
const auto f= ci; // deduced type of ci is int; f has type const intWe can also specify that we want a reference to the auto-deduced type. Normal initialization rules still apply:
auto &g= ci; // g is a const int& that is bound to ci
auto &h= 42; // error: we can't bind a plain reference to a literal
const auto &j= 42; // ok: we can bind a const reference to a literalwhen we ask for a reference to an auto-deduced type, top-level consts in the initializer are not ignored. As usual, consts are not top-level when we bind a reference to an initializer.
When we define several variables in the same statement, it is important to remember that a reference or pinter is part of a particular declarator and not part of the base type for the declaration. As usual, the initializers must provide consitent auto-deduced types:
auto k= ci, &l= i; // k is int; l is int&
auto &m= ci, *p= &ci; // m is a const int&; p is a pointer to cosnt int
// error: type deduced from i is int; type deduced from &ci is const int
auto &n= i, *p2= &ci;The decltype Type Specifier
Sometimes we want to define a variable with a type that the compiler deduces from an expression but do not want to use that expression to initialize the variable. For such cases, the new standard introduced a second type specifier, decltype, which returns the type of its operand. The compiler analyzes the expression to determine its type but does not evaluate the expression:
decltype(f()) sum= x; // sum has whatever type f returnsHere, the compiler does not call f, but it uses the type that such a call would return as the type for sum. That is, the compiler gives sum the same type as the type that would be returned if we were to call f.
The way decltype handles top-level const and references differs subtly from the way auto does. When the expression to which we apply decltype is a variable, decltype returns the type of that variable, including top-level const and references:
cosnt int ci= 0, &cj= ci;
decltype(ci) x= 0; // x has type const int
decltype(cj) y= x; // y has type cosnt int& and is bound to x;
decltype(cj) z; // error: z is reference and must be initializedBecause cj is a reference, decltype(cj) is a reference type. Like any other reference, z must be initialized.
It is worth nothing that decltype is the only context in which a variable defined as a reference is not treated as a synonym for the object to which it refers.
decltype and References
When we apply decltype to an expression that is not a variable, we get the type that expression yields.
// decltype of an expression can be a reference type
int i= 42, *p= &i, &r= i;
decltype(r+0) b; // ok: addition yields an int; b is an (uninitialized) int
decltype(*p) c; // error: c is int& and must be initializedHere r is a reference, so decltype(r) is a reference type. If we want the type to which r refers, we can use r in an expression, such as r+0, which is an expression that yields a value that has a nonreference type.
On the other hand, the dereference operator is an example of an expression for which decltype returns a reference. As we’ve seen, when we dereference a pointer, we get the object to which the pointer points. Moreover, we can assign to that object. Thus, the type deduced by decltype(*p) is int&, not plain int.
Another important difference between decltype and auto is that the deduction done by decltype depends on the form of its given expression. What can be confusing is that enclosing the name of variable in parentheses affects the type returned by decltype. When we apply decltype to a variable without any parentheses, we get the type of that variable. If we warp the variable’s name in one or more sets of parentheses, the compiler will evaluate the operand as an expression. A variable is an expression that can be the left-hand side of an assignment. As a result, decltype on such an expression yields a reference:
// decltype of a parenthesized variable is always a reference
decltype((i)) d; // error: d is int& and must be initialized
decltype(i) e; // ok: e is an (uninitialized) intRemember that decltype((variable))(note,double parentheses) is always a reference type, but decltype(variable) is reference type only if variable is a reference.
ご訪問ありがとうございます.ご協力をお願いします.注目、コレクション、コメントを歓迎します.
私の更なるブログの文章:NoMaspブログのガイド
斧正と質問を得るために、転載は出典を明記してください.http://blog.csdn.net/nomasp
本文はNoMasp柯于旺のオリジナルの文章で、許可を得ずに転載することを厳禁します!私のブログへようこそ:http://blog.csdn.net/nomasp