This article is a continuation of the tutorial Operators in C Part 2. It will discuss the next unary operators, the cast operator, the multiplicative and additive operators, the bitwise shift operators and the relational operators.
Unary Arithmetic Operators
There are four unary arithmetic operators:
1. Unary minus ()
2. Unary plus (+)
3. Bitwise Complement (~)
4. Logical Negation Operator (!)
Unary Minus Operator
The unary minus operator precedes a numerical constant, variable or expression and negates its value. It is different from the subtraction operator () which requires two separate operands.
The operand of the unary minus operator must belong to the arithmetic data type domain. The arithmetic type domain consists of the Integer data types and the Floating point data types. The Integer data types consists of char
, the signed
and the unsigned integer types
and the enumerated types
. The floating point types are float and double
types. Each of these arithmetic types belong to one type domain — the real type (stores values that are real numbers) or the complex types (stores values that are complex numbers).
Unary Plus Operator
The unary plus operator also precedes a numerical constant, variable or expression. The result of the unary (+) operator is the value of its operand. The operand of the unary (+) operator should also belong to the arithmetic type domain.
Bitwise Complement Operator
The bitwise complement operator (~) causes the bits to get inverted or reversed; ie, 1s become 0s and 0s become 1s. The operand must be an integer type quantity (char, signed and unsigned integer types and the enumerated types).
Logical Negation Operator
The logical negation operator (!) negates the value of a logical expression; ie, it causes an expression that is originally true to become false and vice versa. The result of the logical negation operator has type int
. The result of ! is 0 if the value of the operand, which is a logical expression, is unequal to 0, and the result is 1 if the value of the operand is equal to 0.
The operand of the logical negation operator must belong to a scalar type. The scalar type domain consists of the arithmetic types (Integer and Floating types) and the pointer type.
Example: suppose i and f are integer variables where i=7
and f=5
, then the true logical expresion (i>f)
becomes false when the logical negation operator is applied to it; ie, !(i>f) evaluates to 0(false).
The sizeof and alignof Operators
The sizeof operator yields the memory occupied by its operand in bytes. The operand may either be an expression or a data type name.
Syntax: sizeof(operand);
The data type can be one of the integer types , a pointer type or even a structure or union type. When sizeof is applied to an operand with type char
, signed char
or unsigned char
the result is 1. If it is applied to an array, the result is the total number of bytes required by the array elements. If it is applied to a structure/union the result is the sum of the number of bytes required by each member of the structure/union. The value of the result is implementationdefined and its type (an unsigned integer type) is size_t
defined in stddef.h
(and other header files).
The alignof operator yields the alignment required of its operand type. An alignment is an implementationdefined integer value representing the number of bytes between successive addresses at which a given object can be allocated. The data type of an object imposes an alignment requirement on every object of that type. Stricter alignment can be requested using the _Alignas
keyword.
A fundamental alignment is less than or equal to the greatest alignment supported by the implementation (the target machine/platform) which is equal to alignof(max_align_t)
.
An extended alignment is greater than alignof(max_align_t)
. It is implementationdefined whether extended alignments are supported or not.
Alignments are represented as values of type size_t
. Valid alignments include only those values returned by an alignof
expression for fundamental types, plus an additional implementationdefined set of values, which may be empty. Every valid alignment value shall be an integral power of two.
The sizeof and alignof operators cannot be applied to an expression that has function type or an incomplete data type (such as a void type or to a variable length array), to the parenthesized name of such a type, or to an expression that designates a bitfield member.
The Cast Operator
The value of an expression can be converted to a different data type if desired. To do so, the expression must be preceded by the name of the desired data type enclosed in parantheses, ie:
(data type) expression
This type of construction is known as a cast.
Example: Suppose that i
is an integer variable whose value is 7, and f
is a floating point variable whose value is 8.5. The expression (i+f)%4
is invalid because the first operand is floating point and the %
operator works only on integer operands. However, the expression, ((int) (i+f))%4
forces the first operand to be an integer, and is therefore valid. Thus, the output of this expression is 3 as the % operator gives the remainder after integer division. Note that the explicit type specification applies only to the first operand and not to the entire expression.
The data type associated with the expression itself is not changed by a cast. Rather, it is the value of the expression that undergoes type conversion wherever the cast appears. This is particularly relevant when the expression consists of only a single variable.
Multiplicative Operators
There are three multiplicative operators:
Multiplication operator (*)
The * operator gives the product of two operands. The operands must be of arithmetic data type.
Division operator (/)
The / operator produces the quotient after dividing the first operand by the second. The two operands must be of arithmetic type and the second operand must be nonzero.
Modulus operator (%)
The % operator produces the remainder after division. The operands of the % operator must be integers and the second operand must be nonzero.
Additive Operators
There are two additive operators in C:
Addition operator (+)
The + operator performs binary addition and produces the sum of the two operands. The two operands of the + operator should both be of arithmetic type, or otherwise one operand should be a pointer type and the other should be of integer type.
Subtraction operator ()
The – operator subtracts the second operand from the first and gives the difference. For subtraction, the data types of the operands must satisfy one of the following combinations:
1. Both operands should be of arithmetic type.
2. Both operands should be a pointer to a complete object type.
3. The left operand should be a pointer to a complete object type and the right operand should be of integer type.
Operations on pointers will be discussed when we discuss pointers in a later article.
Bitwise Shift Operators
The two bitwise operators are shift left (<<) and shift right (>>). Each operator requires two operands. The first is an integer type operand that represents the bit pattern to be shifted. The second is an unsigned integer that indicates the number of displacements (ie, whether the bits in the first operand will be shifted by 1 bit position, 2 bit positions, 3 bit positions etc). This value cannot exceed the number of bits assosciated with the word size of the first operand.
The left shift operator causes all of the bits in the first operand to be shifted to the left by the number of positions indicated by the second operand. The leftmost bits (ie the overflow bits) in the original bit pattern will be lost. The rightmost bit positions that become vacant will be filled with 0s.
Example: Suppose a
is an unsigned integer variable whose value is 0110 1101 1011 0111
. The expression
b = a<<6
will shift all bits of a
six places to the left and assign the resulting bit pattern to the unsigned integer variable b
. Therefore the resulting value of b
will be 0110 1101 1100 0000
. All of the bits originally assigned to a
are shifted to the left six places. The leftmost 6 bits, ie 0110 11,
are lost and the the rightmost 6 bit positions are filled with 0s.
The right shift operator causes all of the bits in the first operand to be shifted to the right by the number of positions indicated by the second operand. The rightmost bits (ie, the underflow bits) in the original bit pattern will be lost. If the bit pattern being shifted represents an unsigned integer, then the leftmost bit positions that become vacant will be filled with 0s.
Example: Suppose a
is an unsigned integer variable whose value is 0110 1101 1011 0111
. The expression
b= a>>6
will shift all bits of a
six places to the right and assign the resulting bit pattern to the unsigned integer variable b
. Therefore the resulting value of b
will be 0000 0001 1011 0110
. The rightmost 6 bits of a, ie 11 0111,
are lost. The leftmost 6 bit positions are filled with 0s.
Relational Operators
There are four relational operators in C:
1. Less than (<)
2. Greater than (>)
3. Less than or equal to (<=)
4. Greater than or equal to (>=)
Relational operators are used to form logical expressions, which represent conditions that are either true or false. The resulting expressions will be of type integer, since true is represented by the integer value 1 and false by 0.
In a logical expression that uses relational operators either both the operands are of real data type or both are of pointer type.
When two pointers are compared, the result depends on the relative locations in the address space of the objects pointed to. If two pointers point to the same object, or both point one past the last element of the same array, they compare equal. If the objects pointed to are members of the same structure/union, pointers to structure members declared later compare greater than pointers to members declared earlier in the structure, and pointers to array elements with larger subscript values compare greater than pointers to elements of the same array with lower subscript values. All pointers to members of the same union object compare equal.
Example: Suppose i
and j
are integer variables where i=3
and j=5
. Then the logical expression i>j
will evaluate to false, ie 0, and the expression(i+5)>=j
will evaluate to true, ie 1.
The next article on C will continue with the rest of the operators: equality operators, bitwise AND, bitwise OR, logical AND, logical OR, conditional operators, assignment operators and the comma operator.

Dorsey

Andrew
