const的所有用法——Dan+Saks

In my last column, I discussed one of the reasons why the rules by which a compiler can place data into ROM are a bit more complicated in C++ than they are in C.1I have more to say about that subject, but before I do, I’d like to reply to the following query I received through e-mail from Phil Baurer at Komatsu Mining Systems:“We’re having an interesting prob-lem using const with a typedef. I hoped you could comment on this sit-uation. I am wondering if we are bumping into some unknown (by us) rule of the C language.“We are using the Hitachi C com-piler for the Hitachi SH-2 32-bit RISC microcontroller. We thought the fol-lowing code:t y p e d e f v o i d*V P;c o ns t V P v e c t o r T a b l e[]={..<d a t a>..};(1) should be identical to:c o ns t v o i d*v e c t o r T a b l e[]={..<d a t a>..};(2)“However, the linker places v e c t o r T a b l e in (1) into the C O N S T A N T section, but it places v e c t o r T a b l e in (2) into the D A T A section.“Is this the proper behavior or a bug in the compiler?”This is proper behavior; it is not a bug. You are indeed bumping into some rules of the C language that you apparently don’t know about. Don’t feel bad; you’re not alone. I believe many other C and C++ pro-grammers are confused about theserules, which is why I’m answering thisin my column.I presented some of these rules inan earlier column.2However, in look-ing back at that column, I don’t thinkI emphasized strongly enough thepoints which seem to be the sourceof your confusion. So let me tryagain.Declarat orsHere’s the first insight:Every declaration in C and C++ has twoprincipal parts: a sequence of zero or moredeclaration specifiers, and a sequence ofone or more declarators, separated bycommas.For example:A declarator is the name beingdeclared, possibly surrounded byoperators such as *, [], (), and (in thecase of C++) &. As you already know,the symbol *in a declarator means“pointer to” and []means “array of.”Thus, *x[N]is a declarator indicatingthat x is an “array of N elements ofpointer to ...” something, where thatsomething is the type specified in thedeclaration specifiers. For example,s t a t i c u ns i g ne d l o ng i nt*x[N];declares x as an object of type “array ofN elements of pointer to unsignedlong int.” (As explained later, the key-word s t a t i c does not contribute tothe type.)How did I know that *x[N]is an“array of ... pointer to ...” rather than a“pointer to an array of ...?” It followsfrom this rule:The operators in a declarator group accord-ing to the same precedence as they do whenthey appear in an expression.For example, if you check the near-est precedence chart for either C orC++, you’ll see that []has higherprecedence than *. Thus the declara-tor *x[N]means that x is an arraybefore it’s a pointer.Parentheses serve two roles indeclarators: first, as the function calloperator, and second, as grouping. Asthe function call operator, ()have thesame precedence as []. As grouping,()have the highest precedence of all.Embedded Systems Programming FEBRUARY 1999 13Dan Saks const T vs.T constAlthough C and C++ read mostly from top-to-bottom and left-to-right, pointer declarationsread, in a sense, backwards.For example, *f (i nt )is a declarator specifying that f is a “function ...returning a pointer ... .” In contrast,(*f )(i nt )specifies that f is a “pointer to a function ... .”A declarator may contain more than one identifier. The declarator *x [N ]contains two identifiers, x and N .Only one of those identifiers is the one being declared, and it’s called the declarator-id. The other(s), if any,must have been declared previously.For instance, the declarator-id in *x [N ]is x .A declarator need not contain any operators at all. In a declaration as simple as:i nt n;the declarator is just the identifier n without any operators.Declaration specifiersSome of the declaration specifiers leading up to a declarator can be type specifiers such as i nt , u ns i g ne d , or an identifier that names a type. They can also be storage class specifiers such as e x t e r n or s t a t i c . In C++ they can also be function specifiers such as i nl i ne or v i r t u a l .Here’s another insight: Type specifiers contribute to the type of the declarator-id; other specifiers provide non-type information that applies directly to the declarator-id.For example:s t a t i c u ns i g ne d l o ng i nt *x [N ];declares x as a variable of type “array of N elements of type pointer to unsigned long int.” The keyword s t a -t i c specifies that x has statically allo-cated storage.The examples in your letter lead me to suspect that you may have been tripped up by the fact that:The keywords c o ns t and v o l a t i l e are type specifiers.For example, the const in:c o ns t v o id *ve c t o r T a b l e []= {..<d a t a >..};(2)does not apply directly to v e c t o r T a b l e ;it applies directly to v o i d . This decla-ration declares v e c t o r T a b l e as a vari-able of type “array of pointer to const void.” It appears that you were expect-ing it to be “const array of pointer to void.”Here’s yet another important insight:The order in which the declaration speci-fiers appear in a declaration doesn’t matter.Thus, for example,c o ns t V P v e c t o r T a b l e []is equivalent to:V P c o ns t v e c t o r T a b l e []andc o ns t v o id *ve c t o r T a b l e []is equivalent to:v o i d c o ns t *v e c t o r T a b l e []Most of us place storage class speci-fiers such as s t a t i c as the first (left-most) declaration specifier, but it’s just a common convention, not a language requirement.The declaration specifiers c o n s t and v o l a t i l e are unusual in that:The only declaration specifiers that can also appear in declarators are c o n s t and v o l a t i l e .For example, the const in:v o i d *c o ns t v e c t o r T a b l e []appears in the declarator. In this case,you cannot rearrange the order of the keywords. For example:*c o ns t v o i d v e c t o r T a b l e []is an error.A clarifying styleAs I explained earlier, the order of the declaration specifiers doesn’t matter to the compiler. Therefore, these dec-larations are equivalent:c o ns t v o id *ve c t o r T a b l e [] (3)v o i d c o ns t *v e c t o r T a b l e [](4)Almost all C and C++ programmers prefer to write const and volatile to the left of the other type specifiers, as in (3). I prefer to write const and volatile to the right, as in (4), and I recom-mend it. Strongly.Although C and C++ read mostly from top-to-bottom and left-to-right,pointer declarations read, in a sense,backwards. That is, pointer declara-tions read from right-to-left. By plac-ing const to the right of the other type specifiers, you can read pointer decla-rations strictly from right-to-left and get const to come out in the “right”places. For example:T c o ns t *p ;declares p as a “pointer to a const T,”which is exactly what it is. Also:T *c o ns t p ;declares p as a “const pointer to a T,”which is also the correct interpretation.Writing const to the right of the14FEBRUARY 1999 Embedded Systems ProgrammingMost of us place storage class specifiers such as static as the first (leftmost)declaration specifier, but it’s just a common convention, not a languagerequirement.which makes it appear that v e c t o r T a b l e has type “array of pointer to const void.” This is wrong! The cor-rect interpretation is to replace VP as:uses. Just about everyone who usesconst places it to the left. However,given how few C and C++ program-mers really understand what they’redoing when it comes to using const indeclarations, “everyone else does it” ishardly an argument in favor of thecurrently popular style. Why not buckthe trend and try using a clearer style?As long as I’m on a roll here, Imight as well get in my digs in on arelated style point. Although most Cprogrammers seem to have remainedunsullied by this, many C++ program-mers have acquired the most unfortu-nate habit of writing:c o ns t i nt*p;rather than:c o ns t i nt*p;That is, they use spacing to join the *with the declaration specifiers ratherthan with the declarator. I reallybelieve C++ programmers do them-selves and each other a disservicewhen they write declarations in thisstyle. Sure, the spacing makes no dif-ference to the compiler, but puttingthe space after the *leaves many peo-ple with a false impression about theunderlying structure of declarations.Recognizing the boundary betweenthe last declaration specifier and thedeclarator is one of the keys to under-standing declarations. Breaking updeclarators with spaces this way onlyconfuses the situation.I hope I’ve answered your questionand clarified some issues.e s pDan Saks is the president of Saks &Associates, a C/C++ training and consult-ing company. He is also a contributing edi-tor for the C/C++ Users Journal. Heserved for many years as secretary of the C++standards committee and remains an activemember. With Thomas Plum, he wrote C++Programming Guidelines. You can writeto him at dsaks@.References1. “Static vs. Dynamic Initialization,”December 1998, p. 19.2. “Placing c o n s t in Declarations,” June1998, p. 19.16FEBRUARY 1999 Embedded Systems Programming。