Types of Operators in C
2 likes574 views
The document explains various types of operators in the C programming language, including arithmetic, relational, logical, assignment, increment and decrement, conditional, bitwise, and special operators. It includes detailed descriptions of each operator type, their purposes, and examples of their usage. Additionally, the document covers operator precedence and type modifiers, highlighting how these concepts apply to data types in C.
![73
int a = 5; [binary : 0000 0101]
int b = 9; [binary : 0000 1001]
a | b yields [binary : 0000 1101]
& (Bit-wise AND) :binary operator takes two operands of int type and
performs bit-wise AND operation. With same assumption
on int size as above:
int a = 5; [binary : 0000 0101]
int b = 9; [binary : 0000 1001]
a & b yields [binary : 0000 0001]
^ (Bit-wise Logical XOR) :XOR gives 1 if only one of the operand is 1 else 0. With
same assumption on int size as above:
int a = 5; [binary : 0000 0101]
int b = 9; [binary : 0000 1001]
a ^ b yields [binary : 0000 1100]
<< (Shift left) :This operator shifts the bits towards left padding the
space with 0 by given integer times.
int a = 5; [binary : 0000 0101]
a << 3 yeilds [binary : 0010 1000]
>> (Shift right) :This operator shifts the bits towards right padding the
space with 0.
int a = 5; [binary : 0000 0101]
a >> 3 yeilds [binary : 0000 0000]
~ (oneâs complement operator) :It is a uniary operator that causes the bits of its operand to
be inverted so that 1 becomes 0 and vice-versa. The
opearator must always precede the operand and must be
integer type of all sizes. Assuming that int type is of 1 byte
size:
inr a = 5; [binary : 0000 0101]
~a; [binary : 1111 1010]
Special Operators
C language supports some special operators such as comma operator, sizeof operator, pointer operators (&
and *), and member selection operators (. and ->). Pointer operators will be discussed while introducing
pointers and member selection operators will be discussed with structures and union. Right now, we will
discuss comma operator and sizeof operator.
(a) Comma Operator
This operator is used to link the related expressions together.](https://image.slidesharecdn.com/unit-3focp-170510035332/85/Types-of-Operators-in-C-5-320.jpg)
![74
e.g.: int val, x, y;
value = (x = 0, y = 5, x+y);
It first assigns 10 to x, then 5 to y, finally sum x+y to val.
(b) sizeof Operator
The sizeof operator is a compile time operator and when used with an operand, it returns the
number of bytes the operand occupies. The operand may be a variable, a constant or a data type
qualifier.
e.g.: int n;
n = sizeof (int);
printf ("%d", n);
output: n = 2 /* Assuming that int size is 2 bytes */
Operator Precedence
Precedence defines the sequence in which operators are to be applied on the operands while evaluating the
expressions involving more than one operators. Operators of same precedence are evaluated from left to
right or right to left, depending upon the level. This is known as associativity property of an operator.
Summary of Precedence and Associativity
DESCRIPTION OPERATORS ASSOCIATIVITY
Function expression ( ) LďŽR
Array expression [ ] LďŽR
Structure operator ďŽ LďŽR
Structure operator . LďŽR
Unary Minus - RďŽL
Increment/Decrement ++ -- RďŽL
One's complement ~ RďŽL
Negation ! RďŽL
Address of & RďŽL
Value at address * RďŽL
Type cast (type) RďŽL
Size in bytes sizeof RďŽL
Multiplication * LďŽR
Division / LďŽR
Modulus % LďŽR
Addition + LďŽR
Subtraction - LďŽR
Left shift << LďŽR
Right shift >> LďŽR
Less than < LďŽR
Less than or equal to < = LďŽR
Greater than > LďŽR
Greater than or equal to > = LďŽR
Equal to = = LďŽR](https://image.slidesharecdn.com/unit-3focp-170510035332/85/Types-of-Operators-in-C-6-320.jpg)
Types of Operators in C
- 1. For more Https://www.ThesisScientist.com Unit 3 Operators Operators An operator is a symbol that tells the computer to perform certain mathematical or logical manipulation on data stored in variables. The variables that are operated are termed as operands. C operators can be classified into a number of categories. They include: 1. Arithmetic operators 2. Relational operators 3. Logical operators 4. Assignment operator 5. Increment and decrement operators 6. Conditional operator 7. Bitwise operators 8. Special operators Now, let us discuss each category in detail. Arithmetic Operators C provides all the basic arithmetic operators. There are five arithmetic operators in C. Operator Purpose + Addition - Subtraction * Multiplication / Division % Remainder after integer division The division operator (/) requires the second operand as non zero, though the operands need not be integers. The operator (%) is known as modulus operator. It produces the remainder after the division of two operands. The second operand must be non-zero. All other operators work in their normal way.
- 2. 70 Relational Operators Relational operator is used to compare two operands to see whether they are equal to each other, unequal, or one is greater or lesser than the other. The operands can be variables, constants or expressions, and the result is a numerical value. There are six relational operators. = = equal to ! = not equal to < less than < = less than or equal to > greater than > = greater than or equal to A simple relation contains only one relational expression and takes the following form: ae-1 relational operator ae-2 ae-1 and ae-2 are arithmetic expressions, which may be simple constants, variables or combination of these. The value of the relational operator is either 1 or 0. If the relation is true, result is 1 otherwise it is 0. e.g.: Expressions Result 4.5 < = 10 True 4.5 < -10 False -35 > = 0 False 10 < 7+5 True Logical Operators Logical operators are used to combine two or more relational expressions. C provides three logical operators. Operator Meaning && Logical AND ÂŚÂŚ Logical OR ! Logical NOT The result of Logical AND will be true only if both operands are true. While the result of a Logical OR operation will be true if either operand is true. Logical NOT (!) is used for reversing the value of the expression. The expression which combines two or more relational expressions is termed as Logical Expression or Compound Relational Expression which yields either 1 or 0. e.g.: 1. if (age > 50 && weight < 80) 2. if ( a < 0 ÂŚ ÂŚ ch = = 'a') 3. if (! (a < 0))
- 3. 71 Assignment Operators Assignment operators are used to assign the result of an expression to a variable. The most commonly used assignment operator is (=). Note that it is different from mathematical equality. An expression with assignment operator is of the following form: identifier = expression #include <stdio.h> main( ) { int i; i = 5; printf ("%d", i); i = i + 10; printf ("n%d", i); } output will be: 5 15 In this program i = i+10; is an assignment expression which assigns the value of i+10 to i. Expressions like i = i+10, i = i â 5, i = i*2, i = i/6, and i = i*4, can be rewritten using shorthand assignment operators. The advantages of using assignment operators are: 1. The statement is more efficient and easier to read. 2. What appears on the L.H.S need not to be repeated and therefore it becomes easier to write for long variable names. Increment and Decrement Operators C has two very useful operators ++ and -- called increment and decrement operators respectively. These are generally not found in other languages. These operators are called unary operators as they require only one operand. This operand should necessarily be a variable not a constant. The increment operator (++) adds one to the operand while the decrement operator (--) subtracts one from the operand. These operators may be used either before or after the operand. When they are used before the operand, it is termed as prefix, while when used after the operand, they are termed as postfix operators. e.g.: int i = 5; i++; ++i; ââi; iââ; e.g.: b = a ++; this is postfix increment expression. In the expression firstly b = a; then a = a+1; will be executed, while in prefix increment expression b = - - a; firstly a = a-1; then b = a; will be executed.
- 4. 72 e.g.: # include <stdio.h> main( ) { int a = 10; b = 0; a++; printf ("n a = %d", a); b = ++a; printf ("n a = % d, b = % d", a, b); b = a++; printf ("n a = % d, b = % d", a, b); } output: a = 11 a = 12 b = 12 a = 13 b = 12 Conditional Operator A ternary operator is one which contains three operands. The only ternary operator available in C language is conditional operator pair "?:". It is of the form: exp1 ? exp2 : exp3 ; This operator works as follows. Exp1 is evaluated first. If the result is true then exp2 is executed, otherwise exp3 is executed. e.g.: a = 10; b = 15; x = (a > b ? a: b) In this expression value of b will be assigned to x. Bitwise Operators Bitwise operators are used for manipulation of data at bit level. These operators are used for testing the bits, or shifting them right or left. Bitwise operators may not be applied to float or double data type. It is applicable to integer data types data only. Some Bitwise Operators Operator Meaning & Bitwise Logical AND ÂŚ Bitwise Logical OR ^ Bitwise Logical XOR << Left shift >> Right shift ~ One's complement | (Bit-wise OR) :binary operator takes two operands of int type and performs bit-wise OR operation. With assumption that int size is 8-bits:
- 5. 73 int a = 5; [binary : 0000 0101] int b = 9; [binary : 0000 1001] a | b yields [binary : 0000 1101] & (Bit-wise AND) :binary operator takes two operands of int type and performs bit-wise AND operation. With same assumption on int size as above: int a = 5; [binary : 0000 0101] int b = 9; [binary : 0000 1001] a & b yields [binary : 0000 0001] ^ (Bit-wise Logical XOR) :XOR gives 1 if only one of the operand is 1 else 0. With same assumption on int size as above: int a = 5; [binary : 0000 0101] int b = 9; [binary : 0000 1001] a ^ b yields [binary : 0000 1100] << (Shift left) :This operator shifts the bits towards left padding the space with 0 by given integer times. int a = 5; [binary : 0000 0101] a << 3 yeilds [binary : 0010 1000] >> (Shift right) :This operator shifts the bits towards right padding the space with 0. int a = 5; [binary : 0000 0101] a >> 3 yeilds [binary : 0000 0000] ~ (oneâs complement operator) :It is a uniary operator that causes the bits of its operand to be inverted so that 1 becomes 0 and vice-versa. The opearator must always precede the operand and must be integer type of all sizes. Assuming that int type is of 1 byte size: inr a = 5; [binary : 0000 0101] ~a; [binary : 1111 1010] Special Operators C language supports some special operators such as comma operator, sizeof operator, pointer operators (& and *), and member selection operators (. and ->). Pointer operators will be discussed while introducing pointers and member selection operators will be discussed with structures and union. Right now, we will discuss comma operator and sizeof operator. (a) Comma Operator This operator is used to link the related expressions together.
- 6. 74 e.g.: int val, x, y; value = (x = 0, y = 5, x+y); It first assigns 10 to x, then 5 to y, finally sum x+y to val. (b) sizeof Operator The sizeof operator is a compile time operator and when used with an operand, it returns the number of bytes the operand occupies. The operand may be a variable, a constant or a data type qualifier. e.g.: int n; n = sizeof (int); printf ("%d", n); output: n = 2 /* Assuming that int size is 2 bytes */ Operator Precedence Precedence defines the sequence in which operators are to be applied on the operands while evaluating the expressions involving more than one operators. Operators of same precedence are evaluated from left to right or right to left, depending upon the level. This is known as associativity property of an operator. Summary of Precedence and Associativity DESCRIPTION OPERATORS ASSOCIATIVITY Function expression ( ) LďŽR Array expression [ ] LďŽR Structure operator ďŽ LďŽR Structure operator . LďŽR Unary Minus - RďŽL Increment/Decrement ++ -- RďŽL One's complement ~ RďŽL Negation ! RďŽL Address of & RďŽL Value at address * RďŽL Type cast (type) RďŽL Size in bytes sizeof RďŽL Multiplication * LďŽR Division / LďŽR Modulus % LďŽR Addition + LďŽR Subtraction - LďŽR Left shift << LďŽR Right shift >> LďŽR Less than < LďŽR Less than or equal to < = LďŽR Greater than > LďŽR Greater than or equal to > = LďŽR Equal to = = LďŽR
- 7. 75 Not equal to ! = LďŽR Bitwise AND & LďŽR Bitwise XOR ^ LďŽR Bitwise OR | LďŽR Logical AND && LďŽR Logical OR || LďŽR Conditional ?: RďŹL Assignment = RďŹL * = / = % = RďŹL + = - = & = RďŹL ^ = | = RďŹL << = >> = RďŹL Comma , RďŹL Type Modifiers The Basic Data Types may have modifiers preceding them to indicate special properties of the objects being declared. These modifiers change the meaning of the Basic data types to suit the specific needs. These modifiers are unsigned, signed, long and short. It is also possible to give these modifiers in combination, e.g., unsigned log int. Modifiers for char Data Type char data type can be qualified as either signed or unsigned, both occupying one byte each, but having different ranges. A signed char is same as an ordinary char and has a range from -128 to +127; whereas an unsigned char has a range from 0 to 255. By default char is unsigned. e.g.: main ( ) { char ch = 291; printf ("%dt%cn", ch, ch); } output: 35 # Here ch has been defined as a char, and a char cannot take a value bigger than +128. That is why assigned value of ch, 291 is considered to be 35 (291-128). Modifiers for int Data Type Integer quantities can be defined as short int, long int or unsigned int. short int occupies two bytes of space, whereas long int occupies 4 bytes of space. A signed int has the same memory requirements as an unsigned int (or a short int or a long int), the leftmost bit is reserved for the sign. With an unsigned int, all the bits are used to represent the numerical value. The unsigned qualifier can also be applied to other qualified int. For example, unsigned short int or unsigned long int. By default, modifier assumed with integers is signed. Modifiers for double and float Data Type Modifier long is used with double data type but not with float. Long double occupies 10 bytes of memory space (usually, but actual size depends on implementation and hardware platform).
- 8. 76 Data Type Range Bytes Format signed char -128 to + 127 1 %c unsigned char 0 to 255 1 %c short signed int -32768 to 32767 2 %d short unsigned int 0 to 65535 2 %u long signed int -2147483648 to +2147483647 4 %ld long unsigned int 0 to 4294967295 4 %lu float -3.4e38 to 3.4e38 4 %f double -1.7e308 to +1.7e308 8 %lf