csharp-basics/2-variables-and-types.md

---
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 that contains an array of characters.
  ```csharp
  string name = "Sini Aalto";
  ```
* You can ***concatenate*** (i.e., combine) multiple strings with the `+` operator:
  ```csharp
  string firstName = "Sini";
  string lastName = "Aalto";
  
  string fullName = firstName + " " + lastName;
  
  Console.WriteLine(fullName);    // Outputs "Sini Aalto"
  ```

### Character Constants

* Character constants are preceded by a backslash `\` and can be used for formatting strings
* `\n` represents a ***newline***
  ```csharp
  string firstName = "Johannes";
  string lastName = "Kantola";
  string fullName = firstName + "\n" + lastName;
  Console.WriteLine(fullName);

  /* This outputs
  Johannes

  Kantola
  */
  ```
* All character constants are listed [here](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 `{ }`:
  ```csharp
  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)
  ```csharp
  double pi = 3.141592653;
  Console.WriteLine($"Pi to three digits: {pi:G3}");
  // Outputs "Pi to three digits: 3.14"
  ```

## User input with `Console.ReadLine()`

<div class='columns21' markdown='1'>
<div markdown='1'>

* 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:
  ```csharp
  string userInput = Console.ReadLine();
  Console.WriteLine(userInput);
  ```

</div>
<div markdown='1'>

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

</div>
</div>

## Exercise 2: Weekday survey
<!--_class: "exercise invert" -->

1) Create a console application that asks the user which weekday it is and assigns the answer to a string variable.
2) 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)