Dynamic Function Memory? C++

Question

I've been reading through some books, and when it comes to Class/Functions using Pointers/Dynamic Memory (or heap or w/e they call it) I start to get confused.

Does anyone have a simple....like easy example they can show, because the books im using are using overly complex examples (large classes or multiple functions) and it makes it hard to follow. Pointers have always been my weak point anyways but I understand BASIC pointers, just classes/functions using them is a little bit confusing.

Also.....when would you use them is another question.

Answer 1

I think this is what you're asking about:

Basically C++ doesn't allow variable-sized arrays. Any array in C++ has to be given a very specific size. But you can use pointers to work around that. Consider the following code:

int *arry = new int[10];

That just created an array of ints with 10 elements, and is pretty much the same exact thing as this:

int arry[] = int[10];

The only difference is that each one will use a different set of syntax. However imagine trying to do this:

Class class:
{
public:
    void initArry(int size);

private:
    int arry[];
};

void class::initArry(int size)
{
    arry = int[size]; // bad code
}

For whatever reason C++ was designed to not allow regular arrays to be assigned sizes that are determined at runtime. Instead they have to be assigned sizes upon being coded. However the other way to make an array in C++ - using pointers - does not have this problem:

Class class:
{
public:
    ~class();
    void initArry(int size);

private:
    int *arry;
};

class::~class()
{
    delete []arry;
}

void class::initArry(int size)
{
    arry = new int[size]; // good code
}

You have to do some memory cleanup in the second example, hence why I included the destructor, but by using pointers that way you can size the array at runtime (with a variable size). This is called a dynamic array, and it is said that memory here is allocated dynamically. The other kind is a static array.

As far as 2-dimensional arrays go, you can handle it kind of like this:

Class class:
{
public:
    ~class();
    void initArrays(int size1, int size2);

private:
    int **arry;
};

class::~class()
{
    delete [] arry[0];
    delete [] arry[1];
    delete [] arry;
}

void class::initArrays(int size1, int size2)
{
    arry = new int*[2];
    arry[0] = new int[size1];
    arry[1] = new int[size2];
}

Disclaimer though: I haven't done much with this language in a while, so I may be slightly incorrect on some of the syntax.

Answer 2

Warning: Don't do this. This is why we have vectors.

If you wanted to create an array of data, and return if from a function, how would you do it?

Obviously, this does not work:

int [10] makeArray(int val)
{
    int arr[10];
    for(int i=0; i<10; ++i)
        arr[i] = val;
    return arr;
}

You cannot return an array from a function. We can use pointers to refer to the first element of an array, like this:

int * makeArray(int val)
{
    int arr[10];
    for(int i=0; i<10; ++i)
        arr[i] = val;
    return &(arr[0]);  // Return the address of the first element.
                       // Not strictly necessary, but I don't want to confuse.
}

This, however, also fails. arr is a local variable, it goes on the stack. When the function returns, the data is no longer valid, and now you have a pointer pointing to invalid data.

What we need to do is declare an array that will survive even after the function exits. For that, we use keyword new which creates that array, and returns the address to us, which needs to be stored in a pointer.

int * makeArray(int val)
{
    int * arr = new int[10];
    for(int i=0; i<10; ++i)
        arr[i] = val;
    return arr;
}

Then you can call that function and use that array like this:

int * a = makeArray(7);

for(int i=0; i<10; ++i)
    std::cout << a[i] << std::endl;

delete [] a; // never forget this.  Obviously you wouldn't do it right
             // away like this, but you need to do it sometime.

Using pointers with new also gives you the advantage that you can determine the size of the array at runtime, something you can't do with local static arrays(though you can in C):

int * makeArray(int size, int val)
{
    int * arr = new int[size];
    for(int i=0; i<size; ++i)
        arr[i] = val;
    return arr;
}

That used to be one of the primary purposes for pointers. But like I said at the top, we don't do that anymore. We use vector.

One of the last vestiges of pointers is not for dynamic arrays. The only time I ever use them, is in classes where I want one object to have access to another object, without giving it ownership of that object. So, Object A needs to know about Object B, but even when Object A is gone, that doesn't affect Object B. You can also use references for this, but not if you need to give Object A the option to change which object it has access to.

