Operator in programming

In programming, an operator is a command denoting a specific mathematical or logical action performed on data (operands). It is the smallest autonomous element of a computer program. Essentially, any computer program is a sequence of operators. A close analogue of operators in natural languages ​​are the phrases or sentences that make up text. 

Each operator has its own syntax and semantics (content, meaning). Depending on the specific language, operator syntax can vary significantly, although in general, symbols with the same or similar meaning in mathematics or formal logic are used to denote a particular operation. 

Why are operators needed in programming?

A computer program is an algorithm, a sequence of specific actions performed on data. It is created by a human, but executed by a computer, so it must be understandable to both. Therefore, simply describing a specific operation, say, assigning a value to a variable, in ordinary (natural) language, while theoretically possible, is very difficult in practice. For a human, such code would be extremely cumbersome and difficult to understand, making writing any significant program impossible. And for the code to be understood by a computer, a complex compiler would have to be developed to translate it into machine language.  

Therefore, symbols used in similar languages ​​for mathematical expressions and formal logic were adopted to denote operations in programming. These symbols became the basis for the syntax of operators in the vast majority of modern programming languages. Thus, operators in programming perform the following functions:

• simplify and shorten the code, making it more understandable for human perception;
• denote a specific operation on data in such a way that it can be easily translated into machine code.

An additional advantage of using operators is the program’s ease of understanding by humans, regardless of their natural language. This is achieved through the universality of mathematical and logical symbols. 

General property of operators

All operators in programming have one thing in common: they are executable. Essentially, they are instructions that a computer must follow to process data and execute a program. The operator itself is a pure mathematical or logical abstraction, not referring to any specific objects like memory cells. Throughout the program’s execution, it remains unchanged, but the data contained in the computer’s memory changes. In other words, these information changes constitute the execution of the command designated by the operator.  

Types of operators in programming

Different programming languages ​​have their own systems of operators and operations. But in general, they can be classified into several basic types. 

The assignment operator. It’s used when you need to assign a specific value to a variable. This means indicating to the program that a given memory location, designated by a name, contains specific data that will be used during code execution. In most programming languages, the assignment algorithm uses the equal sign. For example, in Python, this operation looks like this:

x = 365, where x is the name of the variable, 365 is its value, and “=” is the assignment sign.

Arithmetic operators. This is a group of operators that denote mathematical operations on data. In most programming languages, they are denoted by symbols used for the same meaning as conventional arithmetic operators, although some may have their own notation—for example:

• “-” – subtraction;
• “+” – addition;
• “*” – multiplication;
• “/” — division without remainder;
• “-” – decrease;
• “++” – increase.

The last two operators in this list are used in the C language and denote decreasing or increasing the operand by 1. In other languages, this operation is written, for example, as follows: x = x + 1 or x = x – 1.

Logical operators. They help establish relationships between different data and/or define the conditions under which certain actions will be performed. A key concept for understanding them is the “true/false” relationship. Logical operators are based on formal logic in their semantics and syntax. Their notation varies across programming languages, not only symbolically but also literally—for example:

• The “AND” operator compares multiple values ​​with each other and produces a true/false result, which determines the further execution of the program. A true result is only possible if all values ​​are true. It is denoted by the word “and” or the signs &, &&. 
• The “OR” operator also compares multiple values ​​with each other. It differs from the previous one in that it returns “false” only if all the compared values ​​are false. It is denoted by the word “or” and the || sign.
• The “NOT” operator is used to change a value to its opposite, that is, “true” to “false” and vice versa. In programming, it is denoted by the exclamation mark “!”.

Comparison operators. These are often used in conjunction with logical operators to compare different values ​​with each other, resulting in a true/false result. For example, in C, they are represented by the following symbols:

• “>” — more;
• “<” – less;
• “>=” — greater than or equal to;
• “<=” – less than or equal;
• “==” – equal;
• “!=” — not equal.

In addition to these basic operators, programming uses others, and their set can vary significantly depending on the language, which affects the capabilities of the programming language and the flexibility of the code written in it. Operators denoted by words or symbols often coexist within the same language. For example, in Pascal, alongside the symbolic assignment operator “:=”, there is an unconditional jump operator “goto,” written in Latin letters. 

All of the above commands are simple, meaning they represent a single, specific operation with data. In addition, programming also uses compound operators, meaning operators consisting of several simple ones. Accordingly, they have special notations for correct programming:

• The boundaries of a compound statement can be indicated in various languages ​​by curly braces (in C or C++), the words “begin” and “end”.
• A separator that separates simple operators that are part of a complex operator.

Compound operators first appeared in the Algol language, from which they were inherited by many other languages, such as Pascal, C, C++, etc. They allow the use of multiple operators where a single one is expected—for example, in branching operations. Compound operators allow you to simplify program code and streamline its execution. An example of writing a compound conditional “switch” operator (replacing multiple simple “if” statements in C):

switch(ii)

   {

   case 1: Buf_1[Pok-f+i]= Prognoz; break;

   case 2: Buf_2[Pok-f+i]= Prognoz; break;

   case 3: Buf_3[Pok-f+i]= Prognoz; break;

   }

According to their purpose in the program structure, operators can be divided into the following main types:

Choice statements. These are used when a program requires a choice between a number of values, depending on which further execution or non-execution occurs. In other words, they indicate branching in an algorithm. A typical example is the “if” statement in C, which divides a program into two scenarios depending on whether the condition specified in it is met or not. 

Loop operators. These operators are used to denote repeated operations (loops) in a program. They also contain conditions or parameters that, when met, cause the loop to repeat. In Pascal, such an operator is “while.” For example, the construct “while B do S” translates into natural language as follows: while the logical expression (condition) B is true, the program will execute loop S until B becomes false. Depending on how the condition is used, loop operators can be divided into three groups:

• with a precondition – that is, a condition that must be met for the cycle to be carried out;
• In a statement with a postcondition, the situation is the opposite: when the condition is met, the cycle will end;
• In an operator with a parameter (variable), a variable value is entered that determines the final number of repetitions of the loop.

Procedure call operators. In programming, a procedure is a subroutine (a functional block within the main program). A procedure call operator initiates its start and determines its completion when the desired results are achieved. This makes a program more understandable, and its execution more consistent and error-free. 

Jump operators. They redirect program execution to a specific fragment of code marked with a special label. Jump operators allow you to create functioning algorithms with complex structures. A typical example of such an operator in Pascal is the unconditional “goto” operator. Other operators include the “break” operator for terminating a loop, the “continue” operator for terminating its current operation, and the “exit” operator for terminating the entire program. Similar operators are present in other programming languages, such as C, C++, Java, and others.

The order of execution of operators

To use operators correctly in programming, it’s important to set the correct order of their execution. The standard order is for simple and complex operators to be executed sequentially, top to bottom (if located on different lines) and right to left (on the same line). This is how they should be reflected in the program code. Simple operators within a complex (multiple) operator are executed according to the same principle. However, this sequencing principle isn’t the only one: some programming languages ​​allow for more flexible configuration. This often leads to a more complex program structure.

Operators in programming are thus one of the most important components of code, the minimal functional unit without which even the simplest program cannot be executed. To use them effectively, it is necessary to strictly adhere to the syntax rules defined in a specific language, understand the meaning of the operations being performed, and correctly specify the sequence of their execution.