Оқуға арналған деректерді белгілеуші (Type Qualifier)

Type qualifier denoting the data as being read only

In some programming languages, const is a type qualifier (a keyword applied to a data type), which 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 in other languages in that it is part of the type, and thus has complicated behavior when combined with pointers, references, composite data types, and type checking. In other languages, the data is not in a single memory location, but copied at compile time for each use. Languages which use it include C, C++, D, JavaScript, Julia, and Rust.

When applied in an object declaration, it indicates that the object is a constant: its value may not be changed, unlike a variable. This basic use – to declare constants – has parallels in many other languages. However, unlike in other languages, in the C family of languages the const is part of the type, not part of the object. For example, in C, declares an object x of int const type – the const is part of the type, as if it were parsed "(int const) x" – while in Ada, declares a constant (a kind of object) X of INTEGER type: the constant is part of the object, but not part of the type. This has two subtle results. Firstly, const can be applied to parts of a more complex type – for example, int const * const x; declares a constant pointer to a constant integer, while int const * x; declares a variable pointer to a constant integer, and int * const x; declares a constant pointer to a variable integer. Secondly, because const is part of the type, it must match as part of type checking. For example, the following code is invalid:
void f(int& x);
//
int const i;
f(i);
because the argument to f must be a variable integer, but i is a constant integer. This matching is a form of program correctness, and is known as const correctness. This allows a form of programming by contract, where functions specify as part of their type signature whether they modify their arguments or not, and whether their return value is modifiable or not. This type checking is primarily of interest in pointers and references – not basic value types like integers – but also for composite data types or templated types such as containers. It is concealed by the fact that the const can often be omitted, due to type coercion (implicit type conversion) and C being call by value (C++ and D are either call by value or call by reference).

The idea of const ness does not imply that the variable as it is stored in computer memory is unwritable. Rather, const ness is a compile time construct that indicates what a programmer should do, not necessarily what they can do. Note, however, that in the case of predefined data (such as char const * string literals), C const is often unwritable.

While a constant does not change its value while the program is running, an object declared const may indeed change its value while the program is running. A common example are read only registers within embedded systems like the current state of a digital input. The data registers for digital inputs are often declared as const and volatile. The content of these registers may change without the program doing anything (volatile) but it would be ill formed for the program to attempt write to them (const).

In addition, a (non static) member function can be declared as const. In this case, the this pointer inside such a function is of type object type const * rather than merely of type object type *. This means that non const functions for this object cannot be called from inside such a function, nor can member variables be modified. In C++, a member variable can be declared as mutable, indicating that this restriction does not apply to it. In some cases, this can be useful, for example with caching, reference counting, and data synchronization. In these cases, the logical meaning (state) of the object is unchanged, but the object is not physically constant since its bitwise representation may change.

In C, C++, and D, all data types, including those defined by the user, can be declared const, and const correctness dictates that all variables or objects should be declared as such unless they need to be modified. Such proactive use of const makes values "easier to understand, track, and reason about," and it thus increases the readability and comprehensibility of code and makes working in teams and maintaining code simpler because it communicates information about a value's intended use. This can help the compiler as well as the developer when reasoning about code. It can also enable an optimizing compiler to generate more efficient code.

For simple non pointer data types, applying the const qualifier is straightforward. It can go on either side of some types for historical reasons (for example, const char foo = 'a'; is equivalent to char const foo = 'a';). On some implementations, using const twice (for instance, const char const or char const const) generates a warning but not an error.

const can be declared both on function parameters and on variables (static or automatic, including global or local). The interpretation varies between uses. A const static variable (global variable or static local variable) is a constant, and may be used for data like mathematical constants, such as double const PI = 3.14159 – realistically longer, or overall compile time parameters. A const automatic variable (non static local variable) means that single assignment is happening, though a different value may be used each time, such as int const x squared = x * x. A const parameter in pass by reference means that the referenced value is not modified – it is part of the contract – while a const parameter in pass by value (or the pointer itself, in pass by reference) does not add anything to the interface (as the value has been copied), but indicates that internally, the function does not modify the local copy of the parameter (it is a single assignment). For this reason, some favor using const in parameters only for pass by reference, where it changes the contract, but not for pass by value, where it exposes the implementation.

The use of the type system to express constancy leads to various complexities and problems, and has accordingly been criticized and not adopted outside the narrow C family of C, C++, and D. Java and C#, which are heavily influenced by C and C++, both explicitly rejected const style type qualifiers, instead expressing constancy by keywords that apply to the identifier (final in Java, const and readonly in C#). Even within C and C++, the use of const varies significantly, with some projects and organizations using it consistently, and others avoiding it.

const was introduced by Bjarne Stroustrup in C with Classes, the predecessor to C++, in 1981, and was originally called readonly. As to motivation, Stroustrup writes: 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 keyword in C99. Ritchie was not very supportive of these additions, arguing that they did not "carry their weight", but ultimately did not argue for their removal from the standard. D subsequently inherited const from C++, where it is known as a type constructor (not type qualifier) and added two further type constructors, immutable and inout, to handle related use cases.

Other languages do not follow C/C++ in having constancy part of the type, though they often have superficially similar constructs and may use the const keyword. Typically this is only used for constants (constant objects). C# has a const keyword, but with radically different and simpler semantics: it means a compile time constant, and is not part of the type. Nim has a const keyword similar to that of C#: it also declares a compile time constant rather than forming part of the type. However, in Nim, a constant can be declared from any expression that can be evaluated at compile time. In C#, only C# built in types can be declared as const; user defined types, including classes, structs, and arrays, cannot be const. Java does not have const – it instead has final, which can be applied to local "variable" declarations and applies to the identifier, not the type. It has a different object oriented use for object members, which is the origin of the name. The Java language specification regards const as a reserved keyword – i. e., one that cannot be used as variable identifier – but assigns no semantics to it: it is a reserved word (it cannot be used in identifiers) but not a keyword (it has no special meaning). It is thought that the reservation of the keyword occurred to allow for an extension of the Java language to include C++ style const methods and pointer to const type. An enhancement request ticket for implementing const correctness exists in the Java Community Process, but was closed in 2005 on the basis that it was impossible to implement in a backwards compatible fashion. The contemporary Ada 83 independently had the notion of a constant object and a constant keyword, with input parameters and loop parameters being implicitly constant. Here the constant is a property of the object, not of the type. JavaScript has a const declaration that defines a block scoped variable that cannot be reassigned nor redeclared. It defines a read only reference to a variable that cannot be redefined, but in some situations the value of the variable itself may potentially change, such as if the variable refers to an object and a property of it is altered.