Answer 3

Your computer's RAM is a big pile of bytes ordered one after another, and each one of those bytes can be accesed independently by it's address: an integer number startig from zero, upwards. A pointer is just a variable to hold that address of a single place in memory.

Since the RAM is a big chunk of bytes, the CPU ussually divides that big pile of bytes on several chunks. The most important ones are:

1. Code
2. Heap
3. Stack

The Code chunk is where the Assembly code lies. The Heap is a big pool of bytes used to allocate:

• Global variables
• Dynamic data, via the new operation on C++, or malloc() on C.

The stack is the chunk of memory that gets used to store:

• Local variables
• Function parameters
• Return values (return statement on C/C++).

The main difference between the Stack and Heap is the way it is used. While the Heap is a big pool of bytes, the Stack "grows" like a stack of dishes: you can't remove the dish on the bottom unless there are no more dishes on it's top.

That's how recursion is implemented: every time you call a function recursively, memory grows on the stack, allocating parameters, local variables and storing return values of the returning functions, one on top of the others just like the stack of dishes.

Data living on the Stack have different "Life Span" than the data living on the Heap. Once a function exits, the data on the local variables get lost.

But if you allocate data on the Heap, that data won't get lost util you explicitly free that data with the delete or free() operations.

Answer 4

A pointer is basically a variable that contains the memory address of another variable (or in other cases to a function, but lets focus on the first).

That means that if I declare int[] x = {5,32,82,45,-7,0,123,8}; that variable will be allocated to memory at a certain address, lets say it got allocated on address 0x00000100 through 0x0000011F however we could have a variable which indicates a certain memory address and we can use that to access it.

So, our array looks like this

Address           Contents
0x00000100        1
0x00000104        32
0x00000108        82
0x0000010B        45
0x00000110        -7
0x00000114        0
0x00000118        123
0x0000011B        8

If, for example, we were to create a pointer to the start of the array we could do this: int* p = &x; imagine this pointer variable got created a memory address 0x00000120 that way the memory at that address would contain the memory location for the start of array x.

Address           Contents
0x00000120        0x00000100

You could then access the contents at that address through your pointer by dereferencing the pointer so that int y = *p would result in y = 1. We can also move the pointer, if we were to do p += 3; the pointer would be moved 3 addresses forward (note, however, that it moves 3 times the size of the type of object it is pointing to, here I am making examples with a 32 bit system in which an int is 32 bits or 4 bytes long, therefore the address would move by 4 bytes for each increment or 12 bytes in total so the pointer would end up pointing to 0x0000010B), if we were to dereference p again by doing y = *p; then we'd end up having y = 45. This is just the beginning, you can do a lot of things with pointers.

One of the other major uses is to pass a pointer as a parameter to a function so that it can do operations on certain values in memory without having to copy all of them over or make changes that will persist outside of the function's scope.

Answer 5

(not tested, just writing down. and keeping things intentionally primitive, as requested.)

int* oneInt  = new int;  // allocate
*oneInt = 10;            // use: assign a value
cout << *oneInt << endl; // use: retrieve (and print) the value
delete oneInt;           // free the memory

now an array of ints:

int* tenInts = new int[10];  // allocate (consecutive) memory for 10 ints
tenInts[0] = 4353;           // use: assign a value to the first entry in the array.
tenInts[1] = 5756;           // ditto for second entry
//... do more stuff with the ints
delete [] tenInts;           // free the memory

now with classes/objects:

MyClass* object = new MyClass();  // allocate memory and call class constructor
object->memberFunction("test");   // call a member function of the object
delete object;                    // free the object, calling the destructor

Is that what you wanted? I hope it helps.

Answer 6

Stack allocation:

char buffer[1000];

Here the 1000 must be a constant. Memory is automatically freed when buffer goes out of scope.

Heap Allocation:

int bufsz = 1000;
char* buffer = new char[bufsz];
//...
delete [] buffer;

Here bufsz can be a variable. Memory must be freed explicitly.

When to use heap:

• You don't know how much space you will need at compile time.
• You want the memory/object to persist beyond the current scope.
• You need a large chunk of memory (stack space is more limited than heap space)