Constant (computer programming)

Last updated

In 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.

Contents

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, [lower-alpha 1] 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:

constfloatPI=3.1415927;// maximal single float precisionconstunsignedintMTU=1500;// Ethernet v2, RFC 894constunsignedintCOLUMNS=80;

Typical examples of run-time constants are values calculated based on inputs to a function, such as this C++ example:

voidf(std::strings){constsize_tl=s.length();// ...}

Use

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

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.1415926535constfloatpi2=3.1415926535;

while in Ada, there are universal numeric types that can be used, if desired:

pi:constant:=3.1415926535;pi2:constantfloat:=3.1415926535;

with the untyped variant being implicitly converted to the appropriate type upon each use. [2]

Dynamically-valued constants

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

floatfunc(constfloatANYTHING){constfloatXYZ=someGlobalVariable*someOtherFunction(ANYTHING);...}

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:

  1. It is clear to the reader that the object will not be modified further, once set
  2. 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
  3. 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

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

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

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 constpointer 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:

finalinti=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.

constinti=3;// C++ declarationi=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*constbar=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.

finalFooi;// 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++.

constFoo*bar;

Here bar can be modified to point anything, anytime; just that pointed value cannot be modified throughbar 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#

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

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. [lower-alpha 2] 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

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

Notes

  1. In some cases this can be circumvented, e.g. using self-modifying code or by overwriting the memory location where the value is stored.
  2. This is not universal: in Ada input parameters and loop parameters are implicitly constant, for instance.

Related Research Articles

Java and C++ are two prominent object-oriented programming languages. By many language popularity metrics, the two languages have dominated object-oriented and high-performance software development for much of the 21st century, and are often directly compared and contrasted. Java's syntax was based on C/C++.

In a computer language, a reserved word is a word that cannot be used as an identifier, such as the name of a variable, function, or label – it is "reserved from use". This is a syntactic definition, and a reserved word may have no user-defined meaning.

Generic programming is a style of computer programming in which algorithms are written in terms of data types to-be-specified-later that are then instantiated when needed for specific types provided as parameters. This approach, pioneered by the ML programming language in 1973, permits writing common functions or types that differ only in the set of types on which they operate when used, thus reducing duplicate code.

In object-oriented (OO) and functional programming, an immutable object is an object whose state cannot be modified after it is created. This is in contrast to a mutable object, which can be modified after it is created. In some cases, an object is considered immutable even if some internally used attributes change, but the object's state appears unchanging from an external point of view. For example, an object that uses memoization to cache the results of expensive computations could still be considered an immutable object.

In computer programming, a reference is a value that enables a program to indirectly access a particular datum, such as a variable's value or a record, in the computer's memory or in some other storage device. The reference is said to refer to the datum, and accessing the datum is called dereferencing the reference. A reference is distinct from the datum itself.

<span class="mw-page-title-main">C syntax</span> Set of rules defining correctly structured programs

The syntax of the C programming language is the set of rules governing writing of software in C. It is designed to allow for programs that are extremely terse, have a close relationship with the resulting object code, and yet provide relatively high-level data abstraction. C was the first widely successful high-level language for portable operating-system development.

This article compares two programming languages: C# with Java. While the focus of this article is mainly the languages and their features, such a comparison will necessarily also consider some features of platforms and libraries. For a more detailed comparison of the platforms, see Comparison of the Java and .NET platforms.

In the C++ programming language, a reference is a simple reference datatype that is less powerful but safer than the pointer type inherited from C. The name C++ reference may cause confusion, as in computer science a reference is a general concept datatype, with pointers and C++ references being specific reference datatype implementations. The definition of a reference in C++ is such that it does not need to exist. It can be implemented as a new name for an existing object.

In some programming languages, const is a type qualifier, which indicates that the data is read-only. While this can be used to declare constants, const 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.

The computer programming languages C and Pascal have similar times of origin, influences, and purposes. Both were used to design their own compilers early in their lifetimes. The original Pascal definition appeared in 1969 and a first compiler in 1970. The first version of C appeared in 1972.

In the Java programming language, the final keyword is used in several contexts to define an entity that can only be assigned once.

In a programming language, an evaluation strategy is a set of rules for evaluating expressions. The term is often used to refer to the more specific notion of a parameter-passing strategy that defines the kind of value that is passed to the function for each parameter and whether to evaluate the parameters of a function call, and if so in what order. The notion of reduction strategy is distinct, although some authors conflate the two terms and the definition of each term is not widely agreed upon.


A class in C++ is a user-defined type or data structure declared with any of the keywords class, struct or union that has data and functions as its members whose access is governed by the three access specifiers private, protected or public. By default access to members of a C++ class declared with the keyword class is private. The private members are not accessible outside the class; they can be accessed only through member functions of the class. The public members form an interface to the class and are accessible outside the class.

this, self, and Me are keywords used in some computer programming languages to refer to the object, class, or other entity which the currently running code is a part of. The entity referred to thus depends on the execution context. Different programming languages use these keywords in slightly different ways. In languages where a keyword like "this" is mandatory, the keyword is the only way to access data and methods stored in the current object. Where optional, these keywords can disambiguate variables and functions with the same name.

The C and C++ programming languages are closely related but have many significant differences. C++ began as a fork of an early, pre-standardized C, and was designed to be mostly source-and-link compatible with C compilers of the time. Due to this, development tools for the two languages are often integrated into a single product, with the programmer able to specify C or C++ as their source language.

C++11 is a version of the ISO/IEC 14882 standard for the C++ programming language. C++11 replaced the prior version of the C++ standard, called C++03, and was later replaced by C++14. The name follows the tradition of naming language versions by the publication year of the specification, though it was formerly named C++0x because it was expected to be published before 2010.

In computer programming, an anonymous function is a function definition that is not bound to an identifier. Anonymous functions are often arguments being passed to higher-order functions or used for constructing the result of a higher-order function that needs to return a function. If the function is only used once, or a limited number of times, an anonymous function may be syntactically lighter than using a named function. Anonymous functions are ubiquitous in functional programming languages and other languages with first-class functions, where they fulfil the same role for the function type as literals do for other data types.

This article describes the syntax of the C# programming language. The features described are compatible with .NET Framework and Mono.

This article compares a large number of programming languages by tabulating their data types, their expression, statement, and declaration syntax, and some common operating-system interfaces.

In the C, C++, and D programming languages, a type qualifier is a keyword that is applied to a type, resulting in a qualified type. For example, const int is a qualified type representing a constant integer, while int is the corresponding unqualified type, simply an integer. In D these are known as type constructors, by analogy with constructors in object-oriented programming.

References

  1. Ex. IBM Systems Information. Instruction Set - Assembler Language Reference for PowerPC.
  2. Booch, Grady (1983). Software Engineering with Ada . Benjamin Cummings. pp.  116–117. ISBN   0-8053-0600-5.
  3. 1 2 3 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.
  4. 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.
  5. 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.
  6. "Oracle Technology Network for Java Developers | Oracle Technology Network | Oracle". Java.sun.com. 2013-08-14. Retrieved 2013-08-18.
  7. Microsoft Office XP Developer: Constant Names