Variables allow us to assign data to a word, then we can use that word within our program.

Variables

Now that we have outputted a variable and have also outputted things using multiple `cout`s, let's take a closer look at `cout` again. 

If we have the code below:

```cpp
int age = 28;

std::cout << "Hello, I am ";
std::cout << age;
std::cout << " years old\n";
```

It will output:

```
Hello, I am 28 years old
```

Notice how we use quotes around the characters in `"Hello, I am "` but not in `age`. 
- We use quotes when we want a literal [string](https://www.codecademy.com/resources/docs/cpp/strings?page_ref=catalog). 
- We don't use quotes when we refer to the value of something with a name (like a [variable](https://www.codecademy.com/resources/docs/cpp/variables?page_ref=catalog)).

So now, is it possible to write the `cout` statements within a single line?

Yep! You can use multiple `<<` operators to *chain* the things you want to output.

For the same code above you can also do:

```cpp
int age = 28;

std::cout << "Hello, I am " << age << " years old\n";
```

This is called **chaining**.

Chaining

Like we mentioned in the introduction, another way to assign a value to a variable is through user input. A lot of times, we want the user of the program to enter information for the program.

We have `cout` for output, and there is something called `cin` that's used for input!

```cpp
std::cout << "Enter your password: ";
std::cin >> password;
```

The name [`cin`](https://www.codecademy.com/resources/docs/cpp/user-input?page_ref=catalog) refers to the standard input stream (pronounced "see-in", for **c**haracter **in**put). The second operand of the `>>` operator ("get from") specifies where that input goes.

To see how it works, we have to try it with a program.

User Input

Now that we've learned about the basics of variables and [`cin`](https://www.codecademy.com/resources/docs/cpp/user-input?page_ref=catalog), let's write a program!

The mad scientist Kelvin has mastered predicting the weather in his mountain-side meteorology lab.

Recently, Kelvin began publishing his weather forecasts on his website, however, there's a problem: All of his forecasts describe the temperature in Fahrenheit degrees.

Let's convert a temperature from Fahrenheit (F) to Celsius (C).

The formula is the following:

```tex
C = (F - 32) / 1.8
```



Challenge: Temperature (Part 1)

We can both declare and assign a value to a [variable](https://www.codecademy.com/resources/docs/cpp/variables?page_ref=catalog) in a single initialization statement. 

Suppose we have these two lines:

```cpp
// Declare a variable
int score;

// Initialize a variable
score = 0;
```

We can actually combine these two lines into a single line of code: 

```cpp
int score = 0;
```

This means we are declaring an integer called `score` and setting it equal to 0.

<img src="https://content.codecademy.com/courses/learn-cpp/variables/declare-initialize.png" title="Combining the two steps.">

**Note:** We only need to declare a variable one time! And it is highly suggested to initialize a variable before using it later.

Combining Step 1 and Step 2

Variable types: int for integers like 0 or 420, double for floating-point numbers like 3.14 or -200.0, char for characters like 'a' or '@', string for a sequence of characters like "Hello World" or "Codecademy", bool for truth values like true or false.

The `"Hello World!"` program simply writes to the screen. It does not read anything, calculate anything, or allow for user input. That's no fun! 

Real programs tend to produce results based on some input that the user of the program gives, rather than just outputting the same thing every time.

To read something from the keyboard, we first need somewhere in the computer's memory to *store data*. That is where variables come in.

A [**variable**](https://www.codecademy.com/resources/docs/cpp/variables?page_ref=catalog) is simply a name that represents a particular piece of your computer's memory that has been set aside for you to store, retrieve, and use data. 

In this lesson, we will learn about some of the basic [data types](https://www.codecademy.com/resources/docs/cpp/data-types?page_ref=catalog):

- `int`: integer numbers
- `double`: floating-point numbers 
- `char`: individual characters
- `string`: a sequence of characters
- `bool`: true/false values

Every variable has a **type**, which represents the kind of information you can store inside of it. It tells your compiler how much memory to set aside for the variable, and it defines what you can do with the variable.

Introduction to Variables

After we declare a [variable](https://www.codecademy.com/resources/docs/cpp/variables?page_ref=catalog), we can give it a value!

Suppose that we have declared an `int` variable called `score`, to set it to 0, we can simply write:

```cpp
score = 0;
```

- The `score` is the name of the variable.
- The `=` indicates assignment.
- The `0` is the value you want to store inside the variable.

**Note:** In C++, a single equal sign `=` does not really mean "equal". It means "assign". In the code above, we are assigning the `score` variable a value of 0.

Step 2: Initialize a Variable

Computers are incredible at doing calculations. Now that we have declared [variables](https://www.codecademy.com/resources/docs/cpp/variables?page_ref=catalog), let's use them with *arithmetic operators* to calculate things!

Here are some [arithmetic operators](https://www.codecademy.com/resources/docs/cpp/operators?page_ref=catalog):

- `+` addition
- `-` subtraction
- `*` multiplication
- `/` division
- `%` modulo (divides and gives the remainder)

For example:

```cpp
int score = 0;
// score is 0

score = 4 + 2;
// it is now 6

score = 4 - 2;
// it is now 2

score = 4 * 2;
// it is now 8

score = 4 / 2;
// and now 2

score = 5 % 2;
// and now 1
```

**Note:** The order of operations can be specified using parentheses. For example, the use of parentheses in `score = 5 * (4 + 3)` sets `score` equal to `5 * 7` rather than `20 + 3`.

Arithmetic Operators

<blockquote>"Every variable in C++ must be declared before it can be used!"</blockquote>

Suppose we are building a game and we want to keep track of a player's score that goes from 0 to 10. We need a variable!

Before we can use a [variable](https://www.codecademy.com/resources/docs/cpp/variables?page_ref=catalog), we must *declare*, or create, it. To declare a variable, we need to provide two things:

- A [type](https://www.codecademy.com/resources/docs/cpp/data-types?page_ref=catalog) for the variable.
- A name for the variable.

So to declare an integer variable called `score`, we need to write:

```cpp
int score;
```

- The `int` is the type of the variable.
- The `score` is the name of the variable.
- The `;` is how we end a statement.

In C++, variable names consist only of upper/lower case letters, digits, and/or underscores.

**Note:** C++ is known as a *strongly typed* language. If you try to assign a value of one type to a variable that is a different type, you may get unexpected results, warnings, or errors.


Step 1: Declare a Variable

Let's go back to the **temperature.cpp** that we wrote. This time, instead of giving `tempf` a value of the current temperature in New York:

```cpp
tempf = 83;
```

Let's ask the user what the temperature is using [`cin`](https://www.codecademy.com/resources/docs/cpp/user-input?page_ref=catalog)!

Challenge: Temperature (Part 2)

You made it to the end of the lesson! High five. 🙌

Here is a review of the lesson:

- A [variable](https://www.codecademy.com/resources/docs/cpp/variables?page_ref=catalog) represents a particular piece of your computer's memory that has been set aside for you to use to store, retrieve, and manipulate data.
- C++ basic [data types](https://www.codecademy.com/resources/docs/cpp/data-types?page_ref=catalog) include:
  - `int`: integers
  - `double`: floating-point numbers
  - `char`: individual characters
  - `string`: sequence of characters
  - `bool`: true/false
- Single equal sign `=` indicates assignment, not equality in the mathematical sense.
- [`cin`](https://www.codecademy.com/resources/docs/cpp/user-input?page_ref=catalog) is how to receive input from the user.