You just initialized a new array of integers of size number, you did not store the value of number in it.

use ( ) instead of [ ] and everything else the same

Quick tip:

code:

#include <iostream> #include <algorithm> int main() {         int *foo = new int[10];         std::fill(foo, foo + 10, 0);         for (int i = 0; i < 10; i++)         {                 std::cout << foo[i] << std::endl;         }         return 0; }

Quick tip:

code:

#include <iostream> #include <algorithm> int main() {         int *foo = new int[10];         std::fill(foo, foo + 10, 0);         for (int i = 0; i < 10; i++)         {                 std::cout << foo[i] << std::endl;         }         return 0; }

The STL (Standard Template Library) is not for the faint of heart. It makes deep use of templates, which are tricky, and do not result in pleasant error messages.

Teachers avoid it because C++ is complicated enough to teach as it is, but also because many employers who hire programmers to work in C++ also avoid it. To some extent that situation is a chicken and egg problem.

The STL requires a reasonably deep knowledge of C++. Of course, trying to figure it out can be a good incentive to investigate the more interesting concepts in C++.

Dunno how it's done in c++, but in C, the sizeof() function will return the size of the type passed to it. sizeof(int) returns the size of an int. sizeof (POINT) will return the size of POINT.

We could do things the C way again, I suppose.

code:

Point* example = (POINT*) malloc (sizeof (POINT));

malloc is a C function that directly allocates a block of memory of a given size.

In C++, new and delete DO work with things other than int and enum: they work with pretty well everything!

Assuming that POINT is declared...

code:

POINT *example = new POINT(); // needs the brackets!

Later...

code:

delete example;

You can even use new to create arrays of whatever you want:

code:

POINT **ex_arr = new POINT[size];  // creates an array of (size) pointers to POINT objects on the heap for ( int i = 0; i < size; ++i ) {     ex_arr[i] = new POINT();   // constructs a new POINT object on the heap and puts the pointer to it into position i of ex_arr }

Later...

code:

delete [] ex_arr;  // the square brackets are very important, because they tell the compiler that you want to delete ex_arr AND all of its contents

First, there are two main places you allocate memory in C++ (and in programs in general, though most other languages choose to hide these details): the "stack" and the "heap".

Stack allocation is "cheaper" in terms of time, but may cause scoping problems (you cannot return a stack-allocated object or variable from a function and expect it to still be valid).

Heap allocation (using new or malloc or any of malloc's family) is "more expensive" (only a little bit), but has the advantage that you can allocate something within a function and then return it.

There are a lot of schools of thought on how to use each kind of allocation best. The only obviously-true things seem to be: allocate on the stack when you can, and use the RAII pattern when you can (you *should* be reading about that in your C++ textbook around when it discusses allocating memory for objects or where it talks about destructors; don't worry about it until you get there).

This:

code:

POINT **ex_arr = ...

declares a pointer to a pointer to a POINT object.

This:

code:

POINT *example = ...

declares a pointer to a POINT object.

These correspond to two different ways to lay out the memory you have allocated.

For the example pointer, that can either be a pointer to a single POINT object, or it can be treated like an array of POINT objects. If you allocated example as an array, then you can access a member 'x' of POINT #i with this syntax: example[i].x. All of the POINT objects will be contiguous in RAM, meaning they will be stored side-by-side.

For the ex_arr pointer, that is generally used to mean "an array of pointers to POINT". That means that ex_arr[i] is a *POINT, so if you want member 'x' of POINT #i, use this syntax: ex_arr[i]->x. The POINT objects will probably not be contiguous in RAM, and in fact may be stored all over the place. Because ex_arr is an array of pointers, you can also have ex_arr[i] == nullptr, which may or may not be desirable, depending on what you want to do.


Note: I haven't tested any of the code I posted, so the syntax may not be perfect.

If you try to assign an integer the value of NULL, you'll probably get an error. You can set pointers to NULL though, which is actually really useful in certain situations.

I am getting the feeling POINT may be better implemented as a class..

Oh sweet merciful Jebus! The Windows API and you're new enough to programming that you don't know what a class is? Die with dignity.

Yes wtd, don't be so hard on Cancer Sol. This forum is dedicated to people who can create elaborate programs and those who can't declare a variable yet as well as many in between.

But it sure helps, and makes things TONS easier.

Wait, are we still on about ops question or what?