Variables: Lesson

Let's get back to understanding variables in C.  Now that we have our variable, we know its name and what it can hold, what do we do with it? Right now it's empty and doesn't serve any real purpose. A variable's power comes from its ability to be set, changed, and examined. So the question is, how do we do that?

There are two ways to set a value, for now let's look at how to set the value when you create the variable itself:
```c
int example = 3;
```

In this case, not only have you created the variable, named it `example`, and identified it to hold whole numbers, you have set its value to be `3`. We've saved time by doing all these parts in one line!

When declaring a `char`, you need single quotes around it:
```c
char foo = 'a';
char goo = '2';
```


Initialization

So why are there two different types for decimals in C? The short answer is different types for different situations.

A `float` has less precision than a `double`, 6 vs 15 possible decimal places respectively, and therefore takes up less memory (4 vs 8 bytes). However, a `double` run faster, so you gain speed at the cost of more memory usage.

The other thing to be aware of is that the system is rounding the values you store in either. This can cause unexpected results, especially with a `float` as they have less precision. This is why you will see `double` being used any time accuracy is important, such as in scientific, medical or financial applications.

Float and Double, What's the Difference?

A more interesting casting option is converting a `char` to a number type, or the other way around. Just like before, you have to be careful how you set this up. In the back-end, a `char` doesn't store `'a'`, it stores the value representing that: 97 for lowercase and 65 for uppercase.
```c
int targetInt;
char sourceChar = 'a';
targetInt = (int)sourceChar;
```
Now `targetInt` equals 97.

When you cast an `int` to a `char`, you get the opposite process and the `char` is set to the value at the `int` value. So if you did:
```c
int sourceInt = 65;
char targetChar;
targetChar = (char)sourceInt;
```
`targetChar` now equals `'A'`.

Casting Types Continued

In this Lesson on variables in C we learned:
1. The rules for naming variables in C.
2. The main data types in C: `int`, `float`, `double`, and `char`.
3. Declaration and initialization of data types in C, as well as how to change their value.
4. How to cast from one data type to another and some potential limitations in C.

We went over a general introduction to variables, but there is much more to learn. You should now have the building blocks we will add on to. In the next lesson, we will go over more options you have with variables, such as arithmetic, comparisons, and logical operators that will allow you to expand on the power of variables in C. Thank you for joining us and we can't wait to dive into the next lesson with you.

Review

What about that first part of our template `type` (from `type variable_name`)? We saw some examples in the previous exercise when you corrected the bad variable names, but let's talk about what they are.

The type of a variable denotes what kind of information can be stored in it. C has a good number of types you can use, but in this lesson, we will go over some of the most common ones: `int`, `float`, `double`, and `char`.

In C, you must specify the type of the variable when you declare it. Once it is set, that type of information is the only type that can go into that variable. So if you create a variable of type `int`, which can only store whole numbers, you will not be able to store `"a"` nor `1.2` in it. The table below details these types we are going over and what information can go into each.

| Type | Description | Values |
| --- | --- | --- |
| `int` | a whole number | -2,147,483,648 to 2,147,483,647 |
| `float` | a number with possible decimals | 6 decimal places |
| `double` | a number with possible decimals | 15 decimal places |
| `char` | stores one character (letter or number) | a single character |

There are a few questions you might be asking yourself looking at these descriptions. What's the difference between a `float` and a `double`? We are going to look at this in the next exercise. `char` holds a single letter or number, but what if you want to store something like a person's name, that is more than one character (in most cases)? That gets a bit more technical and you will learn about how that works in the lesson on strings later in the course!


Data Types

In this lesson you will learn about:
1. The rules for naming variables in C.
2. The main data types in C: `int`, `float`, `double`, and `char`.
3. Declaring and initializing data types in C, as well as changing their value.
4. Casting from one data type to another, and some potential limitations in C.

Let's start with what a _variable_ is. It is a reference used to store information for future use. For instance, `int score` can be called later in your code to assign, change, compare, etc. In this example, you can see the basic structure of variable creation (known as _declaration_) is `type variable_name`. Have no fear, we will go over each part of this and more in this lesson. Specifically, we will cover how to create, name, assign, modify, and convert them to different types.

