Dynamic Memory and "new" and "delete" Operators

As you may remember from your lesson on arrays, we initially declared the size of the array in our code. However, what if, at run time, the user only wanted to enter five elements in the ten element array we declared? That would be a waste of space. Conversely, if our array is smaller than what the user wants, that would pose another problem. To overcome this, we use the concept of dynamic memory, where the array size is entered by the user during the running of the application.

Dynamic Memory

•          Until now, we have only had as much memory as we have requested in declarations of variables, arrays etc

•          The size of all of them was fixed BEFORE the execution of the program.

•          What if we need a variable amount of memory

•          That can only be determined DURING the program execution (runtime).

•          For example, in case that we need user input to determine the necessary amount of space?

The answer is dynamic memory

We can accomplish this using the operators new and delete

Operators "new" and "new[]"

•          new: to request dynamic memory

•          new is followed by a data type

•          and optionally the number of elements required within brackets [].

•          Returns a pointer to the beginning of the new block of assigned memory.

                pointer = new type // to assign memory to contain one single element of type

               or

               pointer = new type [elements]  // to assign a block (an array) of elements of type.

int * b;

b = new int[5];

•          The operating system will assign space for 5 elements of type int

•          And will return a pointer to its beginning

•          That has been assigned to b.

•          Therefore, now, b points to a valid block of memory with space for 5 int elements. 

Why use pointers as arrays?

•the size of an array must be a constant value

•Which limits its size to what we decide at the moment of designing the program before its execution

•Whereas the dynamic memory allocation allows assigning memory during the execution of the program

•using any variable, constant or combination of both

Dynamic Memory Implementation

•The dynamic memory is generally managed by the operating system

•Shared between several applications

•So there is a possibility that the memory exhausts.

•If so, the operating system cannot assign the memory that we request with the operator new

•A null pointer will be returned.

•For that reason it is recommended to always check to see if the returned pointer is null after a call to new. 

int * b;

   b = new int [5];

   if (b == NULL) {

       // error assigning memory. Take

     //measures.

   }; 

Operators "delete"

•          Once the dynamic memory is no longer needed it should be freed

•          So that it becomes available for future requests of dynamic memory.

•          The operator delete exists for this purpose

                delete pointer;

                or

               delete [] pointer;

•          The first expression should be used to delete memory allocated for a single element

•          The second one for memory allocated for multiple elements (arrays).

•          In most compilers both operators are equivalent

"new" and "delete"

Take a look at an example code to see the implementation of the operators:

Dynamic Memory and "new" and "delete" Operators

02:04 Arrays, Basics, C++, C++ Tutorial, Coding, Courses, Learn C++, Learn Programming, Pointers, Programming, Programming Languages, Software Development, Techology, Tutorials

Character Handling Library

Last time we wrapped up the topic of Pointers and Strings , today we will have a look at <cctype> which is a very important and useful library in C++.

Character Handling Library or <cctype> is a library in C++

–        It has functions to perform tests and manipulations on characters

–       You pass character as argument

•          Character represented by an int

–        char does not allow negative values

•          Characters often manipulated as ints

•          EOF usually has value -1

•   In the upcoming example you will witness the usage of:

–        isalpha( int c )

•          (All character functions take int argument)

•          Returns true if c is a letter (A-Z, a-z)

•          Returns false otherwise

–        isdigit

•          Returns true if digit (0-9)

–        isalnum

•          Returns true if letter or digit (A-Z, a-z, 0-9)

–        isxdigit

•          Returns true if hexadecimal digit (A-F, a-f, 0-9)

  

Some other functions of the character handling Library are:

–        islower

•          Returns true if lowercase letter (a-z)

–        isupper

•          Returns true if uppercase letter (A-Z)

–        tolower

•          If passed uppercase letter, returns lowercase letter

–        A to a

•          Otherwise, returns original argument

–        toupper

•          As above, but turns lowercase letter to uppercase

–        a to A

–        isspace

•          Returns true if space ' ', form feed '\f', newline '\n', carriage return '\r', horizontal tab '\t', vertical tab '\v'

–        iscntrl

•          Returns true if control character, such as tabs, form feed, alert ('\a'), backspace('\b'), carriage return, newline

–        ispunct

•          Returns true if printing character other than space, digit, or letter

•          $ # ( ) [ ] { } ; : %, etc.

–        isprint

•          Returns true if character can be displayed (including space)

–        isgraph

•          Returns true if character can be displayed, not including space

 Some of these are better explained through there usage in the following example:

Character Handling Library

09:45 C++, C++ Tutorial, cctype, Character Handling Library, Coding, Courses, Functions, Learn Programming, Programming, Programming Languages, Software Development, Technology, Tutorials

Pointer & Strings: Part Three

Continuing with the previous post, today we will further study pointers and strings.

Pointer Expressions and Pointer Arithmetic:

Pointer arithmetic is of the following types:

–Increment/decrement pointer  (++ or --)

–Add/subtract an integer to/from a pointer( + or += , - or -=)

–Pointers may be subtracted from each other

but remember that pointer arithmetic is meaningless unless performed on pointer to array

consider an example where there is a 5 element int array on a machine using 4 byte integer space.

–vPtr points to first element v[ 0 ], which is at location 3000

