---
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);

![](imgs/2%20Variables%20and%20Types_1.png)


## 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)