As a bonus tip right from the start, you can create more than one variable of the same type at a time by listing them with commas between their names, like `type` `variable1`, `variable_2`, `variable_3`, `variable4`.

What is a Variable in C?

We are going to start with the second part of our variable declaration, `type variable_name`, the `variable_name`. C does not allow you to throw anything down and call it a variable name, there are some restrictions.

- Names can be composed of upper and lower case letters, numbers, and underscores.
- The first character must be a letter (upper or lower case).
- No keywords are allowed as the full name (`int` is not allowed but `int_count` would work).

That's it, nothing too crazy, just keep those rules in mind when you are creating your names for your variables.


Naming Standards

In most cases, variable values can be changed in the program, however, there are cases where you do not want to allow for your variables to change value. This is where _constants_ come into play. These special types prevent any changes during execution once the value is set at declaration.

Any basic data type in C, like those we have gone over, can be declared as a constant using the keyword `const` before the type. So instead of our template of `type variable_name`, it would be `const type variable_name`.

It is also a best practice to use all upper case letters when declaring a constant:
```c
const int DAYSINWEEK = 7;
```

Constants

Before, we said that there are two times when you can set a variable's value. We just examined how to set it at declaration, but if that's the only place it could be set, variables would have limited value (we will see in a moment an exception to this rule). It turns out they can also be set at any future point in the code! As an example:
```c
int total_units;
…
…
…
total_units = 3;
```
Notice that once we have declared the type we no longer reference the type, we just use the name of the variable. You can also set a variable to be the same as what is stored in another variable, such as `a = b`. If you change `b` after this, the values will no longer match (there is a way to tie the two variables together so they always match, but we will get to that in a later lesson).

Have no fear, we will go over how to do more advanced things with setting the values stored in a variable shortly.

Updating Values

We are going to take a little detour for a minute to help you understand what is going on in the code in the lessons. You might have noticed `printf()` at the bottom of some exercises. This allows for text output to the terminal.

The basic format is `printf("string to display", [list of optional parameters])`.

So if you had something like `printf("Hello World!")`, the terminal would display `Hello World!`.

The optional parameters let you add values dynamically into the string, such as values stored in the variables we have been learning about. For example, if we wanted to output `Hello World, today is the 3rd!`, you could do that like this:
```c
int day = 3;
printf("Hello World, today is the %drd!", day);
```

When the compiler runs the code it will replace %d with the value in the variable list, taking them in the order found in the string matching the order they are listed; first in the string is matched with first in the list of parameters).

There are lots of optional formatting and parameter types that can be used, but for our purposes here are a few of the basic ones.

To indicate a variable type you want to replace:

| symbol | type |
| --- | --- |
| %d or %i | int |
| %f | double or float |
| %c | char |

You can also use some reserved symbols within the string to have invoked formatting, here are a few common ones.

| symbol | effect |
| --- | --- |
| \n | newline |
| \r | carriage return |
| \t | tab |


printf()

Sometimes it's useful, or even necessary, to change the value type of a variable and use it for other purposes. For instance, if you had a `double` with a percent score on a test, say 0.95, you would most likely want to display 95% to the user instead. Notice, we are not changing the type of the variable, nor the value stored in the source variable. What we are doing is displaying the changed variable as a new type or storing it in a different variable that might be a different type.

So you could not do this:
```c
int a;
double b = 3.0;
a = b;
```

There are two types of conversions, implicit and explicit. When you set one variable to be the same as another, such as `a = b` above, but their types do not match, the compiler will try to convert them. However, this can be dangerous as you might not know what values will be in the variable at runtime, and it might not be implicitly convertible to another type. Our example above was implicit, the compiler in this case will make a best guess.

The other way to convert a variable from another type is explicitly. You can do this by simply telling the compiler what type you want to set it to. So in our example above we could change the line `a = b` to `a = (int)b`. That way if `b` was something other than 3.0, such as 3.2, we are telling the compiler to make it work, so it would set it to 3.
