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

Pointers and Strings: Part Four

Let us dive into part four of our lesson on pointers and strings. You can revise the previous three parts here, here and here.

Fundamentals of Characters and Strings

•          Character constant

–        Integer value represented as character in single quotes

–        'z' is integer value of z

•          122 in ASCII

•          String

–        Series of characters treated as single unit

–        Can include letters, digits, special characters  +, -, * ...

–        String literal (string constants)

•          Enclosed in double quotes, for example:

                                            "I like C++"

–        Array of characters, ends with null character '\0'

–        String is constant pointer

•          Pointer to string’s first character

–        Like arrays

•          String assignment

–        Character array

•          char color[] = "blue";

–        Creates 5 element char array color

–        last element is '\0'

–        Variable of type char *

•          char *colorPtr = "blue";

–        Creates pointer colorPtr to letter b in string “blue”

–        “blue” somewhere in memory

–        Alternative for character array

•          char color[] = { ‘b’, ‘l’, ‘u’, ‘e’, ‘\0’ };

•          Reading strings

–        Assign input to character array word[ 20 ]

                               cin >> word 

•          Reads characters until whitespace or EOF

•          String could exceed array size

                                            cin >> setw( 20 ) >> word;

•          Reads 19 characters (space reserved for '\0')

•          cin.getline

•          Read line of text

•          cin.getline( array, size, delimiter );

•          Copies input into specified array until either

•          One less than size is reached

•          delimiter character is input

•          Example

                             char sentence[ 80 ];

                             cin.getline( sentence, 80, '\n' );

String Manipulation Functions of String-handling Library

•          String handling library <cstring> provides functions to

–        Manipulate string data

–        Compare strings

–        Search strings for characters and other strings

–        Tokenize strings (separate strings into logical pieces)

•          Copying strings

–        char *strcpy( char *s1, const char *s2 )

•          Copies second argument into first argument

•          First argument must be large enough to store string and terminating null character

–        char *strncpy( char *s1, const char *s2,   size_t n )

•          Specifies number of characters to be copied from string into array

•          Does not necessarily copy terminating null character

•          Concatenating strings

–        char *strcat( char *s1, const char *s2 )

•          Appends second argument to first argument

•          First character of second argument replaces null character terminating first argument

•          Ensure first argument large enough to store concatenated result and null character

–        char *strncat( char *s1, const char *s2, size_t n )

•          Appends specified number of characters from second argument to first argument

•          Appends terminating null character to result

•          Comparing strings

–        Characters represented as numeric codes

•          Strings compared using numeric codes

–        Character codes / character sets

•          ASCII

•          “American Standard Code for Information Interchange”

•          EBCDIC

•          “Extended Binary Coded Decimal Interchange Code”

•          Comparing strings

–        int strcmp( const char *s1, const char *s2 )

•          Compares character by character

•          Returns

–        Zero if strings equal

–        Negative value if first string less than second string

–        Positive value if first string greater than second string

–        int strncmp( const char *s1,

                                                                 const char *s2, size_t n )

•          Compares up to specified number of characters

•          Stops comparing if reaches null character in one of arguments

•          Tokenizing

•          Breaking strings into tokens, separated by delimiting characters

•          Tokens usually logical units, such as words (separated by spaces)

•          "This is my string"  has 4 word tokens (separated by spaces)

•          char *strtok( char *s1, const char *s2 )

•          Multiple calls required

•          First call contains two arguments, string to be tokenized and string containing delimiting characters

•          Finds next delimiting character and replaces with null character

•          Subsequent calls continue tokenizing

•          Call with first argument NULL

•          Determining string lengths

•          size_t strlen( const char *s )

•          Returns number of characters in string

•          Terminating null character not included in length

Pointers and Strings: Part Four

14:14 Arrays, Arrays in C++, C++ Tutorial, Courses, Languages, Learn C++, Learn Programming, Pointer Arithmetic, Pointers, Pointers in C++, Programming, Programming Languages, Software Development, Techology

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