A variable provides us with named storage that our programs can manipulate. Each variable in C++
has a specific type, which determines the size and layout of the variable's memory; the range of
values that can be stored within that memory; and the set of operations that can be applied to
The name of a variable can be composed of letters, digits, and the underscore character. It must
begin with either a letter or an underscore. Upper and lowercase letters are distinct because
C++ is case-sensitive:
There are following basic types of variable in C++ as explained in last chapter:
C++ also allows to define various other type of variables which we will cover in subsequent
chapters like Enumeration, Pointer, Array, Reference, Data structures, and Classes.
Following section will cover how to define, declare and use various type of variables.
All variables must be declared before use, although certain declarations can be made implicitly
by content. A declaration specifies a type, and contains a list of one or more
variables of that type as follows:
Here, type must be a valid C++ data type including char, w_char, int, float, double, bool
or any user defined object etc., and variable_list may consist of one or more identifier
names separated by commas. Some valid declarations are shown here:
int i, j, k;
char c, ch;
float f, salary;
A variable declaration with an initializer is always a definition. This means that storage is
allocated for the variable and could be declared as follows:
int i = 100;
An extern declaration is not a definition and does not allocate storage. In effect, it
claims that a definition of the variable exists elsewhere in the program. A variable can be
declared multiple times in a program, but it must be defined only once. Following is the
declaration of a variable with extern keyword:
extern int i;
Variables are initialized (assigned an value) with an equal sign followed by a constant
expression. The general form of initialization is:
variable_name = value;
Variables can be initialized (assigned an initial value) in their declaration. The initializer
consists of an equal sign followed by a constant expression as follows:
type variable_name = value;
Some examples are:
int d = 3, f = 5; // initializing d and f.
byte z = 22; // initializes z.
double pi = 3.14159; // declares an approximation of pi.
char x = 'x'; // the variable x has the value 'x'.
For declarations without an initializer: variables with static storage duration are implicitly
initialized with NULL (all bytes have the value 0); the initial value of all other variables is
It is a good programming practice to initialize variables properly otherwise, sometime program
would produce unexpected result. Try following example which makes use of various types of
using namespace std;
int main ()
// Variable declaration:
int a, b;
// actual initialization
a = 10;
b = 20;
c = a + b;
cout << c << endl ;
f = 70.0/3.0;
cout << f << endl ;
There are two kinds of expressions in C++:
lvalue : An expression that is an lvalue may appear as either the left-hand or
right-hand side of an assignment.
rvalue : An expression that is an rvalue may appear on the right- but not
left-hand side of an assignment.
Variables are lvalues and so may appear on the left-hand side of an assignment. Numeric literals
are rvalues and so may not be assigned and can not appear on the left-hand side. Following is a
int g = 20;
But following is not a valid statement and would generate compile-time error:
10 = 20;
Your Query was successfully sent!