Variables are named locations where we can store information.

We use variables in programming as places to temporarily store data so that we can manipulate that data. We can have the user write to it via the keyboard, we can use files to write data to variables, we can do math operations or modify these variables, and we can print* them back out to the screen or a text file. (*Printing here meaning "display on the screen"; not to a printer.)

When we're writing programs in C++, we need to tell our program what the data type of each variable is, and give each variable a variable name (aka identifier). When a variable is declared, a space in RAM is allocated to that variable and it can store its data there. That data can be manipulated or overwritten later as needed in the program.

Some examples of things we might store as variables:

• A student's information:
  • string studentName, the name of a student
  • float studentGpa, the GPA of that student
  • int creditHoursCompleted, the total amount of credit hours the student has completed
  • bool activeStudent, whether the student is an active student or not (e.g., graduated?)
• A store website's item listing:
  • string name, the name of the product
  • float price, the price of the product
  • int quantity, how much of this product is in stock

In C++, when we want to create a variable we need to tell the compiler what the data type of the variable is. Data types specify what is stored in the variable (whole numbers? numbers with decimal values? text? true/false values?). Each data type takes up a different amount of space in memory.

Some of the common data types we'll use are:

• Floats and doubles both store numbers with fractional (decimal) parts, but a double takes up double the memory in RAM, allowing to store more accurate fractional amounts. A float has 6 to 9 digits of precision and a double has 15 to 18 digits of precision. (From https://www.learncpp.com/cpp-tutorial/floating-point-numbers/)
• Boolean data types store true and false values, but will also accept integer values when assigned. It will convert a value of 0 to false and any other number to true.
• String variables' values must be written within double quotes "Hello!"
• Character variables' values must be written within single quotes 'Z'

Additional information: Unsigned data types

Sometimes it doesn't make sense to store negative values in a variable - such as speed (which isn't directional, like velocity), the size of a list (can't have negative items), or measurement (can't have negative width). You can mark a variable as unsigned to essentially double its range (by getting rid of the negative side of values). For instance, a normal int can store values from -2,147,483,648 to 2,147,483,647, but if you mark it as unsigned, then your range is 0 to 4,294,967,295.

Whenever you find yourself using a literal value in your assignment statements, you may want to think about whether you should replace it with a named constant instead.

const CONSTNAME = LITERAL;

A named constant looks like a variable when you declare it, but it also has the keyword const - meaning that the value can't change after its declaration.

Let's say you wrote a program and hard-coded the tax rate:

// Somewhere in the code...
totalPrice = cartTotal + ( cartTotal * 0.0948 );

// Somewhere else in the code...
cout << 0.0948 << " sales tax" << endl;

Then the tax rate changes later on. You would have to go into your program and search for "0.0948" and update all those places! Instead, it would have been easier to assign the tax rate ONCE to a named constant and referred to that instead:

// Beginning of program somewhere...
const SALES_TAX = 0.0948;

// Somewhere in the code...
totalPrice = cartTotal + (cartTotal * SALES_TAX);

// Somewhere else in the code...
cout << SALES_TAX << " sales tax" << endl;

If you ever find yourself using the same literal multiple times in your program, then perhaps consider replacing it with a named constant.

While you can generally name a variable whatever you'd like, you still need to adhere to the syntax rules of the C++ language. In particular:

• Names can only contain letters (upper- and lower-case), numbers, and underscores.
• Spaces are not allowed in a variable name!
• Names cannot start with a number.
• A name cannot be a keyword in C++, a name reserved for something else in the language, such as void, if, int, etc.

There are also naming conventions used so that variables (and later on functions and structs/classes) have a consistent naming scheme:

• Variables:
  • One common style is lowerFirstLetterThenUpperCase for variable names - this is called Camel Case.
  • Another style you might see in C++ code is all_lower_with_underscores.
  • You might see both of these styles in my starter code or examples, but I try to stick to one style for a program. You should also choose one and stay consistent in each program.
• Named constants:
  • It is customary to give your named constants names in ALL CAPS, using underscores (_) to separate words. For example: TOTAL_STUDENTS, OP_TAX_RATE, etc.

Everything in C++ is case sensitive, which means if you name a variable username, it will be a different variable from one named userName (or if you type "userName" when the variable is called "username," the compiler will complain at you because it doesn't know what you mean).

Now that you have variables available in your program to play with, what can you even do with them?