Operators and Expressions

Performing Simple
P r o g ra m
Calculati ons with C#
ming
Basics

SoftUni Team (n & (1 < < p )) >> p ;

int b it =
Technical Trainers p);
Software University n = n & (~(1<<p)) | (bit<<
http://softuni.bg
Table of Contents
1. Operators in C# and Operator Precedence
2. Arithmetic Operators
3. Logical Operators
4. Bitwise Operators
5. Comparison Operators
6. Assignment Operators
7. Other Operators
8. Implicit and Explicit Type Conversions
9. Expressions
2
What is an Operator?
 Operator is an operation performed over data at runtime
 Takes one or more arguments (operands)

 Produces a new value Operator "+"

 Example of operators: a = b + c;

 Operators have precedence Operator "="

 Precedence defines which will be evaluated first

 Expressions are sequences of operators and operands that are

evaluated to a single value, e.g. (a + b) / 2
3
Operators in C#
 Operators in C# :
 Unary – take one operand

 Binary – take two operands

 Ternary (?:) – takes three operands

 Except for the assignment operators, all binary operators are

left-associative
 The assignment operators and the conditional operator (?:) are
right-associative
4
 Operators in C#
 Arithmeti c, Logical, Comparison,
Assignment, Etc.
Categories of Operators in C#
Category Operators
Arithmetic + - * / % ++ --
Logical && || ^ !
Binary & | ^ ~ << >>
Comparison == != < > <= >=
Assignment = += -= *= /= %= &= |= ^= <<=
>>=
String concatenation +
Type conversion is as typeof
Other . [] () ?: new

6
Operators Precedence
Operators Precedence
Precedence Operators
Highest ()
++ -- (postfix) new typeof
++ -- (prefix) + - (unary) ! ~
* / %
+ -
<< >>
< > <= >= is as
== !=
&
Lower ^

8
Operators Precedence (2)

Precedence Operators
Higher |
&&
||
?:
Lowest = *= /= %= += -= <<= >>= &= ^= |=

 Parenthesis operator always has highest precedence

 Note: prefer using parentheses, even when it seems stupid to do so
9
Arithmetic Operators
Arithmetic Operators

 Arithmetic operators +, -, * are the same as in math

 Division operator / if used on integers returns integer (without
rounding) or exception
 Division operator / if used on real numbers returns real number
or Infinity or NaN
 Remainder operator % returns the remainder from division of
integers
 The special addition operator ++ increments a variable
11
Arithmetic Operators – Examples
int squarePerimeter = 17;
double squareSide = squarePerimeter / 4.0;
double squareArea = squareSide * squareSide;
Console.WriteLine(squareSide); // 4.25
Console.WriteLine(squareArea); // 18.0625
int a = 5;
int b = 4;
Console.WriteLine( a + b ); // 9
Console.WriteLine( a + b++ ); // 9
Console.WriteLine( a + b ); // 10
Console.WriteLine( a + (++b) ); // 11
Console.WriteLine( a + b ); // 11

12
Arithmetic Operators – Example (2)
Console.WriteLine(12 / 3); // 4
Console.WriteLine(11 / 3); // 3

Console.WriteLine(11.0 / 3); // 3.666666667

Console.WriteLine(11 / 3.0); // 3.666666667
Console.WriteLine(11 % 3); // 2
Console.WriteLine(11 % -3); // 2
Console.WriteLine(-11 % 3); // -2

Console.WriteLine(1.5 / 0.0); // Infinity

Console.WriteLine(-1.5 / 0.0); // -Infinity
Console.WriteLine(0.0 / 0.0); // NaN

int x = 0;
Console.WriteLine(5 / x); // DivideByZeroException
13
Arithmetic Operators – Overflow Examples
int bigNum = 2000000000;
int bigSum = 2 * bigNum; // Integer overflow!
Console.WriteLine(bigSum); // -294967296

bigNum = Int32.MaxValue;
bigNum = bigNum + 1;
Console.WriteLine(bigNum); // -2147483648

checked
{
// This will cause OverflowException
bigSum = bigNum * 2;
}
14
Beware of Integer Division!!!
 When you divide two integers, the result is always an integer.
 To determine the remainder use the remainder operator %.
 Cast the dividend or divisor to type float or double.

int a = 5;
int b = 2; int a = 5;
int b = 2;
double result = a / b;
Console.WriteLine(result); // 2 int result = a % b;
Console.WriteLine(result);
double result = (double)a / b; // 1 (remainder)
Console.WriteLine(result); // 2.5
15
Arithmetic Operators
Live Demo
Logical Operators
Logical Operators
 Logical operators take boolean operands and return boolean
result
 Operator ! turns true to false and false to true
 Behavior of the operators &&, || and ^
(1 == true, 0 == false):
Operator || || || || && && && && ^ ^ ^ ^
Operand1 0 0 1 1 0 0 1 1 0 0 1 1
Operand2 0 1 0 1 0 1 0 1 0 1 0 1
Result 0 1 1 1 0 0 0 1 0 1 1 0

18
Logical Operators – Example
bool a = true;
bool b = false;
Console.WriteLine(a && b); // False
Console.WriteLine(a || b); // True
Console.WriteLine(a ^ b); // True
Console.WriteLine(!b); // True
Console.WriteLine(b || true); // True
Console.WriteLine(b && true); // False
Console.WriteLine(a || true); // True
Console.WriteLine(a && true); // True
Console.WriteLine(!a); // False
Console.WriteLine((5>7) ^ (a==b)); // False
19
Logical Operators
Live Demo
Bitwise Operators
Bitwise Operators
 Bitwise operator ~ turns all 0 to 1 and all 1 to 0
 Like ! for boolean expressions but bit by bit
 The operators |, & and ^ behave like ||, && and ^ for boolean
expressions but bit by bit
 The << and >> move the bits (left or right)
 Behavior of the operators|, & and ^:
Operator | | | | & & & & ^ ^ ^ ^
Operand1 0 0 1 1 0 0 1 1 0 0 1 1
Operand2 0 1 0 1 0 1 0 1 0 1 0 1
Result 0 1 1 1 0 0 0 1 0 1 1 0
22
Bitwise Operators (2)
 Bitwise operators are used on integer numbers (byte, sbyte,
int, uint, long, ulong)
 Bitwise operators are applied bit by bit
 Examples: ushort a = 3; // 00000000 00000011
ushort b = 5; // 00000000 00000101
Console.WriteLine( a | b); // 00000000 00000111
Console.WriteLine( a & b); // 00000000 00000001
Console.WriteLine( a ^ b); // 00000000 00000110
Console.WriteLine(~a & b); // 00000000 00000100
Console.WriteLine( a << 1); // 00000000 00000110
Console.WriteLine( a >> 1); // 00000000 00000001
23
Bitwise Operators – Tips & Tricks
 How to get the bit at position p from a number n?
int p = 5;
int n = 291; // 00000001 00100011
int nRightP = n >> p; // 00000000 00001001
int bit = nRightP & 1; // 00000000 00000001
Console.WriteLine(bit); // 1

 How to set the bit at position p to 0?

int p = 5;
int n = 291; // 00000001 00100011
int mask = ~(1 << p); // 11111111 11011111
int result = n & mask; // 00000001 00000011
Console.WriteLine(result); // 259
24
Bitwise Operators – Tips & Tricks (2)
 How to set the bit at position p to 1?
int p = 4;
int n = 291; // 00000001 00100011
int mask = 1 << p; // 00000000 00010000
int result = n | mask; // 00000001 00110011
Console.WriteLine(result); // 307

 How to print a binary number to the console?

Console.WriteLine(
Convert.ToString(result, 2).PadLeft(16, '0'));
// 0000000000110011
25
Bitwise Operators
Live Demo
Comparison and Assignment
Operators
Comparison Operators
 Comparison operators are used to compare variables
 ==, <, >, >=, <=, !=

 Comparison operators example:

int a = 5;
int b = 4;
Console.WriteLine(a >= b); // True
Console.WriteLine(a != b); // True
Console.WriteLine(a == b); // False
Console.WriteLine(a == a); // True
Console.WriteLine(a != ++b); // False
Console.WriteLine(a > b); // False
28
Assignment Operators
 Assignment operators are used to assign a value to a variable ,
 =, +=, -=, |=, ...

 Assignment operators example:

int x = 6;
int y = 4;
Console.WriteLine(y *= 2); // 8
int z = y = 3; // y=3 and z=3
Console.WriteLine(z); // 3
Console.WriteLine(x |= 1); // 7
Console.WriteLine(x += 3); // 10
Console.WriteLine(x /= 2); // 5
29
 Comparison and
Assignment Operators
Live Demo
Other Operators
Other Operators
 String concatenation operator + is used to concatenate strings
 If the second operand is not a string, it is converted to string
automatically
string first = "First";
string second = "Second";
Console.WriteLine(first + second);
// FirstSecond
string output = "The number is : ";
int number = 5;
Console.WriteLine(output + number);
// The number is : 5
32
Other Operators (2)
 Member access operator . is used to access object members
 E.g. DateTime.Now.DayOfWeek.ToString()

 Square brackets [] are used with arrays, indexers and attributes

 E.g. numbers[3], "Hello"[2]

 Parentheses ( ) are used to override the default operator

precedence, e.g. (a + b) / 2
 Class cast operator (type) is used to cast one compatible type
to another, e.g. (uint) -1
33
Other Operators (3)
 Conditional operator ?: has the form
b ? x : y

(if b is true then the result is x else the result is y)

 The new operator is used to create new objects
 The typeof operator returns System.Type object (the
reflection of a type), e.g. typeof(int)
 The is operator checks if an object is compatible with given
type, e.g. 5 is int  true; 3.14 is float  false
34
Other Operators (4)
 Null-coalescing operator ?? is used to define a default value for
both nullable value types and reference types
 It returns the left-hand operand if it is not null
 Otherwise it returns the right-hand operand

int? x = null; Here the value of y is -1

int y = x ?? -1;

int? x = 1;
int y = x ?? -1;
Here the value of y is 1
35
Other Operators – Example
int a = 6;
int b = 4;
Console.WriteLine(a > b ? "a>b" : "b>=a"); // a>b
Console.WriteLine((long) a); // 6
int c = b = 3; // b=3; followed by c=3;
Console.WriteLine(c); // 3
Console.WriteLine(a is int); // True
Console.WriteLine((a+b)/2); // 4
Console.WriteLine(typeof(int)); // System.Int32
int d = new int();
Console.WriteLine(d); // 0
36
Other Operators
Live Demo
Implicit and Explicit Type
Conversions
Implicit Type Conversion
 Implicit type conversion
 Automatic conversion of value of one data type to value of
another data type
 Allowed when no loss of data is possible
 "Larger" types can implicitly take values of smaller "types"
 Example:

int i = 5;
long l = i; // implicit type conversion
39
Explicit Type Conversion
 Explicit type conversion
 Manual conversion of a value of one data type to a value of
another data type
 Allowed only explicitly by (type) operator

 Required when there is a possibility of loss of data or precision

 Example:

long l = 5;
int i = (int) l; // explicit type conversion
40
Type Conversions – Example
 Example of implicit and explicit conversions:
float heightInMeters = 1.74f; // Explicit conversion
double maxHeight = heightInMeters; // Implicit

double minHeight = (double) heightInMeters; // Explicit

float actualHeight = (float) maxHeight; // Explicit

float maxHeightFloat = maxHeight; // Compilation error!

 Note: explicit conversion may be applied even when it is not

required by the compiler
41
Type Conversions
Live Demo
Expressions
Expressions
 Expressions are sequences of operators, literals and variables
that are evaluated to some value
 Examples:

int r = (150 - 20) / 2 + 5; // r=70

// Expression for calculating a circle area
double surface = Math.PI * r * r;
// Expression for calculating a circle perimeter
double perimeter = 2 * Math.PI * r;
44
Expressions (2)
 Expressions have:
 Type (integer, real, boolean, ...)
 Value Expression of type int.
Calculated at compile time Expression of type int.
 Examples: Calculated at runtime

int a = 2 + 3; // a = 5
int b = (a + 3) * (a - 4) + (2 * a + 7) / 4; // b = 12
bool greater = (a > b) || ((a == 0) && (b == 0));

Expression of type bool.

Calculated at runtime
45
Expressions
Live Demo
Summary
 We discussed the operators in C#:
 Arithmetic, logical, bitwise, comparison,
assignment and others
 Operator precedence
 Bitwise calculations (read / change a bit)

 We learned when to use implicit and

explicit type conversions
 We learned how to use expressions
47
Operators and Expressions

? ?

stio ns ? ?

Qu e ?
?

?
https://softuni.bg/courses/programming-basics/
 Homework Review
 Live Demo
Resources
 Boolean algebra (logic)
 http://en.wikipedia.org/wiki/Boolean_algebra_%28logic%29
 Bitwise mask
 http://en.wikipedia.org/wiki/Mask_%28computing%29
 Bitwise operation
 http://en.wikipedia.org/wiki/Bitwise_operation
 Bit hacks
 graphics.stanford.edu/~seander/bithacks.html

50
License
 This course (slides, examples, demos, videos, homework, etc.)
is licensed under the "Creative Commons
Attribution-NonCommercial-ShareAlike 4.0 International" license

 Attribution: this work may contain portions from

 "Fundamentals of Computer Programming with C#" book by Svetlin Nakov & Co. under CC-BY-SA license
 "C# Part I" course by Telerik Academy under CC-BY-NC-SA license

51
Free Trainings @ Software University
 Software University Foundation – softuni.org
 Software University – High-Quality Education,
Profession and Job for Software Developers
 softuni.bg
 Software University @ Facebook
 facebook.com/SoftwareUniversity
 Software University @ YouTube
 youtube.com/SoftwareUniversity
 Software University Forums – forum.softuni.bg