The C++ Data Types Fundamental Data Types Consists of the following: 1) Integers of different sizes Type Size(bytes) Type Size char 1 int 2 or 4 short 2 long 4 or 8 The above can be preceded by the key words signed or unsigned to specify signed or unsigned integers, e.g.., signed char (defines integer from -127 to 128) unsigned long (defines integers from 0 to (2^64-1) 2) Floating point numbers type Size in bytes float 4 double 8 long double 16 The integer and floating point types can be preceded by the key word const to specify constants, e.g., const int Max=10; // constants must be initialized when declared.

The C++ Data Types Type Conversion Implicit type conversion exists but it is a potential source of errors, e.g., int I; float a=10.5; I = a; // I equals 10 unsigned long x=1000000000000; I = x; // I is undefined Explicit type conversion using casting is done as follows: int I=2, j=5; float c; c = (float) I / (float) j; // floating point divide unsigned long x, int z = 10000; x = (unsigned long) z*z; Type conversion from a wider data type to narrower data type is unsafe. Derived Types Types can be derived using the following declaration operators: 1. * used to specify pointer type objects 2. & used to define references 3. [ ] used to defined arrays 4. () used to define functions other Derived Types can be defined using structs, classes, and enum

The C++ Data Types Pointers are defined using: type_name * object_name; // object_name is a pointer type // object which can be used to point to objects of the particular type examples: int *pi; // data object pi is a pointer to an integer char **pc; // pc is a pointer to a pointer to a character float *v[10]; // v is an array of 10 pointers to float type objects int (*fp)(char, char*); // fp can be used to point to any function which // takes two arguments of type char, and char*, and returns a data value of type int Initializing pointers int* pi, I=10; // Watch out, I is only an integer, whereas pi is a pointer pi = & I; // pi now points to I. & is called the address of operator The above is the same as: int I=10, *pi=&I; // here pi is declared and initialized Objects can be referenced by their pointers as follows: *pi = I + 100; // same as I = I + 100; // *pi refers to object I which pi points to

The C++ Data Types References are defined using: type &object_name= object_name; // object_name can become an alternative name or an alias for objects of the particular type examples: int I = 1; int &r = I; // I and r refer to the same integer type object The use of references is often found in specifying the types of arguments and return values for functions and overloaded operators. The following examples show the use of references as types of arguments or and return values of functions. Example 1: void f(double &A) { A += 3.14;} // f() updates the value of an object //of type double referenced by A, and does not return any values double d = 0.0; // declare and initialize object d f(d); // call f and pass it the reference of d //Compare the above with code using a pointer instead of a reference

The C++ Data Types . // function g() returns the reference of v[I] Example 2: int v[20]; . // function g() returns the reference of v[I] int& g(int I) { return v[I];} . . main(){ // Assume that function main can not directly access the // elements of v[ ], it can do that thr’ calling g() g(3) = 7; // same as v[3] = 7 // Notice that a function call can be placed on the left side of an // assignment operator // the expression g(3) is called an lvalue since g() returns a // reference

The C++ Data Types Constant Pointers, Pointers to Constants, and References to Constants A constant pointer: int I; int *const cp = &I; // cp is initialized to point to I // cp can not point to any other object A pointer to a constant: const int ci = 10; const int* pc = &ci; // pc is variable pointer to a constant integer *pc = 15 // this gives an error, ci is a constant integer reference to a constant: const float pi = 3.141; const float& unit_circle_area = pi; A reference to a constant can refer to a variable data object double x; const double& xr = x; // xr can be a function argument // xr refers to x as a const data object of type double xr = 10.0; // gives error, where x = 10.0; x *= 100.0; // are OK

The C++ Data Types Arrays are defined as follows type name[const expression] int v[10];// is OK, where int size; int v[size];// gives error, size is not const const int csize=10; double x[csize];// this is OK, elements are x[0] to x[csize-1] arrays of all types can be declared, except arrays of references: int& iar[10]; //gives error initializing an array: int a[ ] = {10,15,25}; double x[csize]={0.1,0.2};// csize = 10 char str[ ]=“C++”;// str[0] = ‘C’, str[1] = ‘+’, str[2] = “+, str[3] = ‘\0’ 2-dimensional arrays: double d[2][3] = { {0.0,0.1,0.2};// row 0 {0.4,0.5,0.6};// row 1}; arrays can be referenced and manipulated using pointers: int ar[10]; int *p=ar;// ar is the same as &ar[0], now p points to the array for(int i=0; i<10; i++){cout << “input an integer value \n”;// using iostream.h cin >> p[i];}// reads the value in ar[i]

The C++ Data Types Dynamic storage Allocation with the new and delete operators Pointers can be used to create arrays or objects of any size at run time with dynamic memory allocation The new operator: new type; allocates memory storage for an object and returns the address of that memory: new int; new double; for an array of objects: new type [number_of_elements]; new int [1000]; the return value from new is used to initialize pointers: double *pd = new double[100]; // allocates memory for 100 double elements int n = 1000; int *p = new int [n]; // notice that n is not a const int size; cout << “input array size”; cin >> size; float *pf = new float[size]; The delete operator: delete pointer_to_object; deallocates the storage of an object delete [ ] pointer_to_array; is used when deleting an array delete[ ] pd; delete [ ] pf; // for int, float, double, and char types [ ] is not needed delete is used to avoid memory leaks which occur when allocating storage for objects defined within a function and exiting the function.

The C++ Data Types typedef, enum, and void* the typedef keyword is used to define new type specifiers, typedef char* String; String a = “hello”; typedef unsigned long Age; Age Stone_Age; the enum keyword is used to define discrete data types, enum Boolean {false,true}; Boolean unordered = false; enum Long_Work_Day { Monday = 1, Tuesday, Thursday}; Long_Work_Day X = 2; // X is initialized to Tuesday void* is used to define generic pointers, int ival, *pi = 0; char *pc = 0; void *pv; pv = pi ; pv = pc // OK, implicit // conversion, pv can be made to point to different variable data types pc = pv // Error, pc must only point to char type objects pc = (char*) pv ; // Ok, since pv is casted to point to char type objects const int *pci = &ival; pv = pci // Error, pci is a pointer to a const data type pv = (void *) pci // Ok, explicit casting away from constness