Community hub
Recent from talks
Contribute something
Nothing was collected or created yet.
Constant (computer programming)
View on WikipediaIn computer programming, a constant is a value that is not altered by the program during normal execution. When associated with an identifier, a constant is said to be "named," although the terms "constant" and "named constant" are often used interchangeably. This is contrasted with a variable, which is an identifier with a value that can be changed during normal execution. To simplify, constants' values remains, while the values of variables varies, hence both their names.
Constants are useful for both programmers and compilers: for programmers, they are a form of self-documenting code and allow reasoning about correctness, while for compilers, they allow compile-time and run-time checks that verify that constancy assumptions are not violated,[a] and allow or simplify some compiler optimizations.
There are various specific realizations of the general notion of a constant, with subtle distinctions that are often overlooked. The most significant are: compile-time (statically valued) constants, run-time (dynamically valued) constants, immutable objects, and constant types (const).
Typical examples of compile-time constants include mathematical constants, values from standards (here maximum transmission unit), or internal configuration values (here characters per line), such as these C examples:
const float PI = 3.1415927; // maximal single float precision
const unsigned int MTU = 1500; // Ethernet v2, RFC 894
const unsigned int COLUMNS = 80;
Typical examples of run-time constants are values calculated based on inputs to a function, such as this C++ example:
using std::string;
void f(string s) {
const size_t len = s.length();
// ...
}
Use
[edit]Some programming languages make an explicit syntactic distinction between constant and variable symbols, for example considering assignment to a constant to be a syntax error, while in other languages they are considered syntactically the same (both simply an identifier), and the difference in treatment is semantic (assignment to an identifier is syntactically valid, but if the identifier is a constant it is semantically invalid).
A constant value is defined once and can be referenced many times throughout a program. Using a constant instead of specifying the same value multiple times can simplify code maintenance (as in don't repeat yourself) and can be self documenting by supplying a meaningful name for a value, for instance, PI instead of 3.1415926.
Comparison with literals and macros
[edit]There are several main ways to express a data value that doesn't change during program execution that are consistent across a wide variety of programming languages. One very basic way is by simply writing a literal number, character, or string into the program code, which is straightforward in C, C++, and similar languages.
In assembly language, literal numbers and characters are done using the "immediate mode" instructions available on most microprocessors. The name "immediate" comes from the values being available immediately from the instruction stream, as opposed to loading them indirectly by looking up a memory address.[1] On the other hand, values longer than the microprocessor's word length, such as strings and arrays, are handled indirectly and assemblers generally provide a "data" pseudo-op to embed such data tables in a program.
Another way is by defining a symbolic macro. Many high-level programming languages, and many assemblers, offer a macro facility where the programmer can define, generally at the beginning of a source file or in a separate definition file, names for different values. A preprocessor then replaces these names with the appropriate values before compiling, resulting in something functionally identical to using literals, with the speed advantages of immediate mode. Because it can be difficult to maintain code where all values are written literally, if a value is used in any repetitive or non-obvious way, it is often named by a macro.
A third way is by declaring and defining a variable as being "constant". A global variable or static variable can be declared (or a symbol defined in assembly) with a keyword qualifier such as const, constant, or final, meaning that its value will be set at compile time and should not be changeable at runtime. Compilers generally put static constants in the text section of an object file along with the code itself, as opposed to the data section where non-const initialized data is kept. Some compilers can produce a section specifically dedicated to constants. Memory protection can be applied to this area to prevent overwriting of such constants by errant pointers.
These constants differ from literals in a number of ways. Compilers generally place a constant in a single memory location identified by symbol, rather than spread throughout the executable as with a macro. While this precludes the speed advantages of immediate mode, there are advantages in memory efficiency, and debuggers can work with these constants at runtime. Also while macros may be redefined accidentally by conflicting header files in C and C++, conflicting constants are detected at compile time.
Depending upon the language, constants can be untyped or typed. In C and C++, macros provide the former, while const provides the latter:
#define PI 3.1415926535
const float pi2 = 3.1415926535;
while in Ada, there are universal numeric types that can be used, if desired:
pi : constant := 3.1415926535;
pi2 : constant float := 3.1415926535;
with the untyped variant being implicitly converted to the appropriate type upon each use.[2]
Dynamically-valued constants
[edit]Besides the static constants described above, many procedural languages such as Ada and C++ extend the concept of constantness toward global variables that are created at initialization time, local variables that are automatically created at runtime on the stack or in registers, to dynamically allocated memory that is accessed by pointer, and to parameter lists in function headers.
Dynamically valued constants do not designate a variable as residing in a specific region of memory, nor are the values set at compile time. In C++ code such as
float func(const float myFloat) {
const float result = someGlobalVariable * someOtherFunction(myFloat);
// ...
}
the expression that the constant is initialized to are not themselves constant. Use of constantness is not necessary here for program legality or semantic correctness, but has three advantages:
- It is clear to the reader that the object will not be modified further, once set
- Attempts to change the value of the object (by later programmers who do not fully understand the program logic) will be rejected by the compiler
- The compiler may be able to perform code optimizations knowing that the value of the object will not change once created.[3]
Dynamically valued constants originated as a language feature with ALGOL 68.[3] Studies of Ada and C++ code have shown that dynamically valued constants are used infrequently, typically for 1% or less of objects, when they could be used much more, as some 40–50% of local, non-class objects are actually invariant once created.[3][4] On the other hand, such "immutable variables" tend to be the default in functional languages since they favour programming styles with no side-effect (e.g., recursion) or make most declarations immutable by default, such as ML. Purely functional languages even forbid side-effects entirely.
Constantness is often used in function declarations, as a promise that when an object is passed by reference, the called function will not change it. Depending on the syntax, either a pointer or the object being pointed to may be constant, however normally the latter is desired. Especially in C++ and C, the discipline of ensuring that the proper data structures are constant throughout the program is called const-correctness.
Constant function parameters
[edit]In C/C++, it is possible to declare the parameter of a function or method as constant. This is a guarantee that this parameter cannot be inadvertently modified after its initialization by the caller. If the parameter is a pre-defined (built-in) type, it is called by value and cannot be modified. If it is a user-defined type, the variable is the pointer address, which cannot be modified either. However, the content of the object can be modified without limits. Declaring parameters as constants may be a way to signalise that this value should not be changed, but the programmer must keep in mind that checks about modification of an object cannot be done by the compiler.
Besides this feature, it is in C++ also possible to declare a function or method as const. This prevents such functions or methods from modifying anything but local variables.
In C#, the keyword const exists, but does not have the same effect for function parameters, as it is the case in C/C++. There is, however, a way to "stir" the compiler to do make the check, albeit it is a bit tricky.[5]
Object-oriented constants
[edit]A constant data structure or object is referred to as "immutable" in object-oriented parlance. An object being immutable confers some advantages in program design. For instance, it may be "copied" simply by copying its pointer or reference, avoiding a time-consuming copy operation and conserving memory.
Object-oriented languages such as C++ extend constantness even further. Individual members of a struct or class may be made const even if the class is not. Conversely, the mutable keyword allows a class member to be changed even if an object was instantiated as const.
Even functions can be const in C++. The meaning here is that only a const function may be called for an object instantiated as const; a const function doesn't change any non-mutable data.
C# has both a const and a readonly qualifier; its const is only for compile-time constants, while readonly can be used in constructors and other runtime applications.
Java
[edit]Java has a qualifier called final that prevents changing a reference and makes sure it will never point to a different object. This does not prevent changes to the referred object itself. Java's final is basically equivalent to a const pointer in C++. It does not provide the other features of const.
In Java, the qualifier final states that the affected data member or variable is not assignable, as below:
final int i = 3;
i = 4; // Error! Cannot modify a "final" object
It must be decidable by the compilers where the variable with the final marker is initialized, and it must be performed only once, or the class will not compile. Java's final and C++'s const keywords have the same meaning when applied with primitive variables.
const int i = 3; // C++ declaration
i = 4; // Error!
Considering pointers, a final reference in Java means something similar to const pointer in C++. In C++, one can declare a "constant pointer type".
Foo* const bar = mem_location; // const pointer type
Here, bar must be initialised at the time of declaration and cannot be changed again, but what it points is modifiable. I.e. *bar = value is valid. It just can't point to another location. Final references in Java work the same way except that they can be declared uninitialized.
final Foo i; // a Java declaration
Note: Java does not support pointers.[6] It is because pointers (with restrictions) are the default way of accessing objects in Java, and Java does not use stars to indicate them. For example, i in the last example is a pointer and can be used to access the instance.
One can also declare a pointer to "read-only" data in C++.
const Foo* bar;
Here bar can be modified to point anything, anytime; just that pointed value cannot be modified through bar pointer.
There is no equivalent mechanism in Java. Thus there are also no const methods.
Const-correctness cannot be enforced in Java, although by use of interfaces and defining a read-only interface to the class and passing this around, one can ensure that objects can be passed around the system in a way that they cannot be modified.
Java collections framework provides a way to create an immutable wrapper of a Collection via Collections.unmodifiableCollection() and similar methods.
A method in Java can be declared "final", meaning that it cannot be overridden in subclasses.
C#
[edit]In C#, the qualifier readonly has the same effect on data members that final does in Java and the const does in C++; the modifier const has an effect similar (yet typed and class-scoped) to that of #define in C++. The other, inheritance-inhibiting effect of Java's final when applied to methods and classes is induced in C# with the aid of the keyword sealed.
Unlike C++, C# does not permit methods and parameters to be marked as const. However one may also pass around read-only subclasses, and the .NET Framework provides some support for converting mutable collections to immutable ones which may be passed as read-only wrappers.
By paradigm
[edit]Treatment of constants varies significantly by programming paradigm. Const-correctness is an issue in imperative languages like C++ because by default name bindings typically create variables, which can vary, as the name suggests, and thus if one wishes to mark a binding as constant this requires some additional indication.[b] In other programming language paradigms related issues arise, with some analogs to const-correctness found.
In functional programming, data are typically constant by default, rather than variable by default. Instead of assigning a value to a variable (a storage space with a name and potentially variable value), one creates a binding of a name to a value, such as by the let construct in many dialects of Lisp. In some functional languages, particularly multiparadigm ones such as Common Lisp, modifying data is commonplace, while in others it is avoided or considered exceptional; this is the case for Scheme (another Lisp dialect), which uses the set! construct to modify data, with the ! exclamation point drawing attention to this. Such languages achieve the goals of const-correctness by default, drawing attention to modification rather than constantness.
In a number of object-oriented languages, there is the concept of an immutable object, which is particularly used for basic types like strings; notable examples include Java, JavaScript, Python, and C#. These languages vary in whether user-defined types can be marked as immutable, and may allow particular fields (attributes) of an object or type to be marked as immutable.
In some multiparadigm languages that allow both object-oriented and functional styles, both of these features may be combined. For example, in OCaml object fields are immutable by default and must be explicitly marked with the keyword mutable to be mutable, while in Scala, bindings are explicitly immutable when defined with val for "value" and explicitly mutable when defined with var for "variable".
Naming conventions
[edit]Naming conventions for constants vary. Some simply name them as they would any other variable. Others use capitals and underscores for constants in a way similar to their traditional use for symbolic macros, such as SOME_CONSTANT.[7] In Hungarian notation, a "k" prefix signifies constants as well as macros and enumerated types.
One enforced convention is that in Ruby, any variable that begins with a capital letter is considered a constant, including class names.
See also
[edit]- Address constants for the IBM/360 and Z/Architecture platform
Notes
[edit]- ^ In some cases this can be circumvented, e.g. using self-modifying code or by overwriting the memory location where the value is stored.
- ^ This is not universal: in Ada input parameters and loop parameters are implicitly constant, for instance.
References
[edit]- ^ Ex. IBM Systems Information. Instruction Set - Assembler Language Reference for PowerPC.
- ^ Booch, Grady (1983). Software Engineering with Ada. Benjamin Cummings. pp. 116–117. ISBN 0-8053-0600-5.
- ^ a b c Schilling, Jonathan L. (April 1995). "Dynamically-Valued Constants: An Underused Language Feature". SIGPLAN Notices. 30 (4): 13–20. doi:10.1145/202176.202177. S2CID 17489672.
- ^ Perkins, J. A. Programming Practices: Analysis of Ada Source Developed for the Air Force, Army, and Navy. Proceedings TRI-Ada '89. pp. 342–354. doi:10.1145/74261.74287.
- ^
Timwi (2010-09-09). "Read-only ("const"-like) function parameters of C#". Stack Overflow. Retrieved 2012-05-06.
[...] Then you can declare methods whose parameter type "tells" whether it plans on changing the variable or not:. [...] This mimics compile-time checks similar to constness in C++. As Eric Lippert correctly pointed out, this is not the same as immutability. But as a C++ programmer I think you know that.
- ^ "Oracle Technology Network for Java Developers | Oracle Technology Network | Oracle". Java.sun.com. 2013-08-14. Retrieved 2013-08-18.
- ^ Microsoft Office XP Developer: Constant Names
Constant (computer programming)
View on Grokipedia42, the floating-point 3.14159, or the string "Hello, World!", used inline where the value is needed.[4] Named constants, often declared using keywords like const in languages such as C, C++, or Java, allow programmers to assign a value once and reference it by name throughout the program, improving code maintainability.[3] For instance, in C++, const double PI = 3.14159; creates a reusable constant for pi.[1]
The use of constants enhances code readability by replacing magic numbers or hardcoded values with descriptive names, making it easier for developers to understand and modify the program later.[2] They also reduce errors, as compilers or interpreters enforce immutability, catching attempts to alter them at compile time rather than runtime.[5] In languages without built-in constant support, such as Python, conventions like uppercase naming (e.g., PI = 3.14159) signal that a variable should not be changed, though enforcement relies on developer discipline.[1] Overall, constants promote safer, more reliable software by centralizing fixed values and facilitating updates in a single location.[2]
Definition and Fundamentals
Definition
In computer programming, a constant is an identifier associated with a fixed value that cannot be modified after its initialization, distinguishing it from variables which permit reassignment during program execution.[6] This immutability ensures that the value remains unchanged throughout the program's lifecycle, promoting reliability by preventing unintended alterations.[7] Key characteristics of constants include their enforcement of immutability either at compile-time, where the compiler rejects any modification attempts, or at runtime through language mechanisms that prohibit changes.[7] They are commonly used to represent invariant values, such as mathematical constants; for instance, defining π as 3.14159 allows reuse without repetition or risk of error.[8] Basic syntax for declaring a constant varies by language; in C, the statementconst int MAX = 100; creates an immutable integer identifier named MAX with the value 100.[9]
The concept of constants dates back to early high-level programming languages. Literal constants were present in Fortran I, developed by IBM under John Backus in the 1950s for scientific computing. Named constants, however, were introduced later, such as with the PARAMETER statement in the Fortran 77 standard.[10]
Purpose and Benefits
Constants in computer programming serve primarily to enhance code readability by assigning descriptive names to fixed values that would otherwise appear as unexplained numbers or strings, often referred to as "magic numbers."[11] This practice makes the intent of the code clearer to developers, facilitating quicker comprehension and collaboration.[1] Additionally, constants reduce errors by eliminating the repetition of hardcoded values throughout the codebase, which can lead to inconsistencies if values are mistyped or altered inconsistently.[2] A key benefit of constants is their role in facilitating maintenance, as changes to a fixed value need only be made in one centralized location, preventing the propagation of errors across large codebases.[11] Compile-time constants, in particular, enable compiler optimizations by allowing values to be evaluated and inlined during compilation, resulting in faster execution and reduced memory usage at runtime.[12] They also provide type safety, as the compiler enforces immutability and type checking, which helps catch potential bugs early.[13] Furthermore, constants simplify debugging by making fixed values explicit and unchangeable, reducing the likelihood of unintended modifications during program execution.[1] For instance, in a physics simulation, declaringconst double GRAVITY = 9.8; allows the value to be referenced meaningfully throughout the code, rather than scattering the literal 9.8 in multiple places, which improves both readability and ease of adjustment if the constant needs refinement.[11]
While constants offer limited flexibility compared to variables—since their values cannot be altered after declaration—they provide significant performance gains in resource-constrained environments like embedded systems, where immutable data can be stored in read-only memory (ROM) to optimize space and execution speed.[14]
Comparisons with Related Concepts
With Variables
In programming languages, variables are mutable entities that can be reassigned new values after their initial declaration, allowing them to store changing data throughout program execution. For example, in C++, a variable can be declared and modified asint x = 5; x = 10;, where the value of x is updated from 5 to 10. In contrast, constants are immutable, preventing any reassignment to enforce the intended fixed nature of the value; attempting to modify a constant, such as const int c = 5; c = 10;, results in a compile-time error.[15] This immutability is similarly enforced in Java using the final keyword, where final int c = 5; cannot be reassigned, and in C# with const int c = 5;, which embeds the value directly into the code at compile time.[16][17]
The distinction between constants and variables guides their selection based on data mutability. Variables are appropriate for dynamic values that evolve, such as loop counters in algorithms (e.g., int i = 0; i++; in a for loop) or user inputs that may vary at runtime. Constants, however, suit invariant data like mathematical values (e.g., const double PI = 3.14159;) or configuration limits (e.g., final int MAX_USERS = 100; in Java), ensuring the program's design intent remains intact and reducing the risk of unintended modifications.[16][17] By declaring such fixed elements as constants, developers signal that these values should not change, promoting code reliability and maintainability across languages like C++, Java, and C#.[15]
Enforcement of constant immutability typically occurs at compile time, where the compiler detects and rejects reassignment attempts, providing immediate feedback during development. In C++, the const qualifier triggers errors for direct modifications and undefined behavior for indirect ones via non-const pointers, while Java's final prevents reassignment entirely, including in inheritance hierarchies. C# constants are substituted inline during compilation, making modification impossible as they lack runtime addresses. This mechanism not only prevents bugs but also aids in static analysis tools for verifying program correctness.[15][16][17]
From a performance perspective, constants enable compiler optimizations that variables generally do not, such as constant folding—where expressions involving constants are evaluated and replaced with their results at compile time—or inlining values directly into instructions, reducing runtime memory accesses. For instance, in C++, a const variable may be treated as a compile-time constant expression, allowing the compiler to optimize it into immediate values in the generated code, whereas a variable requires loading from memory or registers. Similar benefits apply in Java and C#, where final or const declarations facilitate these transformations, potentially improving execution speed without altering program semantics.[15][17]
With Literals
In computer programming, literals represent fixed, unnamed values directly embedded in the source code, such as the integer42 or the string "hello", serving as immediate data without requiring identifiers or storage allocation.[18] Constants, by contrast, provide named identifiers for these fixed values, allowing reuse across the codebase while ensuring immutability after initialization.[19] This distinction enables constants to encapsulate literals in a more structured manner, promoting code organization without altering the underlying fixed nature of the value.[18]
Using constants offers several advantages over scattering literals throughout the code, including simplified refactoring—where changing a single constant updates all references automatically—and reduced duplication of values that might otherwise appear in multiple places. For instance, declaring const int DAYS_IN_WEEK = 7; in C++ provides semantic clarity by naming the value, making it evident that it represents the number of days in a week, rather than relying on unexplained 7s in calculations like weekly totals.[18] This approach enhances readability and maintainability, as the intent behind the number becomes self-documenting.[19]
However, literals remain preferable for one-off uses due to their simplicity and lack of overhead, avoiding the need to define a name for values that appear only once.[18] Over-reliance on literals, particularly numerical ones without context, can introduce "magic numbers"—arbitrary values that obscure code meaning and complicate debugging or modification.[20]
A practical example appears in Python, where a constant like PI = 3.14159 can be defined for repeated use in geometric computations, contrasting with embedding the literal 3.14159 directly in a single expression such as area = 3.14159 * [radius](/page/Radius) ** 2, which forgoes reusability and clarity.[11]
# Using a constant
PI = 3.14159
area = PI * [radius](/page/Radius) ** 2
circumference = 2 * PI * [radius](/page/Radius)
# Using a literal (less maintainable for multiple uses)
area = 3.14159 * [radius](/page/Radius) ** 2
circumference = 2 * 3.14159 * [radius](/page/Radius)
# Using a constant
PI = 3.14159
area = PI * [radius](/page/Radius) ** 2
circumference = 2 * PI * [radius](/page/Radius)
# Using a literal (less maintainable for multiple uses)
area = 3.14159 * [radius](/page/Radius) ** 2
circumference = 2 * 3.14159 * [radius](/page/Radius)
With Macros
Macros in programming languages, particularly in C and C++, are defined using preprocessor directives such as#define PI 3.14159, which instruct the preprocessor to perform textual substitution of the identifier with its value before the compilation process begins.[21] This mechanism replaces the macro name with its expansion in the source code, effectively treating it as a named literal without any associated type information, in contrast to typed constants that are evaluated and checked during compilation.[22]
Unlike constants, macros lack type safety, meaning the compiler does not verify the type of the substituted value, which can lead to unintended behaviors such as implicit type conversions or errors that only manifest at runtime.[23] For instance, in C++, a const double pi = 3.14159; declaration ensures type checking and prevents misuse, whereas a macro like #define PI 3.14159 could be substituted into contexts expecting an integer, potentially causing precision loss without compiler warnings.[22] Additionally, macros can introduce side effects when used in expressions; for example, a macro defined as #define SQUARE(x) x*x expands SQUARE(1+2) to 1+2*1+2, evaluating to 5 instead of the expected 9 due to operator precedence and multiple evaluations of the argument.[21] This lack of evaluation control and the difficulty in debugging expanded code—since source-level debuggers operate on post-preprocessing code—make macros prone to subtle errors.[24]
In the evolution of programming languages, modern designs increasingly favor constants over macros to enhance code reliability and maintainability through built-in type systems and compiler enforcement.[25] However, macros persist in performance-critical domains like embedded systems, where their zero-runtime overhead and ability to inline code without function call costs are advantageous for resource-constrained environments.[26] This preference for constants aligns with their compile-time evaluation in many languages, similar to certain constant types.[23]
Types of Constants
Compile-Time Constants
Compile-time constants are values whose values are fully determined and fixed during the compilation phase of a program, prior to execution. In languages like C++, these are often specified using theconstexpr keyword, which ensures that expressions involving literals, certain functions, and operations can be evaluated at compile time, enabling their use in contexts such as template arguments, array sizes, and enumerator values. Similarly, in C#, constants declared with the const modifier represent compile-time literal values of built-in types, which the compiler substitutes directly into the intermediate language (IL) code, eliminating any runtime storage or access. In Java, compile-time constant expressions include primitive literals, strings, and certain final static fields initialized with constant expressions, as defined in the Java Language Specification (JLS §15.28). Enums in these languages also typically qualify as compile-time constants, providing named sets of fixed values resolvable before runtime.
A primary benefit of compile-time constants is the facilitation of compiler optimizations, such as constant folding—where arithmetic operations on constants are precomputed—and code specialization, which replaces constant expressions with their evaluated results to reduce runtime overhead. For instance, using a compile-time constant for array sizes allows the compiler to allocate fixed memory statically, avoiding dynamic allocation checks, while in switch statements, it enables exhaustive case analysis and potential dead-code elimination at compile time. This leads to smaller, faster executables by inlining values and minimizing branches, as the compiler can perform strength reduction, like optimizing division by a known constant into multiplication by a reciprocal. Early error detection is another advantage, as invalid constant expressions trigger compilation failures rather than runtime exceptions.
Examples illustrate these concepts across languages. In Java, a class-level declaration like public static final int MAX_USERS = 100; creates a compile-time constant usable in array declarations such as int[] users = new int[MAX_USERS]; or switch cases, where the value is inlined by the compiler. In C++, constexpr int MAX_USERS = 100; permits advanced computations, such as constexpr int BUFFER_SIZE = MAX_USERS * 2;, which can initialize static arrays like int buffer[BUFFER_SIZE]; without runtime evaluation. C# employs public const int MAX_USERS = 100; similarly, embedding the value directly in calling code for efficiency in loops or conditions.
However, compile-time constants have limitations rooted in their pre-runtime nature. They cannot depend on dynamic inputs, such as user-provided values or runtime function calls like std::time(nullptr) in C++, which would invalidate compile-time evaluation. Only specific types—built-in primitives, strings, or literal types in C++—are supported; user-defined or reference types beyond strings are generally excluded to ensure full resolvability. Additionally, changes to these constants often require recompilation of dependent code, as their values are baked into the binary, preventing flexibility for runtime variability.
Runtime Constants
Runtime constants are values that are initialized once during program execution, typically at startup, but remain immutable thereafter, preventing reassignment or modification throughout the program's lifetime.[27][28] This approach bridges the gap between fixed compile-time values and fully dynamic variables, allowing initialization based on runtime conditions such as user input or external data sources while enforcing immutability to promote code reliability and thread safety. Common use cases for runtime constants include storing environment-specific configurations, such as database connection URLs or API endpoints, which are loaded from configuration files or environment variables at program launch.[29] This ensures that sensitive or deployment-varying data is set once without risking accidental changes during execution, facilitating easier maintenance across different environments like development, testing, and production. In Java, non-staticfinal fields serve as runtime constants when their values are assigned in constructors or instance initializers rather than at declaration. For example:
public class DatabaseConfig {
private final [String](/page/String) url;
public DatabaseConfig([String](/page/String) configUrl) {
this.url = configUrl; // Set once in constructor
}
public [String](/page/String) getUrl() {
return url;
}
}
public class DatabaseConfig {
private final [String](/page/String) url;
public DatabaseConfig([String](/page/String) configUrl) {
this.url = configUrl; // Set once in constructor
}
public [String](/page/String) getUrl() {
return url;
}
}
url field cannot be reassigned, compiling only if set in every constructor.[27] Similarly, in C#, readonly fields are initialized at declaration or in constructors and cannot be modified afterward, as shown below:
public class DatabaseConfig {
private readonly string url;
public DatabaseConfig(string configUrl) {
this.url = configUrl; // Assigned in constructor
}
public string GetUrl() {
return url;
}
}
public class DatabaseConfig {
private readonly string url;
public DatabaseConfig(string configUrl) {
this.url = configUrl; // Assigned in constructor
}
public string GetUrl() {
return url;
}
}
config.py might define:
# config.py
import os
DATABASE_URL = os.environ.get('DB_URL', 'default://localhost') # Set on import
# config.py
import os
DATABASE_URL = os.environ.get('DB_URL', 'default://localhost') # Set on import
import config; config.DATABASE_URL.[30]
Unlike compile-time constants, which enable optimizations like constant folding and inlining by the compiler, runtime constants permit conditional logic or external data for initialization but forgo such performance benefits in exchange for greater flexibility.[28]
Dynamically-Valued Constants
The term "dynamically-valued constants," introduced by Schilling (1995), refers to constants whose values are computed once at runtime—potentially deferred until first use via mechanisms like memoization—but remain immutable thereafter, extending the concept of runtime constants to support more flexible initialization without recomputation on subsequent accesses.[31] This allows for efficient handling of complex or conditional values while preserving immutability semantics, common in languages supporting lazy evaluation or deferred computation.[32][33] In Haskell, lazy evaluation implements this via top-level definitions orlet bindings, where an expression is evaluated on first demand using call-by-need semantics and the result cached for all future uses, ensuring constancy. For example, defining fib = 0 : 1 : zipWith (+) fib ([tail](/page/Tail) fib) creates an infinite Fibonacci sequence that is computed incrementally as elements are accessed, but each value is fixed once calculated. In languages like JavaScript, const declarations provide binding immutability, though assigning to mutable structures (e.g., objects) allows internal changes, which may not fully enforce value constancy unless combined with freezing mechanisms like Object.freeze(). For instance:
const config = Object.freeze({ apiUrl: 'https://example.com' });
config.apiUrl = 'https://new-example.com'; // [Mutation](/page/Mutation) prevented
const config = Object.freeze({ apiUrl: 'https://example.com' });
config.apiUrl = 'https://new-example.com'; // [Mutation](/page/Mutation) prevented
Constants in Specific Contexts
Function Parameters
In computer programming, function parameters can be designated as constants to ensure they remain unmodified within the function body, thereby enforcing immutability at the interface level. This is commonly achieved through language-specific qualifiers, such as theconst keyword in C++ for reference parameters, as in the declaration void func(const int& x), where x is a reference to an integer that the function cannot alter.[38] Such qualifiers bind the parameter to a read-only view of the argument, preventing accidental or intentional modifications while allowing efficient access to the original data.[38]
The primary benefits of constant function parameters include enabling compiler optimizations, such as avoiding unnecessary copies of large objects and facilitating function inlining, which can reduce runtime overhead by substituting the function body directly at the call site.[38] Additionally, marking parameters as constant signals to callers that the function will not modify the inputs, promoting clearer API contracts and reducing debugging efforts by catching modification attempts at compile time.[39] In multi-threaded environments, constant parameters are particularly valuable in APIs, as they indicate that the function performs only reads on the input, contributing to thread safety by minimizing the risk of data races without requiring additional synchronization mechanisms.[40]
For example, in Java, method parameters can be declared with the final modifier, such as public void process(final int value), which prohibits reassigning the local parameter variable within the method, though it does not affect the underlying object if the parameter is a reference type. This practice is especially useful in recursive methods, where final parameters help avoid accidental overwrites that could lead to incorrect stack frame states or infinite recursion due to altered arguments across calls.[41]
A key variation involves passing constants by reference rather than by value, which enhances efficiency by avoiding the overhead of copying data—particularly for complex types like strings or containers—while still guaranteeing non-modification through the const qualification.[38] This approach, exemplified in C++ with const T& parameters, balances performance and safety without transferring ownership of the argument.[38]
Object-Oriented Programming
In object-oriented programming, class constants serve as shared immutable values accessible to all instances of a class, facilitating the definition of fixed attributes such as configuration parameters or universal constants that remain consistent across the program's execution. These constants, typically declared as static and final, belong to the class itself rather than individual objects, promoting efficient memory usage by storing a single copy in memory that all instances reference. In contrast, instance constants are immutable fields tied to specific objects, allowing each instance to maintain its own fixed value, such as a unique identifier set during object creation, without affecting other instances. This distinction supports encapsulation by preventing unintended modifications while enabling reusable, stable state management within class hierarchies.[42] Regarding inheritance, constants defined in a base class are accessible to subclasses if they are public or protected, allowing derived classes to utilize the immutable values without redeclaration, which enhances code reusability and maintains consistency in polymorphic structures. For example, in languages like Java, subclasses inherit static final constants from superclasses, but these cannot be overridden due to their final nature, ensuring the base class's invariants are preserved across the inheritance chain. Similarly, in C++, static constants are inherited by derived classes and can be accessed via the class scope, though a derived class can declare its own static constant with the same name (resulting in name hiding), without altering the base class constant, thereby preserving immutability. This mechanism supports hierarchical design by propagating shared constants downward while protecting against alterations that could break subclass behavior.[43][44] Constants are integral to several design patterns in object-oriented programming, particularly in singletons and factories, where they provide reliable configuration values that ensure encapsulation and predictability. In the singleton pattern, class constants can define initialization parameters for the single instance, guaranteeing that shared resources like database connections use unchanging settings across the application. Likewise, in the factory method pattern, constants configure object creation logic, such as selecting implementation types based on environmental factors like operating system identifiers, thereby allowing subclasses to specialize production without altering core invariants. These uses reinforce modularity by centralizing immutable decisions outside mutable instance logic.[45][46] A key challenge in using constants within multi-threaded object-oriented environments is ensuring thread-safety, though immutable constants inherently mitigate many risks due to their unchangeable nature. Since class and instance constants cannot be modified post-initialization, multiple threads can safely read them concurrently without synchronization overhead, avoiding race conditions that plague mutable shared state. However, care must be taken during initialization to prevent partial visibility issues in concurrent access; for instance, using final fields in Java ensures atomicity and visibility across threads once the object is fully constructed. This property makes constants preferable for thread-safe shared data in OOP applications, provided initialization follows language-specific concurrency guidelines.[47]By Programming Paradigm
In procedural programming, constants are typically implemented as simple named immutable values that can be used globally throughout a program to promote code readability and prevent accidental modification. Languages like C employ theconst qualifier to declare such immutables, including for structs and pointers, ensuring that the qualified objects remain unchanged during execution and aiding in defensive programming practices. This approach aligns with the paradigm's focus on sequential execution and explicit state management, where constants serve as fixed references without enforcing broader immutability across the entire program.
Functional programming places a strong emphasis on immutability as a core principle, treating data as constant by default to enable pure functions—those that produce the same output for the same inputs without side effects—and facilitate referential transparency. In this paradigm, constant inputs and outputs are integral to composing functions predictably, often extending to data structures that cannot be altered post-creation, which simplifies reasoning about program behavior and supports parallelism. For instance, in Lisp dialects like Common Lisp, constants are defined using the defconstant macro, creating global variables whose values cannot be rebound, building on the language's atomic data types that represent unchanging, self-evaluating values.[48][49] Modern functional influences appear in languages like Rust, where const fn (constant functions) allow compile-time evaluation of expressions, enforcing immutability to prevent data races and enhance safe concurrency by ensuring shared data remains constant across threads.[50]
Declarative programming, which specifies what results are desired rather than how to compute them, handles constants primarily through configuration values or parameterized queries that minimize mutable state altogether. In database contexts like SQL, constants appear as literal values in queries or as bind parameters that substitute fixed inputs at runtime, promoting reusability and security by avoiding direct embedding of sensitive or repeated values. This paradigm's reduced reliance on mutable variables means constants often serve declarative goals, such as defining schema constraints or query filters, without procedural side effects.[51][52]
Implementation and Conventions
Language Examples
In C and C++, theconst keyword declares variables that cannot be modified after initialization, allowing for runtime constants, while constexpr (introduced in C++11) enables compile-time evaluation for more efficient constant expressions. For example, a compile-time constant might be defined as constexpr int MAX_SIZE = 100;, which the compiler evaluates during compilation. Enumerations provide another mechanism for named constants, as in:
enum Color { RED, GREEN, BLUE };
enum Color { RED, GREEN, BLUE };
RED evaluates to 0, GREEN to 1, and BLUE to 2 by default, serving as integer constants.
In Java, class-level constants are typically declared using public static final, ensuring immutability and shared access across instances without requiring object creation.[42] For instance:
public class MathConstants {
public static final double PI = 3.14159;
}
public class MathConstants {
public static final double PI = 3.14159;
}
MathConstants.PI to be used throughout the program as an unchangeable value. Final variables can also be set at runtime within constructors, providing instance-specific constants that remain immutable post-construction.[53] An example is:
public class Point {
private final int x;
public Point(int xValue) {
this.x = xValue; // Set once in constructor
}
}
public class Point {
private final int x;
public Point(int xValue) {
this.x = xValue; // Set once in constructor
}
}
MAX_RETRIES = 5 # Intended as constant
MAX_RETRIES = 5 # Intended as constant
const for compile-time constants that are always immutable and can be used in any scope, with the borrow checker ensuring memory safety by preventing invalid references even in constant contexts.[55][56] For example:
const MAX_POINTS: u32 = 100_000;
const MAX_POINTS: u32 = 100_000;
const for compile-time constants and supports iota for automatically incrementing enum-like values within a constant block, simplifying the definition of sequential constants.[57] An illustration is:
const (
Sunday = iota // 0
Monday // 1
Tuesday // 2
)
const (
Sunday = iota // 0
Monday // 1
Tuesday // 2
)
#ifdef to select architecture-specific values. For example:
#ifdef WINDOWS
#define PATH_SEPARATOR '\\'
#else
#define PATH_SEPARATOR '/'
#endif
#ifdef WINDOWS
#define PATH_SEPARATOR '\\'
#else
#define PATH_SEPARATOR '/'
#endif
Naming Conventions
In many programming languages, constants are named using all uppercase letters with underscores separating words, a style known as screaming snake case or UPPERCASE_WITH_UNDERSCORES, to visually distinguish them from mutable variables which often use lowercase or camelCase. For instance, in Python, the official style guide recommends this convention for module-level constants, such asMAX_BUFFER_SIZE, to indicate immutability and improve code readability.[54] Similarly, in C and traditional C++ usage, macro-defined constants like #define PI 3.14159 follow this uppercase convention to differentiate them from function or variable names in lowercase_with_underscores.[58] This practice originated from early C conventions where uppercase signaled preprocessor macros or fixed values, aiding quick scanning of code.[59]
In contrast, languages like Java and C# favor PascalCase for constants, capitalizing the first letter of each word without underscores, such as MaxBufferSize in Java for public static final fields.[60] Microsoft's C# guidelines specify PascalCase for both constant fields and local constants, aligning with the language's overall casing for types and properties to maintain consistency, while variables use camelCase like maxBufferSize.[61] Google's C++ style guide deviates slightly, recommending a leading 'k' prefix followed by CamelCase for constexpr or const variables with static storage duration, e.g., kDaysInAWeek, to explicitly mark compile-time fixed values without relying solely on case.[62] These variations stem from language-specific design philosophies, where the goal is to signal constancy through casing that contrasts with variable naming patterns, reducing cognitive load for developers.[60]
Best practices emphasize descriptive names that convey purpose without ambiguity, such as MAX_CONNECTIONS_PER_USER instead of vague abbreviations like MCPU, unless the shorthand is universally recognized like PI for the mathematical constant.[54] Abbreviations should be avoided to prevent confusion, prioritizing full words for maintainability, as recommended in Python's PEP 8 and Java's code conventions.[54][60] Related constants should be grouped logically, often within enums, namespaces, or dedicated modules, to enhance organization—for example, clustering HTTP status codes like HTTP_OK and HTTP_NOT_FOUND in a single file or class.[61] This grouping facilitates refactoring and comprehension, aligning with broader clean code principles that treat names as self-documenting elements.[11]
In functional programming languages like Haskell, where immutability is the default, constants lack a distinct casing convention and typically follow the general variable naming rules, using lowercase or camelCase such as pi or maxBufferSize, to emphasize purity without special visual markers.[63] This approach reflects the paradigm's focus on all bindings as effectively constant within their scope, avoiding the need for emphatic styles used in imperative languages.[64]