Increment and decrement operators are
unary operators that ''add'' or ''subtract'' one, to or from their
operand
In mathematics, an operand is the object of a mathematical operation, i.e., it is the object or quantity that is operated on.
Example
The following arithmetic expression shows an example of operators and operands:
:3 + 6 = 9
In the above exam ...
, respectively.
They are commonly implemented in
imperative programming language
A programming language is a system of notation for writing computer programs. Most programming languages are text-based formal languages, but they may also be graphical. They are a kind of computer language.
The description of a programming ...
s.
C-like languages feature two versions (pre- and post-) of each operator with slightly different semantics.
In languages syntactically derived from
B (including C and its various derivatives), the increment operator is written as
++
and the decrement operator is written as
--
. Several other languages use inc(x) and dec(x) functions.
The increment operator increases, and the decrement operator decreases, the value of its operand by 1. The operand must have an arithmetic or
pointer data type
In computer science and computer programming, a data type (or simply type) is a set of possible values and a set of allowed operations on it. A data type tells the compiler or interpreter how the programmer intends to use the data. Most progra ...
, and must refer to a modifiable
data object
In computer science, an object can be a variable, a data structure, a function, or a method. As regions of memory, they contain value and are referenced by identifiers.
In the object-oriented programming paradigm, ''object'' can be a combinati ...
. Pointers values are increased (or decreased) by an amount that makes them point to the next (or previous) element adjacent in memory.
In languages that support both versions of the operators:
* The ''pre''-increment and ''pre''-decrement operators increment (or decrement) their operand by 1, and the value of the expression is the resulting incremented (or decremented) value.
* The ''post''-increment and ''post''-decrement operators increase (or decrease) the value of their operand by 1, but the value of the expression is the operand's value ''prior'' to the increment (or decrement) operation.
In languages where increment/decrement is not an expression (e.g.,
Go), only one version is needed (in the case of Go, post operators only).
Since the increment/decrement operator modifies its operand, use of such an operand more than once within the same expression can produce undefined results. For example, in expressions such as
x - ++x
, it is not clear in what sequence the subtraction and increment operations should be performed. Such expressions generally invoke
undefined behavior, and should be avoided.
In languages with typed pointers like C,
the increment operator steps the pointer to the next item of that type -- increasing the value of the pointer by the size of that type.
When a pointer (of the right type) points to any item in an array, incrementing (or decrementing) makes the pointer point to the "next" (or "previous") item of that array.
When a pointer has a type of pointer-to-integer,
incrementing that pointer makes it point to the next integer (typically increasing it by 4 bytes).
When a pointer has a type pointer-to-employee, incrementing that pointer makes it point to the next "employee" -- if the size of the employee structure is 106 bytes, incrementing that pointer increases it by 106 bytes.
Examples
The following C code fragment illustrates the difference between the ''pre'' and ''post'' increment and decrement operators:
int x;
int y;
// Increment operators
// Pre-increment: x is incremented by 1, then y is assigned the value of x
x = 1;
y = ++x; // x is now 2, y is also 2
// Post-increment: y is assigned the value of x, then x is incremented by 1
x = 1;
y = x++; // y is 1, x is now 2
// Decrement operators
// Pre-decrement: x is decremented by 1, then y is assigned the value of x
x = 1;
y = --x; // x is now 0, y is also 0
// Post-decrement: y is assigned the value of x, then x is decremented by 1
x = 1;
y = x--; // y is 1, x is now 0
In languages lacking these operators, equivalent results require an extra line of code:
# Pre-increment: y = ++x
x = 1
x = x + 1 # x is now 2 (can be written as "x += 1" in Python)
y = x # y is also 2
# Post-increment: y = x++
x = 1
y = x # y is 1
x = x + 1 # x is now 2
The post-increment operator is commonly used with
array subscripts. For example:
// Sum the elements of an array
float sum_elements(float arr[], int n)
The post-increment operator is also commonly used with pointer (computer programming), pointers:
// Copy one array to another
void copy_array(float *src, float *dst, int n)
Note that these examples also work in other C-like languages, such as
C++,
Java
Java (; id, Jawa, ; jv, ꦗꦮ; su, ) is one of the Greater Sunda Islands in Indonesia. It is bordered by the Indian Ocean to the south and the Java Sea to the north. With a population of 151.6 million people, Java is the world's mo ...
, and
C#.
*Increment operator can be demonstrated by an example:
#include
int main()
**Output:
2
4
Supporting languages
The following list, though not complete or all-inclusive, lists some of the major programming languages that support the
++
/
--
increment/decrement operators.
*
ABAP
*
AWK
*
Bash
Bash or BASH may refer to:
Arts and entertainment
* ''Bash!'' (Rockapella album), 1992
* ''Bash!'' (Dave Bailey album), 1961
* '' Bash: Latter-Day Plays'', a dramatic triptych
* ''BASH!'' (role-playing game), a 2005 superhero game
* "Bash" ('' ...
*
C
*
C++
*
C#
*
CFML
*
D
*
Go
*
Java
Java (; id, Jawa, ; jv, ꦗꦮ; su, ) is one of the Greater Sunda Islands in Indonesia. It is bordered by the Indian Ocean to the south and the Java Sea to the north. With a population of 151.6 million people, Java is the world's mo ...
*
JavaScript
JavaScript (), often abbreviated as JS, is a programming language that is one of the core technologies of the World Wide Web, alongside HTML and CSS. As of 2022, 98% of websites use JavaScript on the client side for webpage behavior, of ...
*
Objective-C
*
GNU Octave
GNU Octave is a high-level programming language primarily intended for scientific computing and numerical computation. Octave helps in solving linear and nonlinear problems numerically, and for performing other numerical experiments using a lan ...
*
PARI/GP
PARI/GP is a computer algebra system with the main aim of facilitating number theory computations. Versions 2.1.0 and higher are distributed under the GNU General Public License. It runs on most common operating systems.
System overview
The ...
*
Perl
Perl is a family of two high-level, general-purpose, interpreted, dynamic programming languages. "Perl" refers to Perl 5, but from 2000 to 2019 it also referred to its redesigned "sister language", Perl 6, before the latter's name was offic ...
*
PHP
*
PowerShell
*
Vala
* Vex, a scripting language in the software Houdini
*
Wolfram Language
(Apple's
Swift once supported these operators,
but support was removed as of version 3.)
Pascal
Pascal, Pascal's or PASCAL may refer to:
People and fictional characters
* Pascal (given name), including a list of people with the name
* Pascal (surname), including a list of people and fictional characters with the name
** Blaise Pascal, Frenc ...
,
Delphi,
Modula-2, and
Oberon provide the same functions, but they are called inc(x) and dec(x).
Notably
Python and
Rust do not support these operators.
History
The concept was introduced in the
B programming language circa 1969 by
Ken Thompson.
Thompson went a step further by inventing the ++ and -- operators, which increment or decrement; their prefix or postfix position determines whether the alteration occurs before or after noting the value of the operand. They were not in the earliest versions of B, but appeared along the way. People often guess that they were created to use the auto-increment and auto-decrement address modes provided by the DEC PDP-11 on which C and Unix first became popular. This is historically impossible, since there was no PDP-11 when B was developed. The PDP-7, however, did have a few 'auto-increment' memory cells, with the property that an indirect memory reference through them incremented the cell. This feature probably suggested such operators to Thompson; the generalization to make them both prefix and postfix was his own. Indeed, the auto-increment cells were not used directly in implementation of the operators, and a stronger motivation for the innovation was probably his observation that the translation of ++x was smaller than that of x=x+1.
See also
*
Augmented assignment – for
+=
and
-=
operators
*
PDP-7
*
PDP-11
*
Successor function
References
{{Reflist
Operators (programming)
Unary operations