0% found this document useful (0 votes)
59 views

Data Types and Variables

The document discusses data types and variables in computing. It covers classical data types like integers and floating-point numbers. It describes characteristics of data types such as size and default values. The document also discusses type conversions, variables, and issues with calculations using certain data types.

Uploaded by

saber
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
59 views

Data Types and Variables

The document discusses data types and variables in computing. It covers classical data types like integers and floating-point numbers. It describes characteristics of data types such as size and default values. The document also discusses type conversions, variables, and issues with calculations using certain data types.

Uploaded by

saber
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 46

Data Types and Variables

Data Types, Variables, Type


Conversions
D ata

Saber BHAR
Table of Contents
void
1. What is a Data Type sbyte
ushort
double
2. Classical Data Types int
 Integer Types
float ulong
 Floating-Point Types
byte
 Type Conversion
 Characters and Strings uint
3. Variables short
long
2
Data Types, Variables
and Type Conversions
How Computing Works?
 Computers are machines that process data
 Instructions and data are stored in the computer memory

10110

4
Variables
 Variables have name, data type and value
 Assignment is done by the operator "="

 Example of variable definition and assignment in C#

Variable name
Data type
int count = 5;
Variable value

 When processed, data is stored back into variables

5
What Is a Data Type?
 A data type:
 Is a domain of values of similar characteristics

 Defines the type of information stored in the computer memory (in


a variable)
 Examples:
 Positive integers: 1, 2, 3, …

 Alphabetical characters: a, b, c, …
 Days of week: Monday, Tuesday, … 6
