--- marp: true paginate: true math: mathjax theme: buutti title: 2. Variables and Types --- # Variables and Types ## 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`
* 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 ```
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); } } } ```
### Extra: Modifiers * 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 Data types can be ***cast*** to another either...
...implicitly: ```csharp double valueAddedTax = 25.5; decimal valueAddedTaxDecimal = valueAddedTax; ```
...explicitly: ```csharp double valueAddedTax = 25.5; decimal valueAddedTaxDecimal = (decimal)valueAddedTax; ```
* 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) [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) [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 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
| 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` |
* 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
### 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!
* Addition example: ```csharp int a = 3; a = a + 1; // a is now 4 a += 1; // a is now 5 a++; // a is now 6 ```
* Subtraction example: ```csharp int a = 3; a = a - 1; // a is now 2 a -= 1; // a is now 1 a--; // a is now 0 ```
* `++` and `--` are called the ***increment and decrement operators*** ### Extra: Increment/decrement operation precedence * 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:
```csharp int a = 3; int b = ++a; Console.WriteLine(b); // 4 ``` Assignment of `b` happens after `++`, so its value is 4
```csharp int a = 3; int b = a++; Console.WriteLine(b); // 3 ``` Assignment of `b` happens before `++`, so its value is 3
## 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 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) [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)