Intro to C++ : Variables, Constants, & Data Types

7 min readApr 27, 2019

Variables

They are the fundamental building block for programming. A variable is a named memory location which temporarily stores data that can change while the program is running.

Defining a Variable
Here is a few ways to define a variable in which you give it a type and a name.

int a;
char b;

You can also give a variable a value on definition.

int c = 10;
char d ='d';

An array is a variable that can store multiple items of data unlike a regular variable which can only store one piece of data. Yes, arrays can be variables.

int nums[6];

The pieces of data are stored sequentially in array “elements” that are numbered starting at zero. So the first value is stored in element zero , the second value is stored in element one and so on.

int nums[6] = {0,1,2,3,4,5};

Arrays can be created for any data type but each element may only contain data of the same data type. Collectively elements in an array is known as an “index”. Arrays can have more than one index.

So whenever you create a variable in C++, you must tell the complier the variable’s name and the variable’s data type (e.g integer, character, floating-point). A variable has three aspects that needs to be checked: name, type, value.

What’s in a Name? Aspect #1.

The name of a variable is known as its identifier. Every variable must have a name, but must adhere to the naming conventions where the chosen name may contain letters, digits, and the underscore character but cannot begin with the digit.(It’s best not to use underscore for portability ).

Case Sensitivity
Whether you use uppercase or lowercase letters really matters. Names are very case-sensitive in C++ from keywords to functions to variables, they are all case-sensitive.

a Rose, is not a rose, is not a ROSE 🌹

Scope.
Before the ruling of the scope is that a variable cannot be used in any part of the program before it is defined. A variable scope is limited to the part of the program that has access to the variable. Local, global and so on.

Global Scopeinclude <iostream>
using namespace std;
int x;                // Global variable declared
int main()
{
    x=10;                 // Initialized once
    cout <<"first value of x = "<< x;
    x=20;                 // Initialized again
    cout <<"Initialized again with value = "<< x;
}--------------------------------------------------Local Scopeinclude <iostream>
using namespace std;
int main()
{
    int i=10;
    if(i<20)        // if condition scope starts
    {
        int n=100;   // Local variable declared and initialized
    }              // if condition scope ends
    cout << n;      // Compile time error, n not available here
}

Keywords
Keywords must be avoided when naming constants, variables or any other identifier’s name.

Keywords
╔════════════╦═══════════╦═════════════════╦═══════════╗
║asm         ║ else      ║ new             ║ this      ║
║auto        ║ enum      ║ operator        ║ throw     ║
║bool        ║ explicit  ║ private         ║ true      ║
║break       ║ export    ║ protected       ║ try       ║
║case        ║ extern    ║ public          ║ typedef   ║
║catch       ║ false     ║ register        ║ typeid    ║
║char        ║ float     ║ reinterpret_cast║ typename  ║
║class       ║ for       ║ return          ║ union     ║
║const       ║ friend    ║ short           ║ unsigned  ║
║const_cast  ║ goto      ║ signed          ║ using     ║
║continue    ║ if        ║ sizeof          ║ virtual   ║
║default     ║ inline    ║ static          ║ void      ║
║delete      ║ int       ║ static_cast     ║ volatile  ║
║do          ║ long      ║ struct          ║ wchar_t   ║
║double      ║ mutable   ║ switch          ║ while     ║
║dynamic_cast║ namespace ║ template        ║           ║               ╚════════════╩═══════════╩═════════════════╩═══════════╝

Why Specify the Type? Aspect #2

In order for a variable to be declared, it must be specify the type of data that it may contain. Why? It lets the complier know how much memory needs to be set aside to hold that variable’s value. So all in one, a variable has three aspects that needs to be checked: name, type, value. The basic syntax shown below accomplishes the first two.

Basic Syntax
VariableType VariableName;

Multiple Variables of the same data type can be created.
VariableType VariableName1, VariableName2, VariableName3;

Run the program below to see the memory size of different data types.

Quick Intro to Data Types & Modifiers

Diving into Primitives, Modifiers, TypeQualifier, TypeDef, & more before moving onto aspect #3.

Primitives Data Types
Built-in or predefined data types and can be used directly by the user to declare variables. e.g int, char , float, bool etc.

DATA TYPES (Primitive)
╔══════════╦════════════════╦══════════════════════╦═══════════════╗
║ Keyword  ║ Type           ║Description           ║    Example    ║
╠══════════╬════════════════╬══════════════════════╬═══════════════╣
║ char     ║ character      ║ a single byte        ║ 'A'           ║ ╠══════════╬════════════════╬══════════════════════╬═══════════════╣
║ int      ║ integer        ║ a whole number       ║ 10            ║
╠══════════╬════════════════╬══════════════════════╬═══════════════╣║ float    ║ floating point ║ a floating number,   ║ .0123456      ║ ║          ║                ║ correct to 6 numbers ║               ║  ╠══════════╬════════════════╬══════════════════════╬═══════════════╣
║ double   ║ double floating║ a floating number,   ║ .0123456789   ║  
║          ║    point       ║correct to 10 numbers ║               ║ 
╠══════════╬════════════════╬══════════════════════╬═══════════════╣
║ bool     ║ boolean        ║ check the state      ║ true or false ║ ║          ║                ║ of a variable        ║     0 or 1    ║ ╠══════════╬════════════════╬══════════════════════╬═══════════════╣║ void     ║ valueless      ║ W/o any value        ║               ║       
╠══════════╬════════════════╬══════════════════════╬═══════════════╣   ║ wchar_t  ║ wide character ║ size greater than the║               ║
║          ║                ║ normal 8-bit datatype║               ║
╚══════════╩════════════════╩══════════════════════╩═══════════════╝More exampleschar a = 'A';          // character type
int a = 1;             // integer type
float a = 3.14159;     // floating point type 
double a = 6e-4;       // double type (e is for exponential)

