Introduction

Data types

The need for data types is quite obvious to anyone who is familiar with at least one programming language. Data types allow a programmer to create variable for manipulating data in programs. The power of a programming language is often measured by the variety and abundance of data type’s that it supports.

Data types in C++ can be classified under various categories – fundamental and user defined. The fundamental data types are those at the lowest level that is, used for actual representation in memory. The fundamental data types and their functions are listed in the fallowing table.

Name	Description	Size*	Range*
Char	Character or small integer	1 byte	signed: -128 to 127 unsigned: 0 to 255
short int (short)	Short Integer	2 bytes	signed: -32768 to 32767 unsigned: 0 to 65535
Int	Integer	4 bytes	signed: -2147483648 to 2147483647 unsigned: 0 to 4294967295
Long Int (Long)	Long Integer	4 bytes	signed: -2147483648 to 2147483647 unsigned: 0 to 4294967295
Bool	Boolean value. It can take one of two values: true or false	1 byte	true or false
Float	Floating point number	4 bytes	3.4e +/- 38 (7 digits)
Double	Double precision floating point number	8 bytes	1.7e +/- 308 (15 digits)
Long double	Long double precision floating point number	8 bytes	1.7e +/- 308 (15 digits)
wchar_t	Wide character.	2 bytes	1 wide character

Example 1:

#inclde <iostream.h>
int  main()
{
    //declare variable;
    int x,y;
    int res;
    //process
    x= 4 ;
    y= 3;
    x = x+1;
    res = x - y;
    //print out the result
    cout<<result;
    return 0;
}

Example 2:

#include<iostream.h>
#include<string.h>
int   main()
{
    char mychar;
    mychar = 'f';
    cout <<"my first char:" <<mychar<<endl;
    mychar = 's';
    cout<<"my different char: " << mychar<<endl;
    return 0;
}

The size of a data type or object can be determined by using the statement sizeof operator. This determines the size of the particular type or object.

User defined keywords

User defined data types are those defined by the user using the typedef keyword. User does not actually create a new data type, but rather defines a new name for an existing type. The general form of the typedef statement is

         typedef type newname;

Where type is any valid data type and newname is the name for this data type. For, example, a new name for float can be created using

         typedef float balance;

Compiler recognizes balance as another name for float. A float variable can be created using

         balance overdue;

User-defined data types can also be created in two other ways: by sing the struct keyword and by sing the class keyword, which will be discussed in detail in the later parts of this book.

// defined constants: calculate circumference  
#include<iostream.h>
#define PI 3.14159
#define NEWLINE "\n"
int main()
{
    float r = 5.0; //radius
    float circle;
    circle = 2*PI*r;
    cout<<circle;
    cout<<NEWLINE;
    return 0;
}

Variables:

A variable is a named location in memory that is used to hold a vale that may be modified by the program. All variables must be declared before they can be used.

Variables are fundamental to any language. Values can be assigned to variables, which can be changed in the course of program execution. The value assigned to a variable is placed in the memory allocated to that variable. Variables can be created of fundamental as well as user- defined data types.

Character variables: are used to store characters like ‘a’, ’C’, ’K’ and so on

Integer variables: are used to store whole numbers

Float variables: are used to store floating-point numbers

Boolean variables: are used to store true or false. A bool is used to express result of logical operations

Declaration of variables:

There is a difference between C and C++ with respect to the place of their declaration within the variable’s scope or the program. C requires all variables to be declared at the beginning of the program or function. A declaration that comes after an action statement is invalid in C. The compiler will refuse to compile the program.

This is not so in the case of C++, variables can be declared anywhere within the program or function – as and when they are required. The general form of declaration is

         type variable_list;

Here, type must be a valid data type and variables_list may consist of one or more identifier names separated by commas. Here are some declarations:

         int i, j, k;
         Double balance, profit;
         Char a;

Type Qualifiers

C++ includes two type qualifiers, the keywords const and volatile that define the nature and behavior of variables.

Const Type Qualifier

Variables of type const may not be changed by the program. The compiler is free to place the variable of this type into read-only memory (ROM). For example,

         const int a = 10;

Volatile Type Qualifier

A volatile variable is the opposite of const. the volatile type qualifier tells the compiler that the program can change the variable in unseen ways.

         volatile int a = 10;