By language
C/C++
and C11, there are four type qualifiers in standard C:const
In some programming languages, const is a type qualifier (a keyword applied to a data type) that indicates that the data is read-only. While this can be used to declare constants, in the C family of languages differs from similar constructs ...
( C89), volatile
( C89), restrict
In the C programming language, restrict is a keyword, introduced by the C99 standard, that can be used in pointer declarations. By adding this type qualifier, a programmer hints to the compiler that for the lifetime of the pointer, no other ...
( C99) and _Atomic
( C11) – the latter has a private name to avoid clashing with user-defined names. The first two of these, const
and volatile
, are also present in C++, and are the only type qualifiers in C++. Thus in C++ the term "''cv''-qualified type" (for const and volatile) is often used for "qualified type", while the terms "''c''-qualified type" and "''v''-qualified type" are used when only one of the qualifiers is relevant.
Of these, const
is by far the best-known and most used, appearing in the C and C++ standard libraries and encountered in any significant use of these languages, which must satisfy volatile
was used by some C++ programmers for synchronization during threading, though this was discouraged and is now broken in most compilers.
D
In D the type constructors areconst
, immutable
, shared
, and inout
. immutable
is a stronger variant of const
, indicating data that can ''never'' change its value, while const
indicates data that cannot be changed through this reference: it is a constant ''view'' on possibly mutable data. shared
is used for shared data in multi-threading (as volatile
was briefly used for in C++). inout
is a wildcard used to allow functions that do not modify data (and thus are only concerned with the unqualified type of the data) to return the same ''qualified'' type as the input. const
and immutable
can also be used as storage class specifiers.
Syntax
In C and C++, a type is given in a function declaration or variable declaration by giving one or more type specifiers, and optionally type qualifiers. For example, an integer variable can be declared as:int
is the type specifier. An unsigned integer variable can be declared as:
unsigned
and int
are type specifiers. A constant unsigned integer variable can be declared as:
const
is a type qualifier, which the qualified type of x
is const unsigned int
and the unqualified type is unsigned int
.
Variable declarations further have an optional storage class specifier. Properly this is a separate topic, distinct from the type, though const
on a variable declaration is ''also'' taken to have implications for the storage class, namely that it can be stored in read-only memory.
Volatile-correctness
The other qualifier in C and C++,volatile
, indicates that an object may be changed by something external to the program at any time and so must be re-read from memory every time it is accessed.
The qualifier is most often found in code that manipulates hardware directly (such as in const
in declarations of variables, pointers, references, and member functions, and in fact, volatile
is sometimes used to implement a similar design-by-contract strategy which volatile
-correctness, though this is far less common than const
-correctness. The volatile
qualifier also can be stripped by const_cast
, and it can be combined with the const
qualifier as in this sample:
hardwareRegister
is volatile
, there is no guarantee that it will hold the same value on two successive reads even though the programmer cannot modify it. The semantics here indicate that the register's value is read-only but not necessarily unchanging.
History
The notion of a type qualifier was introduced, along with the example ofreadonly
(later renamed const
) by const
was then adopted in C as part of standardization, and appears in C89 (and subsequent versions) along with another type qualifier, volatile
, which was invented by the ANSI C standard committee (X3J11). volatile
appeared by 1985; and an early use was in compiling the UNIX kernel for MIPS, to allow optimized compiling by preventing usual optimizations from being applied to volatile variables. A further qualifier, noalias
, was suggested at the December 1987 meeting of the X3J11 committee, but was rejected; its goal was ultimately fulfilled by the restrict
qualifier in C99. The motivation for noalias
was complementary to volatile
, namely that it indicated that even normally unsafe optimizations could be performed. Ritchie was not very supportive of type qualifiers, arguing that they did not "carry their weight", but ultimately did not argue for their removal from the standard; he did oppose noalias
however, and it was dropped from the draft.
Java does not have type qualifiers, and conspicuously omitted const
: a 1999 proposal to add it was rejected, notably because adding it after the fact and then changing the standard library to use it consistently would have broken compatibility. However, Java initially left open the possibility of implementing const
, noticeable in that const
is a final
, which is used to qualify attributes (and thence also for local variables) as constant, but not to qualify types.
Alternatives
Other languages take a different approach, considering constancy a property of an ''identifier'' (orconstant
keyword,final
keyword.
Notes
References
{{Reflist, 30emExternal links