Data Type Characteristics
 A data type has:
 Name (C# keyword or .NET type)

 Size (how much memory is used)


int: sequence of 32
bits in the memory
 Default value

 Example: int: 4 sequential


 Integer numbers in C# bytes in the memory
 Name: int

 Size: 32 bits (4 bytes)

 Default value: 0 7
Integer Types
 sbyte [-128 …127]: signed 8-bit [-27 … 27-1]
 byte [0 … 255]: unsigned 8-bit [0 … 28-1]
 short [-32 768 … 32 767]: signed 16-bit [-215 … 215-1]
 ushort [0 … 65 535]: unsigned 16-bit [0 … 216-1]
 int [-2 147 483 648 … 2 147 483 647]: signed 32-bit [-2 31 … 231-1]
 uint [0 … 4 294 967 295]: unsigned 32-bit [0 … 2 32-1]
 long [-9 223 372 036 854 775 808 … 9 223 372 036 854 775 807]:
signed 64-bit [-263 … 263-1]
 ulong [0 … 18 446 744 073 709 551 615]: unsigned 64-bit [0 … 2 64-1]
8
Centuries – Example
 Depending on the unit of measure we can use different data types:

byte centuries = 20; // A small number (up to 255)


ushort years = 2000; // A small number (up to 32767)
uint days = 730484; // A large number (up to 4.3 billions)
ulong hours = 17531616; // A very big number (up to 18.4*10^18)
Console.WriteLine(
"{0} centuries = {1} years = {2} days = {3} hours.",
centuries, years, days, hours);
9
Beware of Integer Overflow!
 Integers have range (minimal and maximal value)
 Integers could overflow  this leads to incorrect values

byte counter = 0; 1
for (int i = 0; i < 260; i++) 2
{ …
counter++; 255
Console.WriteLine(counter); 0
} 1

10
Problem: Centuries to Minutes
 Write program to enter an integer number of centuries and
convert it to years, days, hours and minutes
Centures = 1
1 centuries = 100 years = 36524 days = 876576 hours
= 52594560 minutes

Centures = 5
5 centuries = 500 years = 182621 days = 4382904
hours = 262974240 minutes

11
Solution: Centuries to Minutes
Console.Write("Centuries = ");
int centuries = int.Parse(Console.ReadLine());
int years = centuries * 100;
int days = (int) (years * 365.2422); Tropical year has
int hours = 24 * days; (int) converts 365.2422 days
int minutes = 60 * hours; double to int
Console.WriteLine("{0} centuries = {1} years = {2}
days = {3} hours = {4} minutes", centuries, years,
days, hours, minutes);

12
Integer Literals

 Examples of integer literals:


 The '0x' and '0X' prefixes mean a hexadecimal value

 E.g. 0xFE, 0xA8F1, 0xFFFFFFFF


 The 'u' and 'U' suffixes mean a ulong or uint type

 E.g. 12345678U, 0U
 The 'l' and 'L' suffixes mean a long

 E.g. 9876543L, 0L
13
What are Floating-Point Types?
d ou b le
 Floating-point types:
float
 Represent real numbers, e.g. 1.25, -0.38

 May hold very small and very big values like


0.00000000000001
and 10000000000000000000000000000000000.0
 Have range and precision depending on the memory used

 Sometimes behave abnormally in the calculations

14
Floating-Point Numbers
 Floating-point types are:
 float (±1.5 × 10−45 to ±3.4 × 1038) double
 32-bits, precision of 7 digits
 double (±5.0 × 10−324 to ±1.7 × 10308) float
 64-bits, precision of 15-16 digits
 The default value of floating-point types:
 Is 0.0F for the float type

 Is 0.0D for the double type


15
PI Precision – Example
 Difference in precision when using float and double:

float floatPI = 3.141592653589793238f;


double doublePI = 3.141592653589793238;
Console.WriteLine("Float PI is: {0}", floatPI);
Console.WriteLine("Double PI is: {0}", doublePI);

 NOTE: The "f" suffix in the first statement!


 Real numbers are by default interpreted as double!

 One should explicitly convert them to float


16
Rounding Floating-Point Numbers
 Math.Round(3.45) – round to integer number (mathematically)
 Math.Round(2.3455, 3) – round with precision Banker's
rounding:
 Math.Ceiling() – round up to the nearest integer
2.5  3
 Math.Floor() – round down to the nearest integer 3.5  4
3.45  3
double a = 2.3455;
Console.WriteLine(Math.Round(a)); // result: 2
Console.WriteLine(Math.Round(a, 3)); // result: 2.346
Console.WriteLine(Math.Ceiling(a)); // result: 3
Console.WriteLine(Math.Floor(a)); // result: 2
17
Problem: Circle Area (12 Digits Precision)
 Write program to enter a radius r (real number) and prints the
area of the circle with exactly 12 digits after the decimal point:

2.5 19.634954084936 1.2 4.523893421169

 Sample solution:

double r = double.Parse(Console.ReadLine());
Console.WriteLine("{0:f12}", Math.PI * r * r);

18
Scientific Notation
 Floating-point numbers can use scientific notation, e.g.
 1e+34, 1E34, 20e-3, 1e-12, -6.02e28

double d = 10000000000000000000000000000000000.0;
Console.WriteLine(d); // 1E+34
double d2 = 20e-3;
Console.WriteLine(d2); // 0.02
double d3 = double.MaxValue;
Console.WriteLine(d3); // 1.79769313486232E+308
19
Floating-Point Division
 Integral division and floating-point division are different:

Console.WriteLine(10 / 4); // 2 (integral division)


Console.WriteLine(10 / 4.0); // 2.5 (real division)
Console.WriteLine(10 / 0.0); // Infinity
Console.WriteLine(-10 / 0.0); // -Infinity
Console.WriteLine(0 / 0.0); // NaN (not a number)
Console.WriteLine(8 % 2.5); // 0.5 (3 * 2.5 + 0.5 = 8)
int d = 0; // Integral division works differently
Console.WriteLine(10 / d); // DivideByZeroException
20
Floating-Point Calculations – Abnormalities
 Sometimes floating-point numbers work incorrectly!
Console.WriteLine(100000000000000.0 + 0.3);
// Result: 100000000000000 (loss of precision)
double a = 1.0f, b = 0.33f, sum = 1.33;
Console.WriteLine("a+b={0} sum={1} equal={2}",
a+b, sum, (a+b == sum));
// a+b=1.33000001311302 sum=1.33 equal=False
double one = 0;
for (int i = 0; i < 10000; i++) one += 0.0001;
Console.WriteLine(one); // 0.999999999999906
21
Decimal Floating-Point Type
 There is a special decimal floating-point real number type in C#:
 decimal (±1,0 × 10-28 to ±7,9 × 1028)
 128-bits, precision of 28-29 digits
 Used for financial calculations

 Almost no round-off errors

 Almost no loss of precision

 The default value of decimal type is:


dec i mal
 0.0M (M is the suffix for decimal numbers)
22
Problem: Exact Sum of Real Numbers
 Write program to enter n numbers and print their exact sum:

2
1000000000000000000 1000000000000000005
5

2
0.00000000003 333333333333.30000000003
333333333333.3

23
Solution: Exact Sum of Real Numbers
 This code works but makes mistakes sometimes:

int n = int.Parse(Console.ReadLine());
double sum = 0;
for (int i = 0; i < n; i++)
sum += double.Parse(Console.ReadLine());
Console.WriteLine(sum);

 Change double with decimal and check the differences

24
Type Conversion
 Variables hold values of certain type
 Type can be changed (converted) to another type
 Implicit type conversion (lossless): variable of bigger type
(e.g. double) takes smaller value (e.g. float)
float heightInMeters = 1.74f;
double maxHeight = heightInMeters; // Implicit conversion

 Explicit type conversion (lossy) – when precision can be lost:


double size = 3.14;
int intSize = (int) size; // Explicit conversion  3
25
Problem: Elevator
 Calculate how many courses will be needed to elevate n persons by
using an elevator of capacity of p persons
persons = 17 6 courses
capacity = 3
How? 5 courses * 3 persons
 Sample solution: + 1 course * 2 persons

int n = int.Parse(Console.ReadLine());
int p = int.Parse(Console.ReadLine());
int courses = (int) Math.Ceiling((double)n / p);
Console.WriteLine(courses);

26
Boolean Type
 Boolean variables (bool) hold true or false:

int a = 1;
int b = 2;
bool greaterAB = (a > b);
Console.WriteLine(greaterAB); // False
bool equalA1 = (a == 1);
Console.WriteLine(equalA1); // True

27
Problem: Special Numbers
 A number is special when its sum of digits is 5, 7 or 11
 For all numbers 1…n print the number and if it is special

1 -> False 8 -> False 15 -> False


2 -> False 9 -> False 16 -> True
3 -> False 10 -> False 17 -> False
20 4 -> False 11 -> False 18 -> False
5 -> True 12 -> False 19 -> False
6 -> False 13 -> False 20 -> False
7 -> True 14 -> True

28
Solution: Special Numbers
int n = int.Parse(Console.ReadLine());
for (int num = 1; num <= n; num++)
{
int sumOfDigits = 0;
int digits = num;
while (digits > 0)
{
sumOfDigits += digits % 10;
digits = digits / 10;
}
bool special = (sumOfDigits == 5) || …; // TODO: finish this
Console.WriteLine("{0} -> {1}", num, special);
}

29
The Character Data Type
 The character data type:
 Represents symbolic information

 Is declared by the char keyword

 Gives each symbol a corresponding integer code

 Has a '\0' default value

 Takes 16 bits of memory (from U+0000 to U+FFFF)

 Holds a single Unicode character (or part of character)


30
Characters and Codes
 Each character has an unique
Unicode value (int):
char ch = 'a';
Console.WriteLine("The code of '{0}' is: {1}", ch, (int) ch);
ch = 'b';
Console.WriteLine("The code of '{0}' is: {1}", ch, (int) ch);
ch = 'A';
Console.WriteLine("The code of '{0}' is: {1}", ch, (int) ch);
ch = 'щ'; // Cyrillic letter 'sht'
Console.WriteLine("The code of '{0}' is: {1}", ch, (int) ch);
31
Problem: Triples of Latin Letters
 Write a program to read an integer n and print all triples of the first
n small Latin letters, ordered alphabetically:
aaa acc bcb cca
aab baa bcc ccb
aac bab caa ccc
aba bac cab
3
abb bba cac
abc bbb cba
aca bbc cbb
acb bca cbc

32
Solution: Triples of Latin Letters
int n = int.Parse(Console.ReadLine());
for (int i1 = 0; i1 < n; i1++)
for (int i2 = 0; i2 < n; i2++)
for (int i3 = 0; i3 < n; i3++)
{
char letter1 = (char)('a' + i1);
char letter2 = // TODO: finish this
char letter3 = // TODO: finish this
Console.WriteLine("{0}{1}{2}",
letter1, letter2, letter3);
}

33
Escaping Characters
 Escaping sequences are:
 Represent a special character like ', " or \n (new line)
 Represent system characters (like the [TAB] character \t)

 Commonly used escaping sequences are:


 \'  for single quote \"  for double quote

 \\  for backslash\n  for new line

 \uXXXX  for denoting any other Unicode symbol

34
Character Literals – Example

char symbol = 'a'; // An ordinary character


symbol = '\u006F'; // Unicode character code in a
// hexadecimal format (letter 'o')
symbol = '\u8449'; // 葉 (Leaf in Traditional Chinese)
symbol = '\''; // Assigning the single quote character
symbol = '\\'; // Assigning the backslash character
symbol = '\n'; // Assigning new line character
symbol = '\t'; // Assigning TAB character
symbol = "a"; // Incorrect: use single quotes!

35
The String Data Type
 The string data type:
 Represents a sequence of characters

 Is declared by the string keyword

 Has a default value null (no value)

 Strings are enclosed in quotes:


string s = "Hello, C#"; string
 Strings can be concatenated
 Using the + operator
36
Verbatim and Interpolated Strings
 Strings are enclosed in quotes "": The backslash \
is escaped by \\
string file = "C:\\Windows\\win.ini";

 Strings can be verbatim (no escaping): The backslash \


is not escaped
string file = @"C:\Windows\win.ini";

 Interpolated strings insert variable values by pattern:


string firstName = "Svetlin";
string lastName = "Nakov";
string fullName = $"{firstName} {lastName}";
37
Saying Hello – Examples
 Combining the names of a person to obtain the full name:
string firstName = "Ivan";
string lastName = "Ivanov";
Console.WriteLine(@"Hello, ""{0}""!", firstName);
string fullName = $"{firstName} {lastName}";
Console.WriteLine("Your full name is {0}.", fullName);

 We can concatenate strings and numbers by the + operator:


int age = 21;
Console.WriteLine("Hello, I am " + age + " years old");
38
Problem: Greeting by Name and Age
 Write a program that enters first name, last name and age and
prints "Hello, <first name> <last name>. You are <age> years old."

string firstName = Console.ReadLine();


string lastName = Console.ReadLine();
string ageStr = Console.ReadLine();
int age = int.Parse(ageStr); // Parse string  int
Console.WriteLine($"Hello, {firstName} {lastName}.\
r\nYou are {age} years old.");

39
Naming Variables
 Variable names
 Always refer to the naming conventions
of a programming language – for C# use camelCase
 Preferred form: [Noun] or [Adjective] + [Noun]

 Should explain the purpose of the variable (Always ask yourself


"What this variable contains?")
firstName, report, config, usersList, fontSize, maxSpeed

foo, bar, p, p1, p2, populate, LastName, last_name, LAST_NAME


40
Problem: Refactor Volume of Pyramid
 You are given a working code that finds the volume of a prism:
 Fix naming, span and multi-purpose variables

double dul, sh, V = 0;


Console.Write("Length: ");
dul = double.Parse(Console.ReadLine());
Console.Write("Width: ");
sh = double.Parse(Console.ReadLine());
Console.Write("Heigth: ");
V = double.Parse(Console.ReadLine());
V = (dul * sh * V) / 3;
Console.WriteLine("Pyramid Volume: {0:F2}", V);

41
Variable Scope and Lifetime
 Scope shows from where you can access a variable
 Lifetime shows how long a variable stays in memory
static void Main() Accessible in
{ the Main()
var outer = "I'm inside the Main()";
for (int i = 0; i < 10; i++) Accessible in
{ the loop
var inner = "I'm inside the loop";
}
Console.WriteLine(outer);
// Console.WriteLine(inner); // Error
}

42
Variable Span
 Variable span is how long before a variable is called
 Always declare a variable as late as possible (e.g. shorter span)
static void Main()
{ "outer"
var outer = "I'm inside the Main()"; variable span
for (int i = 0; i < 10; i++)
{
var inner = "I'm inside the loop";
}
Console.WriteLine(outer);
// Console.WriteLine(inner); // Error
}

43
Variable Span
 Variable span is how long before a variable is called
 Always declare a variable as late as possible (e.g. shorter span)
static void Main()
{
for (int i = 0; i < 10; i++)
"outer"
{ variable span
var inner = "I'm inside the loop";
}
var outer = "I'm inside the Main()";
Console.WriteLine(outer);
// Console.WriteLine(inner); // Error
}

44
Problem: Refactor Special Numbers
int kolkko = int.Parse(Console.ReadLine());
int obshto = 0; int takova = 0; bool toe = false;
for (int ch = 1; ch <= kolkko; ch++)
{
takova = ch;
while (ch > 0)
{
obshto += ch % 10;
ch = ch / 10;
}
toe = (obshto == 5) || (obshto == 7) || (obshto == 11);
Console.WriteLine($"{takova} -> {toe}");
obshto = 0; ch = takova;
}

45
Summary
 Classical data types:
 Integer numbers: 8-bit, 16-bit, 32-bit, 64-bit
 Floating-point numbers (float, double) –
good for physics, not for money!
 Decimal floating-point (decimal) – 128-bit real number,
for financial calculations / large precision
 Character and String: Represents symbolic and text information

 Type conversion – Types can be converted into other types


 Variables – Store information. Have scope, span and lifetime 46

You might also like