Variable
A variable in C++ is a name for a piece of memory that can be used to store information.
There are many types of variables, which determines the size and layout of the variable's memory;
Variable names
we can use any combination of letters and numbers for Variable and function names but it must start with a letter.
We can use Underscore (_) as a letter in variable name and can begin with an underscore But Identifiers beginning with an underscore are reserved, And identifiers beginning with an underscore followed by a lower case letter are reserved for file scope identifiers Therefore using underscore as starting letter is not desirable.
Akki and akki are different identifiers because upper and lower case letters are treated as different identifiers
Variable Types
There are many 'built-in' data types in C.
short int -128 to 127 (1 byte)
unsigned short int 0 to 255 (1 byte)
char 0 to 255 or -128 to +127 (1 byte)
unsigned char 0 to 255 (1 byte)
signed char -128 to 127 (1 byte)
int -32,768 to +32,767 (2 bytes)
unsigned int 0 to +65,535 (2 bytes)
long int -2,147,483,648 to +2,147,483,647 (4 bytes)
unsigned long int 0 to 4,294,967,295 (4 bytes)
float single precision floating point (4 bytes)
double double precision floating point (8 bytes)
long double extended precision floating point (10 bytes)
Definition, Declaration & Initialization
Definition is the place where variable is created (allocated storage).
Declaration is a place where nature (type) of variable is stated, but no storage is allocated.
Initialization means assigning a value to the variable.
Variables can be declared many times, but defined only once. Memory space is not allocated for a variable while declaration. It happens only on variable definition.
Variable declaration
syntax
data_type variable_name;
example
int a, b, c;
char flag;
Variable initialization
syntax
data_type variable_name = value;
example
int a = 50;
char flag = 't';
external and static
initialisation done once only.
auto and register
initialisation done each time block is entered.
external and static variables cannot be initialised with a value that is not known until run-time; the initialiser must be a constant expression.
A variable that has not been assigned a value is called an uninitialized variable. Uninitialized variables are very dangerous because they cause intermittent problems (due to having different values each time you run the program). This can make them very hard to debug.
3.2 Variable scope
refers to where variables is declared.
It can be Inside a function or a block which is called local variables, In the definition of function parameters which is called formal parameters or Outside of all functions which is called global variables.
Global variables
Global variable are declared outside any functions, usually at top of program. they can be used by later blocks of code:
int g; //global
int main(void)
{
g = 0;
}
Local variables
Variables that are declared inside a function or block are local variables. The scope of local variables will be within the function only. These variables are declared within the function and can't be accessed outside the function.
void main()
{
int g; //local
g=2;
cout << g;
}
3.3 Constants - Literals
Constants refer to fixed values in the code that you can't change and they are called literals.
Constants can be of any of the basic data types and can be divided into Integer literals, Floating-Point literals, Strings, Characters and Boolean Values.
Integer literals
An Integer literal can be a decimal, octal, or hexadecimal constant.
A prefix specifies the base or radix: 0x or 0X for hexadecimal, 0 for octal, and nothing for decimal.
Example
45 //decimal
0213 //octal
0x4b //hexadecimal
Floating-point literals
A floating-point literal has an integer part, a decimal point, a fractional part, and an exponent part. You can represent floating point literals either in decimal form or exponential form.
Example
3.14159
314159E-5L
Boolean literals
There are two Boolean literals and they are part of standard C++ keywords:
A value of true representing true.
? A value of false representing false.
You should not consider the value of true equal to 1 and value of false equal to 0.
Character literals
A character literal can be a plain character (e.g., 'x'), an escape sequence (e.g., '\t'), or a universal character (e.g., '\u02C0').
Escape sequence & Meaning
There are several character escape sequences which can be used in place of a character constant or within a string.
\a alert (bell)
\b backspace
\f formfeed
\n newline
\r carriage return
\t tab
\v vertical tab
\ backslash
\? question mark
\' quote
\'' double quote
\ooo character specified as an octal number
\xhh character specified in hexadecimal
String literals
String literals are enclosed in double quotes. A string contains characters that are similar to character literals: plain characters, escape sequences, and universal characters.
You can break a long line into multiple lines using string literals and separate them using whitespaces.
Here are some examples of string literals. All the three forms are identical strings.
"hello, dear"
"hello, \
dear"
"hello, ""d""ear"
Defining Constants
There are two ways in C++ to define constants:
* Using #define preprocessor.
* Using const keyword.
The #define Preprocessor:
Following is the form to use #define preprocessor to define a constant:
#define identifier value
Example:
#include <iostream>
using namespace std;
#define WIDTH 5
#define LENGTH 10
The const Keyword: You can use const prefix to declare constants with a specific type as follows:
const type variable = value;
Example:
#include&ly;iostream>
using namespace std;
int main()
{
const int LENGTH =10;
const int WIDTH =5;
}
3.4 Variable Storage Classes
auto
The default class. Automatic variables are local to their block. Their storage space is reclaimed on exit from the block.
register
If possible, the variable will be stored in a processor register. May give faster access to the variable. If register storage is not possible, then the variable will be of automatic class.
Use of the register class is not recommended, as the compiler should be able to make better judgement about which variables to hold in registers, in fact injudicious use of register variables may slow down the program.
static
On exit from block, static variables are not reclaimed. They keep their value. On re-entry to the block the variable will have its old value.
extern
Allows access to external variables. An external variable is either a global variable or a variable defined in another source file. External variables are defined outside of any function. (Note: Variables passed to a function and modified by way of a pointer are not external variables)
static external
External variables can be accessed by any function in any source file which make up the final program. Static external variables can only be accessed by functions in the same file as the variable declaration.
3.5 Operators
An operator is a symbol. Compiler identifies Operator and performs specific mathematical or logical operation. C provides following operators :
# Arithmetic Operators
# Logical Operators
# Increment and Decrement Operators
# Relational Operators
# Cast Operators
# Bitwise Operators
# Assignment Operators
# Misc
Arithmetic Operators
* multiplication
/ division
% remainder after division (modulo arithmetic)
+ addition
- subtraction and unary minus
Logical Operators
&& Called Logical AND operator. If both the operands are non-zero, then condition becomes true.
|| Called Logical OR Operator. If any of the two operands is non-zero, then condition becomes true.
! Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true, then Logical NOT operator will make false.
Increment and Decrement Operators
Increment and decrement operators are used to add or subtract 1 from the current value of oprand.
++ increment
-- decrement
Increment and Decrement operators can be prefix or postfix. In the prefix style the value of oprand is changed before the result of expression and in the postfix style the variable is modified after result.
For eg.
a = 9;
b = a++ + 5; /* a=10 b=14 */
a = 9;
b = ++a + 5; /* a=10 b=15 */
Relational Operators
== equal.
!= Not equal.
> < Greater than/less than
>= greater than or equal to
<= less than or equal to
Cast Operators
Cast operators are used to convert a value from one to another type.
(float) sum; converts type to float
(int) fred; converts type to int
Bitwise Operators
Bitwise operators performs operation on actual bits present in each byte of a variable. Each byte contain 8 bits, each bit can store the value 0 or 1
~ one's complement
& bitwise AND
^ bitwise XOR
| bitwise OR
<< left shift (binary multiply by 2)
>> right shift (binary divide by 2)
Assignment Operators
= assign
+= assign with add
-= assign with subtract
*= assign with multiply
/= assign with divide
%= assign with remainder
>>= assign with right shift
<<= assign with left shift
&= assign with bitwise AND
^= assign with bitwise XOR
|= assign with bitwise OR
For example,
a = a + 64; is same as
a += 64;
Misc
sizeof
The sizeof operator returns the size, in bytes, of a type or a variable.
You can compile and run the following program to find out how large your data types are:
cout << "bool:\t\t" << sizeof(bool) << " bytes";
bool: 1 bytes
Condition ? X : Y
Condition operator: If Condition is true ? then it returns value X : otherwise value Y
,
Comma operator causes a sequence of operations to be performed. The value of the entire comma expression is the value of the last expression of the comma-separated list
. (dot) and -> (arrow)
Member operators are used to reference individual members of classes, structures, and unions.
& Pointer operator: & returns the address of an variable. For example &a; will give actual address of the variable.
* Pointer operator: * is pointer to a variable. For example *var; will pointer to a variable var.
Download for more knowledge
https://play.google.com/store/apps/details?id=cpp.programmin
Comments
Post a Comment