Vptr = v or vptr = &v[0]

–vPtr += 2; sets vPtr to 3008

vPtr points to v[ 2 ]

 when subtracting pointers (must both point to the same array, if not then LOGIC ERROR)

–Returns number of elements between two addresses

  vPtr2 = &v[ 2 ];
vPtr = &v[ 0 ];
vPtr2 - vPtr = 2

As far as pointer assignment is concerned:

–Pointer can be assigned to another pointer if both are of same type

–If not of the same type, cast operator must be used

–Exception: Void Pointer: pointer to void (type void *)

Void Pointer: Pointer to void (type void *):

int nValue = 5;

void *pVoid = &nValue;    //no need for casting

// can not dereference pVoid because it is a void pointer

int *pInt = static_cast<int*>(pVoid); // cast from void* to int*

cout << *pInt << endl; // can dereference pInt

Void Pointer:

the code given below shows an example of void pointers:

void f (void *,void*,int);

main()
{
int x=9,y=5;
char r='w',t='z';

                f(&r,&t,sizeof(r));
f(&x,&y,sizeof(x));

                cout<<x<<endl;
cout<<r<<endl;

}

void f(void* x, void* y, int sizeofptr)
{

int *nptr1, *nptr2;
char *nptr3, *nptr4;

if (sizeofptr == sizeof(int))
{ nptr1=(int* )x;
nptr2=(int* )y;
*nptr1=*nptr1**nptr2;}
else
{nptr3=(char* )x;
nptr4=(char* )y;
*nptr3=toupper(*nptr3);}

}

Relationship between Arrays and Pointers:

Arrays and pointers are closely related:

–        Array name is like a constant pointer

–        Pointers can do array subscripting operations:

                                    int b[5];

                                    int *bptr;

You can point ‘bptr’ to array ‘b’ using either;

                                    bptr = b;    //remember name of array is constant pointer to address of the first                                                           location of array  

                        Or

                                    bptr = &b[0];

Array elements can easily be accessed with pointers

–        Element b[ n ] can be accessed by  *( bPtr + n )

•          Called pointer/offset notation

•          ‘n’ is the offset

•          DO NOT forget the brackets, since * bPtr + n  will simply add n to *bPtr

–        Accessing array addresses with pointers:

•          &b[ 3 ] same as bPtr + 3

–        Array name can be treated as pointer;

•          b[ 3 ] same as *( b + 3 )

•          This is possible since name of the array is a pointer itself.

–        Pointers can be subscripted (pointer/subscript notation)

•          bPtr[ 3 ] same as b[ 3 ]

Array of Pointers:

An array can contain pointers

–This is commonly used to store array of strings

char *suit[ 4 ] = {"Hearts", "Diamonds",
                  "Clubs", "Spades" };

–Each element of suit points to char * (a string)

–Array does not store strings, only pointers to strings

–suit array has fixed size, but strings can be of any size

Pointer & Strings: Part Three

09:25 Arrays, Basics, C++ Tutorial, Coding, Learn C++, Learn Programming, Pointer Arithmetic, Pointers, Pointers in C++, Software Development, Technology, Tutorials

Arrays in C++ Part 4: Searching Arrays and 2-D Arrays

As we have done a few lessons in arrays (parts one, two and three), let us learn how to find results in large arrays as well as look at 2-D arrays.

Searching Arrays

•          Search array for a key value

•          Linear search

–        Compare each element of array with key value

•          Start at one end, go to other

–        Useful for small and unsorted arrays

•          Inefficient

•          If search key not present, examines every element

•          Binary search

–        Only used with sorted arrays

–        Compare middle element with key

•          If equal, match found

•          If key < middle

–        Repeat search on first half of array

•          If key > middle

–        Repeat search on last half

–        Very fast

•          At most N steps, where 2^N    > # of elements

•          30 element array takes at most 5 steps

2⁵   >  30

Multiple Sub-scripted Arrays

•          Multiple subscripts

–        a[ i ][ j ]

–        Tables with rows and columns

–        Specify row, then column

–        “Array of arrays”

•          a[0] is an array of 4 elements

•          a[0][0] is the first element of that array

•          To initialize

–        Default of 0

–        Initializers grouped by row in braces

                             int b[ 2 ][ 2 ] = { { 1, 2 }, { 3, 4 } };

  

                             int b[ 2 ][ 2 ] = { { 1 }, { 3, 4 } };

•          Referenced like normal

               cout << b[ 0 ][ 1 ];

–        Outputs 0

–        Should not be referenced using commas

                             cout << b[ 0, 1 ]; is interpreted as cout << b[1]

•          Function prototypes

–        Must specify sizes of subscripts

•          First subscript not necessary, as with single-scripted arrays

–        void printArray( int [][ 3 ] );

•          Next: program showing initialization

–        After, program to keep track of students grades

–        Multiple-subscripted array (table)

–        Rows are students

–        Columns are grades

Arrays in C++ Part 4: Searching Arrays and 2-D Arrays

09:19 2-D Arrays, Arrays, C++, C++ Tutorial, Coding, Courses, Functions, Learn C++, Learn Programming, Programming, Programming Languages, Software Development, Sorting Arrays, Technology, Tutorials