|
|
---
|
|
|
marp: true
|
|
|
paginate: true
|
|
|
math: mathjax
|
|
|
theme: buutti
|
|
|
title: 2. Variables and Types
|
|
|
---
|
|
|
|
|
|
# Variables and Types
|
|
|
|
|
|
<!-- headingDivider: 5 -->
|
|
|
<!-- class: invert -->
|
|
|
|
|
|
## Overview
|
|
|
|
|
|
* Variables
|
|
|
* Data Types
|
|
|
* Arithmetic Operators
|
|
|
* Increment & Decrement
|
|
|
* Assignment Operators
|
|
|
* Strings
|
|
|
* Character Constants
|
|
|
* String Interpolation
|
|
|
|
|
|
## Variables
|
|
|
|
|
|
* A variable can be thought of as a name for a certain address in computer's memory
|
|
|
* Using this name we can access the value on the computer's memory
|
|
|
* The value can be read or written
|
|
|
* On more practical terms: We can assign values to named variables.
|
|
|
|
|
|
### Declaring variables
|
|
|
|
|
|
* Every variable declaration in C# requires the ***type*** and the ***name*** of the variable, for example:
|
|
|
```csharp
|
|
|
int x;
|
|
|
```
|
|
|
* After declaration, you can assign a ***value*** for declared variables:
|
|
|
```csharp
|
|
|
x = 25;
|
|
|
```
|
|
|
* Variable declaration with value assignment can be done in one line:
|
|
|
```csharp
|
|
|
int x = 25;
|
|
|
```
|
|
|
|
|
|
### Printing to console with `Console.WriteLine`
|
|
|
|
|
|
<div class='columns' markdown='1'>
|
|
|
<div markdown='1'>
|
|
|
|
|
|
* We can use the method `Console.WriteLine` to write, a.k.a. ***print*** to the C# console
|
|
|
```csharp
|
|
|
Console.WriteLine("Hello World!")
|
|
|
```
|
|
|
* We can also declare variables and print their values like this:
|
|
|
```csharp
|
|
|
int example = 123;
|
|
|
Console.WriteLine(example);
|
|
|
// prints 123
|
|
|
```
|
|
|
|
|
|
</div>
|
|
|
<div markdown='1'>
|
|
|
|
|
|
This program prints the value `15`:
|
|
|
```csharp
|
|
|
using System;
|
|
|
namespace MyAwesomeProgram
|
|
|
{
|
|
|
class Program
|
|
|
{
|
|
|
static void Main(string[] args)
|
|
|
{
|
|
|
int a = 25;
|
|
|
int b = 10;
|
|
|
Console.WriteLine(a - b);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
```
|
|
|
|
|
|
</div>
|
|
|
</div>
|
|
|
|
|
|
### Extra: Modifiers
|
|
|
<!-- _class: "extra invert" -->
|
|
|
|
|
|
* A common modifier to add in front of a variable is `const`, short for ***constant***
|
|
|
* If we know that a value of a variable is never going to change during the execution of the script, we can set it to `const`:
|
|
|
```c#
|
|
|
const int one = 1;
|
|
|
|
|
|
one = 2; // raises an error
|
|
|
```
|
|
|
* Some programmers prefer using `const` by default.
|
|
|
* Other modifiers include ***access modifiers*** introduced in [Lecture 7](7-classes-and-objects#access-modifiers).
|
|
|
|
|
|
## Data types
|
|
|
|
|
|
### What is a data type?
|
|
|
|
|
|
* Data type tells to a computer what type of data is stored in a variable.
|
|
|
* Data types are commonly divided into two categories:
|
|
|
* Primitive data types
|
|
|
* Reference data types
|
|
|
* Here we go through the primitive data types
|
|
|
* We dig deeper on the differences of these data types later in [Lecture 7](7-classes-and-objects#value-and-reference-types)
|
|
|
|
|
|
## Primitive data types
|
|
|
|
|
|
| Type | Represents | Range | Default |
|
|
|
|:----------|:-------------------------------|:-------------------------------------------------|:--------|
|
|
|
| `bool` | Boolean value | `true` or `false` | `false` |
|
|
|
| `int` | 32-bit signed integer | $-2147483648$ to $2147483647$ | `0` |
|
|
|
| `float` | 32-bit single-precision float | $±1.5 \cdot 10^{-45}$ to $±3.4 \cdot 10^{38}$ | `0.0F` |
|
|
|
| `double` | 64-bit double-precision float | $±5.0 \cdot 10^{-324}$ to $±1.7 \cdot 10^{308}$ | `0.0D` |
|
|
|
| `decimal` | 128-bit precise decimal values | $±1.0 \cdot 10^{-28}$ to $±7.9228 \cdot 10^{28}$ | `0.0M` |
|
|
|
| `char` | 16-bit Unicode character | `U+0000` to `U+ffff` | `\0` |
|
|
|
| `byte` | 8-bit unsigned integer | $0$ to $255$ | `0` |
|
|
|
|
|
|
More types listed in the [C# reference](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/built-in-types)!
|
|
|
|
|
|
### Data type examples
|
|
|
|
|
|
```csharp
|
|
|
double airPressure = 1.2; // Use for most decimal numbers
|
|
|
decimal accountBalance = 1.2m; // Use for accuracy (e.g. financial applications)
|
|
|
float bulletSpeed = 1.2f; // Use only when you know its precision will be enough
|
|
|
bool loggedIn = false;
|
|
|
char previousInput = 'b';
|
|
|
```
|
|
|
|
|
|
* `char` is only used for single characters, multi-character ***strings*** will be introduced in a bit.
|
|
|
|
|
|
## Extra: Casting data types
|
|
|
<!-- _class: "extra invert" -->
|
|
|
|
|
|
Data types can be ***cast*** to another either...
|
|
|
|
|
|
<div class='columns' style="grid-template-columns: 2.5fr 3fr;" markdown='1'>
|
|
|
<div markdown='1'>
|
|
|
|
|
|
...implicitly:
|
|
|
```csharp
|
|
|
double valueAddedTax = 25.5;
|
|
|
decimal valueAddedTaxDecimal = valueAddedTax;
|
|
|
```
|
|
|
|
|
|
</div>
|
|
|
<div markdown='1'>
|
|
|
|
|
|
...explicitly:
|
|
|
```csharp
|
|
|
double valueAddedTax = 25.5;
|
|
|
decimal valueAddedTaxDecimal = (decimal)valueAddedTax;
|
|
|
```
|
|
|
|
|
|
</div>
|
|
|
</div>
|
|
|
|
|
|
* Casting is useful when, for example, when we want to sum a `double` and a `decimal` together:
|
|
|
```csharp
|
|
|
double a = 1.0;
|
|
|
decimal b = 2.1m;
|
|
|
Console.WriteLine(a + (double)b);
|
|
|
Console.WriteLine((decimal)a + b);
|
|
|
```
|
|
|
* [C# Guide: Casting and type conversions](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/types/casting-and-type-conversions)
|
|
|
|
|
|
## Assignments (variables)
|
|
|
<!--_class: "exercise invert" -->
|
|
|
|
|
|
[Assignments about this topic can be found here](https://gitea.buutti.com/education/academy-assignments/src/branch/master/C%23%20Basics/2.1.%20Variables%20&%20Types)
|
|
|
|
|
|
## Assignments (data types)
|
|
|
<!--_class: "exercise invert" -->
|
|
|
|
|
|
[Assignments about this topic can be found here](https://gitea.buutti.com/education/academy-assignments/src/branch/master/C%23%20Basics/2.2.%20Data%20Types)
|
|
|
|
|
|
## Arithmetic operations?
|
|
|
|
|
|
* ***Arithmetic operations*** are common mathematical operations:
|
|
|
* Addition
|
|
|
* Subtraction
|
|
|
* Multiplication
|
|
|
* Division
|
|
|
* Modulus (remainder, in Finnish *jakojäännös*)
|
|
|
* The operations are represented by **_arithmetic operators_**
|
|
|
|
|
|
## Arithmetic Operators
|
|
|
|
|
|
| Operator | Name | Example | Description |
|
|
|
|:---------|:---------------|:--------|:---------------------------------------|
|
|
|
| `+` | Addition | `a + b` | Adds together two values |
|
|
|
| `-` | Subtraction | `a - b` | Subtracts one value from another |
|
|
|
| `*` | Multiplication | `a * b` | Multiplies two values |
|
|
|
| `/` | Division | `a / b` | Divides one value by another |
|
|
|
| `%` | Modulus | `a % b` | Returns the division remainder |
|
|
|
| `++` | Increment | `a++` | Increases the value by 1 |
|
|
|
| `--` | Decrement | `a–-` | Decreases the value by 1 |
|
|
|
|
|
|
## Exercise 1: Trying Out Variables
|
|
|
<!--_class: "exercise invert" -->
|
|
|
|
|
|
1) Create a new console application and declare two variables of type `double`.
|
|
|
2) Assign different values for those variables.
|
|
|
3) Print the sum, difference, fraction and product of those values to the console.
|
|
|
|
|
|
## The assignment operator
|
|
|
|
|
|
We have used the assignment operator `=` for assigning values for variables:
|
|
|
```csharp
|
|
|
int x;
|
|
|
x = 25;
|
|
|
```
|
|
|
* ***Note*** the difference between `=` and `==` introduced in [Lecture 3](3-conditionals#comparison-operators)!
|
|
|
* `=` is used for assigning values for variables, `==` is used for ***comparing*** values
|
|
|
|
|
|
### Assignment operators
|
|
|
|
|
|
<div class='columns' markdown='1'>
|
|
|
<div markdown='1'>
|
|
|
|
|
|
| Operator | Example | Same As |
|
|
|
|:---------|:---------|:------------|
|
|
|
| `=` | `x = 5` | `x = 5` |
|
|
|
| `+=` | `x += 5` | `x = x + 5` |
|
|
|
| `-=` | `x -= 5` | `x = x - 5` |
|
|
|
| `*=` | `x *= 5` | `x = x * 5` |
|
|
|
| `/=` | `x /= 5` | `x = x / 5` |
|
|
|
| `%=` | `x %= 5` | `x = x % 5` |
|
|
|
|
|
|
</div>
|
|
|
<div markdown='1'>
|
|
|
|
|
|
* As shown here, there are some assignment operators that work as ***shorthands*** for longer assignments
|
|
|
* Particularly useful when the variable name is longer, so you don't have to write it twice when its value is changed
|
|
|
|
|
|
</div>
|
|
|
</div>
|
|
|
|
|
|
|
|
|
### Assignment operators: An example
|
|
|
|
|
|
```csharp
|
|
|
int uppercaseLetters = 2;
|
|
|
uppercaseLetters += 4; // is now 6
|
|
|
|
|
|
int specialCharacters = 2;
|
|
|
specialCharacters *= 2; // is now 4
|
|
|
|
|
|
Console.WriteLine(uppercaseLetters);
|
|
|
Console.WriteLine(specialCharacters);
|
|
|
```
|
|
|
|
|
|
### Increment and decrement operations
|
|
|
|
|
|
* You can increment or decrement a variable value by 1 with dedicated short-hands
|
|
|
* Most programming languages implement these!
|
|
|
|
|
|
<div class='columns' markdown='1'>
|
|
|
<div markdown='1'>
|
|
|
|
|
|
* Addition example:
|
|
|
```csharp
|
|
|
int a = 3;
|
|
|
|
|
|
a = a + 1; // a is now 4
|
|
|
a += 1; // a is now 5
|
|
|
a++; // a is now 6
|
|
|
```
|
|
|
|
|
|
</div>
|
|
|
<div markdown='1'>
|
|
|
|
|
|
* Subtraction example:
|
|
|
```csharp
|
|
|
int a = 3;
|
|
|
|
|
|
a = a - 1; // a is now 2
|
|
|
a -= 1; // a is now 1
|
|
|
a--; // a is now 0
|
|
|
```
|
|
|
|
|
|
|
|
|
</div>
|
|
|
</div>
|
|
|
|
|
|
* `++` and `--` are called the ***increment and decrement operators***
|
|
|
|
|
|
|
|
|
### Extra: Increment/decrement operation precedence
|
|
|
<!-- _class: "extra invert" -->
|
|
|
|
|
|
* Note that incrementing can be written as ***prefix*** (`++i`) or a ***postfix*** (`i++`)
|
|
|
* In this example, `a++` and `++a` do exactly the same:
|
|
|
```csharp
|
|
|
int a = 3;
|
|
|
a++; // a is now 4
|
|
|
++a; // a is now 5
|
|
|
```
|
|
|
* Their exact difference is [complicated](https://stackoverflow.com/questions/3346450/what-is-the-difference-between-i-and-i-in-c), and in some cases, using either prefix or postfix form can produce different results:
|
|
|
|
|
|
<div class='columns' markdown='1'>
|
|
|
<div markdown='1'>
|
|
|
|
|
|
```csharp
|
|
|
int a = 3;
|
|
|
int b = ++a;
|
|
|
Console.WriteLine(b); // 4
|
|
|
```
|
|
|
Assignment of `b` happens after `++`,
|
|
|
so its value is 4
|
|
|
|
|
|
</div>
|
|
|
<div markdown='1'>
|
|
|
|
|
|
```csharp
|
|
|
int a = 3;
|
|
|
int b = a++;
|
|
|
Console.WriteLine(b); // 3
|
|
|
```
|
|
|
Assignment of `b` happens before `++`,
|
|
|
so its value is 3
|
|
|
|
|
|
</div>
|
|
|
</div>
|
|
|
|
|
|
|
|
|
## Strings
|
|
|
|
|
|
String is a special type, which contains an array of characters. You can declare and assign strings like any other type of variables:
|
|
|
|
|
|
string name = "Johannes Kantola";
|
|
|
|
|
|
You can concatenate multiple strings with the '+' operator:
|
|
|
|
|
|
string firstName = "Johannes";
|
|
|
|
|
|
string lastName = "Kantola";
|
|
|
|
|
|
string fullName = firstName + " " + lastName;
|
|
|
|
|
|
Console.WriteLine(fullName); // Outputs "Johannes Kantola"
|
|
|
|
|
|
## Character Constants
|
|
|
|
|
|
Character constants are preceded by a backslash '\\' and can be used for formatting strings
|
|
|
|
|
|
'\\n' represents a newline in the following example:
|
|
|
|
|
|
string firstName = "Johannes";
|
|
|
|
|
|
string lastName = "Kantola";
|
|
|
|
|
|
string fullName = firstName + "\\n" + lastName;
|
|
|
|
|
|
Console.WriteLine(fullName);
|
|
|
|
|
|
/* This outputs
|
|
|
|
|
|
Johannes
|
|
|
|
|
|
Kantola
|
|
|
|
|
|
*/
|
|
|
|
|
|
All character constants: [https://www.tutorialspoint.com/csharp/csharp\_constants.htm](https://www.tutorialspoint.com/csharp/csharp_constants.htm)
|
|
|
|
|
|
## String Interpolation
|
|
|
|
|
|
Concatenating multiple variables into one string with the '+' operator quickly becomes tedious
|
|
|
|
|
|
It's much easier to use __string interpolation __ by prefixing your target string with '$' and inserting the variables inside curly brackets '{ }':
|
|
|
|
|
|
string animal = "Dog";
|
|
|
|
|
|
string sound = "Woof";
|
|
|
|
|
|
Console.WriteLine($"{animal} says {sound}!");
|
|
|
|
|
|
// Outputs "Dog says Woof!"
|
|
|
|
|
|
## String Formatting
|
|
|
|
|
|
You can add __format strings__ to change the way variables are interpolated into a string
|
|
|
|
|
|
Add the format string after your variable, separated by a colon (:)
|
|
|
|
|
|
You can find an overview of format strings and a handy list of both standard and custom strings [here](https://learn.microsoft.com/en-us/dotnet/standard/base-types/formatting-types)
|
|
|
|
|
|
double pi = 3.141592653;
|
|
|
|
|
|
Console.WriteLine($"Pi to three digits: {pi:G3}");
|
|
|
|
|
|
// Outputs "Pi to three digits: 3.14"
|
|
|
|
|
|
## Console.ReadLine()
|
|
|
|
|
|
For the next exercise, you'll need the Console.ReadLine() method. The method pauses the program, waits for an input stream from the console that pops up, and returns the value of the input:
|
|
|
|
|
|
string userInput = Console.ReadLine();Console.WriteLine(userInput);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
## Exercise 2: Weekday survey
|
|
|
<!--_class: "exercise invert" -->
|
|
|
|
|
|
Create a console application which asks the user which weekday it is and assigns the answer to a string variable.
|
|
|
|
|
|
Print "Have a nice weekday!" to the console where weekday is replaced with the string the user wrote.
|
|
|
|
|
|
## Assignments (arithmetic operations)
|
|
|
<!--_class: "exercise invert" -->
|
|
|
|
|
|
[Assignments about this topic can be found here](https://gitea.buutti.com/education/academy-assignments/src/branch/master/C%23%20Basics/2.3.%20Arithmetic%20Operations)
|
|
|
|