Lvalues and Rvalues
Lvalues and Rvalues
A scope is a region of the program and broadly speaking there are three places, where
variables can be declared.
Local Variables:- Variables that are declared inside a function or block are
local variables. They can be used only by statements that are inside that
function or block of code.
Global Variables:- Global variables are defined outside of all the functions,
usually on top of the program. The global variables will hold their value
throughout the life-time of your program. A global variable can be accessed
by any function.
The type qualifiers provide additional information about the variables they
precede.
A storage class defines the scope (visibility) and life-time of variables and/or
functions within a C++ Program. These specifiers precede the type that they
modify. There are following storage classes, which can be used in a C++
Program
auto
register
static
extern
mutable
The auto storage class is the default storage class for all local variables.
The register storage class is used to define local variables that should be
stored in a register instead of RAM. This means that the variable has a
maximum size equal to the register size (usually one word) and can't have
the unary '&' operator applied to it (as it does not have a memory location).
{
register int miles;
}
The register should only be used for variables that require quick access such
as counters. It should also be noted that defining 'register' does not mean
that the variable will be stored in a register. It means that it MIGHT be
stored in a register depending on hardware and implementation restrictions.
The static storage class instructs the compiler to keep a local variable in
existence during the life-time of the program instead of creating and
destroying it each time it comes into and goes out of scope. Therefore,
making local variables static allows them to maintain their values between
function calls.
The static modifier may also be applied to global variables. When this is
done, it causes that variable's scope to be restricted to the file in which it is
declared.
In C++, when static is used on a class data member, it causes only one copy
of that member to be shared by all objects of its class.
The extern storage class is used to give a reference of a global variable that
is visible to ALL the program files. When you use 'extern' the variable cannot
be initialized as all it does is point the variable name at a storage location
that has been previously defined.
When you have multiple files and you define a global variable or function,
which will be used in other files also, then extern will be used in another file
to give reference of defined variable or function. Just for understanding
extern is used to declare a global variable or function in another file.
The extern modifier is most commonly used when there are two or more
files sharing the same global variables or functions as explained below.
The mutable specifier applies only to class objects, which are discussed
later in this tutorial. It allows a member of an object to override const
member function. That is, a mutable member can be modified by a const
member function.
Operator in C++
Arithmetic Operators
Relational Operators
Logical Operators
Bitwise Operators
Assignment Operators
Misc Operators
Bitwise Operators
Bitwise operator works on bits and perform bit-by-bit operation. The truth
tables for &, |, and ^ are as follows −
The Bitwise operators supported by C++ language are listed in the following
table. Assume variable A holds 60 and variable B holds 13, then −
Assignment Operators
Misc Operators
The following table lists some other operators that C++ supports.