Scribd Logo
Upload

Welcome to Scribd!

  • 28 views

    Void - The Very Exceptional Type Pointers To This Type As in The Following Example Void PTR

    Uploaded by

    Sachin N Gudimani
    The document discusses C++ memory management using pointers and dynamic memory allocation. It explains that void pointers can point to memory of any type, and are useful when the pointer type is unknown. The new and delete keywords are used to dynamically allocate and free memory as needed. New returns a pointer to the allocated memory, which must later be freed using delete. Examples demonstrate allocating memory for arrays at runtime based on user input, avoiding wasted memory for fixed-size arrays.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd

    Void - The Very Exceptional Type Pointers To This Type As in The Following Example Void PTR

    Uploaded by

    Sachin N Gudimani
    28 views3 pages
    The document discusses C++ memory management using pointers and dynamic memory allocation. It explains that void pointers can point to memory of any type, and are useful when the pointer type is unknown. The new and delete keywords are used to dynamically allocate and free memory as needed. New returns a pointer to the allocated memory, which must later be freed using delete. Examples demonstrate allocating memory for arrays at runtime based on user input, avoiding wasted memory for fixed-size arrays.

    Original Description:

    c memory

    Original Title

    C++ Memory

    Copyright

    © © All Rights Reserved

    Available Formats

    DOCX, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    The document discusses C++ memory management using pointers and dynamic memory allocation. It explains that void pointers can point to memory of any type, and are useful when the pointer type is unknown. The new and delete keywords are used to dynamically allocate and free memory as needed. New returns a pointer to the allocated memory, which must later be freed using delete. Examples demonstrate allocating memory for arrays at runtime based on user input, avoiding wasted memory for fixed-size arrays.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    28 views3 pages

    Void - The Very Exceptional Type Pointers To This Type As in The Following Example Void PTR

    Uploaded by

    Sachin N Gudimani
    The document discusses C++ memory management using pointers and dynamic memory allocation. It explains that void pointers can point to memory of any type, and are useful when the pointer type is unknown. The new and delete keywords are used to dynamically allocate and free memory as needed. New returns a pointer to the allocated memory, which must later be freed using delete. Examples demonstrate allocating memory for arrays at runtime based on user input, avoiding wasted memory for fixed-size arrays.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    of 3

    C++ - Memory

    VOID THE VERY EXCEPTIONAL TYPE


    Despite the fact that the void type doesn't represent any useful value it is possible to declare
    pointers to this type as in the following example
    void *ptr;
    You may ask how to use a pointer that points exactly at nothing and ask what such a pointer may
    be useful for. That kind of pointer, which is precisely of the type void *, is named an amorphous
    pointer to emphasize the fact that it is able to point to any value of any type. It means that the pointer
    of type void * cannot be subject to the dereference operator, so you must not write anything similar
    to this:
    *ptr = 1;
    It can be justified by the argument that if ptr was of type void * , *ptr would be of type void and the
    assignment of a value of type int is prohibited by the compiler.
    However, pointers of type void * are very useful when you need to have a pointer, but do not know
    what purpose it may be used for in the future. As soon as it is clear, the pointer can easily be
    converted into another pointer of the desired type (of course, a pointer one) which is always feasible
    and does not cause any loss of accuracy.
    MEMORY ON DEMAND
    In the examples presented so far, memory management has taken place outside of our
    consciousness. The parts of memory which we used to store values were hidden behind the names of
    scalars and arrays. They appeared as soon as they had been declared and gone when our program
    had ended operation. All work associated with memory allocation was organized by the compiler and
    we didn't care how it works. This is how it should be - high level languages and their compilers are
    designed to exonerate the developers' minds of such responsibilities.
    It frequently happens that the developer wants to have full control over how much memory is used
    and when exactly it is used. This is especially important when you do not know in advance, what the
    size of the data to be processed is. To manage the allocating and freeing of the memory the C++
    language provides two specialized keywords. Here, we present both of them for you
    new
    delete
    The new keyword is used to request creation of a new memory block. When the allocated memory
    is no longer needed and/or utilized, it would be a good habit to return it to the operating system. This
    is done by the delete keyword.
    The new keyword that performs the first-mentioned task can be used in the following way
    float *array = new float [20];
    int *count = new int;
    it needs precise specification regarding the entity being created; it must be expressed as a
    type description and if the created entity is an array, the size of the array must be given too
    (like in the first example)
    the new returns a pointer of type conforming the newly created entity
    the newly allocated memory area is not filled (initiated) in any way so you should expect
    that it contains just garbage
    When the memory is no longer necessary we can release (free) it using the delete keyword in the
    following way
    delete [ ] array;
    delete count;
    we use delete [] form if we want to free the memory allocated for an array and delete
    otherwise
    you can only release the entire allocated block, not a part of it
    after performing the free function all the pointers that point to the data inside the freed area
    become illegal; attempting to use them may result in an abnormal program termination.

    SS Puram, Tumkur | M.G. Road, Tumkur | Ph: +91-9620160796

    C++ - Memory
    We are going to present a complete, although not very useful, program that demonstrates the use of
    both keywords.
    We declare a variable called ptr which will point to the data of type int (the pointer's type is int
    *); no value is assigned to this variable initially
    We use the new keyword to allocate a block of memory sufficient to store a float array
    consisting of 5 elements;
    We make use of the newly allocated array (to be precise, a vector) and next we release it
    using the delete keyword
    We want you to pay attention to the fact that the pointer returned by new is treated as if it is an array.
    Surprising?
    The handling of the dynamic arrays (created during the run of the program) is no different than using
    regular arrays declared in the usual way.
    We owe it to the [] operator. Regardless of the nature of the array we can access its elements in the
    same way.
    #include <iostream>
    using namespace std;
    int main(void) {
    float *arr;
    arr = new float[5];
    for(int i = 0; i < 5; i++)
    arr[i] = i * i;
    for(int i = 0; i < 5; i++)
    cout << arr[i] << endl;
    delete [] arr;
    return 0;
    }
    The possibility of allocating the amount of memory which is really needed lets us write programs that
    can adapt themselves to the size of the currently processed data. Let's go back to the bubble sort
    algorithm that we presented previously. That program assumed that there were exactly 5 numbers to
    sort. This is obviously a serious inconvenience. It may happen one day that we want to sort 10,000
    numbers and sometimes hundreds of them. You can of course, declare an array of the maximum
    predictable size but it would be unreasonable. A much better way is to ask the user how many
    numbers will be sorted and then allocate the array of the appropriate size.
    Let's try to start with a simpler example. In the following program we allocate an array containing 5
    elements of type int, set their values, sum them up and, finally, release the previously allocated
    memory.
    int *tabptr, sum = 0;
    tabptr = new int[5];
    for(int i = 0; i < 5; i++)
    tabptr[i] = i;
    sum = 0;
    for(int i = 0; i < 5; i++)
    sum += tabptr[i];
    delete [] tabptr;
    The improved bubble sort program goes here We encourage you to compile and run the program
    yourself.
    #include <iostream>
    using namespace std;

    SS Puram, Tumkur | M.G. Road, Tumkur | Ph: +91-9620160796

    C++ - Memory
    int main(void) {
    int *numbers, how_many_numbers;
    int aux;
    bool swapped;
    cout << "How many numbers are you going to sort? ";
    cin >> how_many_numbers;
    if( how_many_numbers <= 0 || how_many_numbers > 1000000) {
    cout << "Are you kidding?" << endl;
    return 1;
    }
    numbers = new int[how_many_numbers];
    for(int i = 0; i < how_many_numbers; i++) {
    cout << "\nEnter the number #" << i + 1 << ": ";
    cin >> numbers[i];
    }
    do {
    swapped = false;
    for(int i = 0; i < how_many_numbers - 1; i++)
    if(numbers[i] > numbers[i + 1]) {
    swapped = true;
    aux = numbers[i];
    numbers[i] = numbers[i + 1];
    numbers[i + 1] = aux;
    }
    } while(swapped);
    cout << endl << "The sorted array:" << endl;
    for(int i = 0; i < how_many_numbers; i++)
    cout << numbers[i] << " ";
    cout << endl;
    delete [] numbers;
    return 0;
    }

    SS Puram, Tumkur | M.G. Road, Tumkur | Ph: +91-9620160796

    You might also like