Data Types Modifiers
There are four datatype modifiers: signed, unsigned, long, short. The datatype modifiers are used with the built-in data types to modify the length of data that a particular data type can hold, except for type void.

Data Types (Modifiers)
╔════════════════╦══════════════╦════════════════╗
║ short          ║ int          ║ long           ║
║ unsigned short ║ unsigned int ║ unsigned long  ║
║ signed short   ║ signed int   ║ signed long    ║
╚════════════════╩══════════════╩════════════════╝Note short is short name for short int 
Note long is short name for long int.

What are the rules for assigning variable with the above data types?

Assign short, int or long data types when you are sure a variable is an integer number (NO decimal points). While these three integer choices are available, based upon the size of the numbers you are using.
Assign float or double when decimals are needed.
Assign char if the variable will always contain ONE character of data. This means only one letter (or character).

Data Types Modifiers
Be used along with built in datatypes to make them more precise and even expand their range.

Data Types (Modifiers by Categories)
╔════════════════╦════════════════╦════════════════╗
║ Integer Type   ║ Character Type ║ Floating-Point ║                      ║    Example     ║   Modifier     ║ Type Modifiers ║
╠════════════════╬════════════════╬════════════════╣
║ short          ║ char           ║ float          ║
║ unsigned short ║ unsigned char  ║ double         ║
║ signed int     ║ signed char    ║ long double    ║
╚════════════════╩════════════════╩════════════════╝

Integer Type Modifiers
Offers three types of integers: short, int, and long that can represent up to three different integer sizes.

Unsigned, numbers are always positive.
Unsigned type are used for quantities that are never negative such as populations, sports, scores, inventory, etc.
Signed types includes both positive and negative numbers and is the default type.
Size hierarchy: short int < int < long int

Character Type Modifiers
Large enough to represent the entire range of basic symbols — all the letters, digits, punctuation and the like — for the target computer system.

char is neither signed nor unsigned by default, unlike int.
holds numbers i.e characters/symbols
unsigned char range(0–256)
signed char range (-128 to 127)

Floating Point Type Modifiers
Have three floating types : float, double, and long double. A float allows you to store decimal values that would be declared in the following.

float pi = 3.14;
double morePrecisePi= 22.0 / 7;

double precision float is simply called a double.
long float is not a legal type.
there are no short floating point numbers.
Size Hierarchy : float < double < long double

Type Qualifiers in C++
The type qualifiers can help provide additional information about the variables they precede.

╔═══════════╦═══════════════════════════════════════════════╗
║ const     ║  Objects of type const cannot be changed      ║
║           ║  by your program during execution             ║
╠═══════════╬═══════════════════════════════════════════════╣
║ restrict  ║  a pointer qualified is initially the only    ║
║           ║  means by which the object it points to can   ║
║           ║  be accessed.                                 ║
╠═══════════╬═══════════════════════════════════════════════╣ 
║ volatile  ║  the modifier volatile tell the compiler that ║
║           ║  a variable value maybe changed in ways not   ║               
║           ║  explicit specified by the program            ║ ╚═══════════╩═══════════════════════════════════════════════╝

Constants
A constant is a named memory location which temporarily stores data that remains the same throughout the execution of the program. Define a variable as a constant. Use the keyword ‘const’ to define a constant.

*Should not change a single thing because that variable cannot be changed during the program. You should be receiving this error: cannot assign to variable ‘benchGoal’ with const-qualified type ‘const int’ and such.*

Enumerated Constants
This means that programmer can create a new variable type and then assign a finite number of values to it. What purpose does this serve? When you need a type of variable whose values are restricted by a certain set.

//Use the keyword ‘const’ to define a constant.enum RainbowColor
{
   Violet = 0;
   Indigo,
   Blue,
   Green,
   Yellow,
   Orange,
   Red
};

Another example has “enum variable” has 12 possible values.

enum MONTH {Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec};

BTW, Use a singular name for the enum. e.g MONTH instead of MONTHS.

Another way to understand this is using a compass example.

#include <iostream>
using namespace std; 
int main()
{
    // set up the enumeration
    enum Direction {North, Northeast, East, Southeast, South, Southwest, West, Northwest };   //create a variable to hold the it
   Direction heading;
   heading = Southeast;   cout << "Moving " << heading;
   return 0;
}

TypeDef
You can also define your own name for a built in data type. You have to at least use the keyword typedef.

typedef double MyDouble;double dAmount;
MyDouble dAmount; //Same like 'double dAmount;'

Aspect #3: Value.

A variable can be given a value through an assignment statement.

unsigned int highScore;
highScore = 3000;

Congrats you learned a lot more about variables, constants, and data types ! The biggest challenge with variables comes with choosing the proper data type. Remember to keep in mind when working with variables, the number of bytes differs by data type.

Next we will be focusing more on using expression, statements, operators.

If you enjoy this, don’t miss the other articles in this order.