Question Regarding Arrays

[Dyndrilliac]

How would I redeclare a single dimensional array, so as to overwrite the old instance of it but preserve all the items in the array and increase the maximum number of indexes by one?

I am pretty much looking for the Visual Basic to C++ equivalent of "ReDim Preserve ArrayName(0 To UBound(ArrayName) + 1)"

[Mephisto]

Dynamically allocate the array using malloc and then when you want to increase it and preserve the current data use realloc on it.

Note: These are C methods of dynamic memory allocation, I don't know of any C++ methods of reallocating an array.

[Dyndrilliac]

Thanks

[Dyndrilliac]

Question, I looked up malloc() on MSDN and the parameter for it is the amount of bytes I want to make it in size; Is this the same as number of indexes?

Also, do I declare the array without any indexes then use malloc on it? Example:

Code Select Expand

#include <stdlib.h>
#include <malloc.h>
#include <windows.h>

int main()
{
   char string[];
   string = (char *)malloc(5);

   if (string == NULL) {
      messagebox(NULL, "Insufficient Memory!", "Error!", MB_OK | MB_ICONERROR);
   } else {
      free(string);
   }

   return 0;
}

[MyndFyre]

Question, I looked up malloc() on MSDN and the parameter for it is the amount of bytes I want to make it in size; Is this the same as number of indexes?

No!!!!!!!!!  [edit: added extra !s to emphasize that it's an important thing to know, not to be attitude-ish.]  You want to make the number of bytes equal the size of the object times the number of indices (note the CORRECT plural of "index") -- so:

Code Select Expand


char *pszString = (char*)malloc(5 * sizeof(char));

In the case of char, it IS the number of indices; however, for larger data types, such as DWORD:

Code Select Expand


typedef unsigned long int DWORD;

DWORD *pDwordArray = (DWORD*)malloc(5 * sizeof(DWORD));


Also, do I declare the array without any indexes then use malloc on it? Example:

Code Select Expand

#include <stdlib.h>
#include <malloc.h>
#include <windows.h>

int main( void )
{
   char string[];
   string = (char *)malloc(5);

   if (string == NULL) {
      messagebox(NULL, "Insufficient Memory!", "Error!", MB_OK | MB_ICONERROR);
   } else {
      free(string);
   }
}

The only way you can declare an array without a size (I *believe*) is to make it a pointer, like I did in my samples above.  Arrays and pointers are interchangeable; example code:

Code Select Expand


typedef unsigned long int DWORD;

int i;
DWORD *pDwordArray;
*pDwordArray = (DWORD*)malloc(5 * sizeof(DWORD));
for (i = 0; i < 5; i++)
{
  *(pDwordArray + i * sizeof(DWORD)) = i;
}
// that loop does the exact same as the one below:
for (i = 0; i < 5; i++)
{
  pDwordArray[i] = i;
}

Recall order of operations; i*sizeof(DWORD) comes first, and so you're getting an offset into the memory that was allocated at pDwordArray.

[UserLoser.]

Correct me if I'm wrong, but isn't malloc supposed to be for C, while new is for C++?

[Newby]

Mephisto stated that, IIRC.

Dynamically allocate the array using malloc and then when you want to increase it and preserve the current data use realloc on it.

Note: These are C methods of dynamic memory allocation, I don't know of any C++ methods of reallocating an array.

[MyndFyre]

Correct me if I'm wrong, but isn't malloc supposed to be for C, while new is for C++?

Yes, new works.  But malloc is more generalizable; as C++ is a superset of C, malloc works equally well in C++ as it does in C.

Additionally, since he said he wanted to redeclare the array, malloc and its cousin realloc should be used.  As I understand it, realloc is the only way to have a fighting chance of not having to copy memory.  Example:

Code Select Expand


typedef unsigned long int DWORD;

// inside a function somewhere.
DWORD* pOriginalLoc, pDwordArray, pNewLoc;

pDwordArray = (DWORD*)malloc(5 * sizeof(DWORD));
pOriginalLoc = pNewLoc = pDwordArray; // copies ptr locations
realloc(pNewLoc, (size_t)(10 * sizeof(DWORD)));
if (pNewLoc == pOriginalLoc)
{
 // don't need to copy memory.
}
else
{
 // need to copy memory from the original.
}

However:

Code Select Expand


DWORD* pOriginalLoc, pDwordArray, pNewLoc;
pDwordArray = new DWORD[5];
pOriginalLoc = pNewLoc = pDwordArray;
delete[] pDwordArray;
pNewLoc = new DWORD[10];
if (pNewLoc == pOriginalLoc)
{
 // don't need to copy memory -- except wait!
 // after calling delete[], the compiler is free to change the
 // contents of memory.  While it's not practical, you are not
 // guaranteed that the memory values will stay the same.
 // example: an optimizing compiler will figure out that pNewLoc
 // isn't actually accessed until AFTER the delete[] statement.
 // thus, it can put the value of pNewLoc in the first memory location
 // freed, in which case you will NEVER have this conditional
 // even be executed.  Particularly if this is on a global heap,
  // you can run into trouble, in which case another program may access
  // that memory and overwrite it while your thread is waiting.
}
else
{
 // need to copy memory
}


[Mephisto]

Operator new just calls malloc() anyways.  But there are certain advantages to using new; three being that it's designed for use with C++ and should be used if you're using C++, it automatically returns the correct pointer type where malloc does not and it can be overloaded for custom functionality.  However, there are no specific C++ methods for re-allocating an array without losing its current contents (the contents will still be in memory, you just won't be able to access them) unless you want to copy memory which I believe you didn't want to do.

[Arta]

Bare in mind that realloc does not guarantee not to move your data anyway. Reallocation should always be considered a (relatively) expensive operation. IMHO, its use is often a sign of bad design - perhaps you should rethink your approach?

[Dyndrilliac]

Well, I need a method to add and remove indices from an array while preserving the data in it. I'm currently working on creating my own Plugin API using LoadLibrary, FreeLibrary, GetProcAddress, and GetModuleHandle.

The only part that's giving me problems is adding and removing plugin objects from the array that holds them. I decided to go with the method I learned in VB to add and remove data froman aray, because those are the only ways I know how.

Add: When the array is full, a dd new indices preserving everything in it, then add the new items.

Remove: Copy everything to a new temporary array except what I want to  remove, then reduce the number of indices on the original array by one and copy everything back.

I already have most of my functions and my Plugin Class written, so I really only need a way to manage the array of Plugin Objects

[Arta]

That doesn't sound very good. What happens when someone unloads a plugin in the middle fo the array? Won't all the plugins after it have their indices changed and mess everything up? Sounds like you want to use a linked list.

[Adron]

Remove: Copy everything to a new temporary array except what I want to  remove, then reduce the number of indices on the original array by one and copy everything back.

This doesn't sound very efficient. If you're doing something like this, I don't see why you need reallocation. You just make a new array with one less spot than the original array, copy all the data there, then deallocate the original array and change your pointer to point to the new array. Same thing works for adding an entry, except you make the new array one bigger than the original.

[Dyndrilliac]

@Arta: Well, I thought about that - instead of locating plugins by their indices, I decided to use a handle that would be both global and accessible by the Application, and the Pliugin API - This way I could manage the plugins by this one variable and I could locate one in the array that I needed even when the indices changed. I decided to use the Plugin's Path for this, because it is the data that is passed from the App to the API making it globally and instantly accessible from the get-go.

However, following your suggestion, I googled linked-lists, and they look liike they would serve my purpose better than an array - However, it will take some practice to get it working

@Adron: Could you show me an example of this? I'm being exposed to a lot of new stuff in this thread

Anyway, to give you an idea what I'm working with, here's my Plugin class:

Code Select Expand

class Plugin { // Plugin Object Class
public:
Plugin(char* szPath);   // Constructor (Loads Plugin  and Initializes Object)
~Plugin();              // Destructor (Called on UnloadPlugin())
char* szplVers;         // Variable to hold Plugin Version
char* szplPath;         // Variable to hold Plugin Path
VERSIONPROC pVersion;   // Version() of the Plugin
protected:
LOADPROC pLoad;         // Load Event of the Plugin
UNLOADPROC pUnload;     // Unload Event of the Plugin
HINSTANCE hInst;        // Handle for Library Instance
};

[Arta]

If you write your own, linked lists can take a while to get right.  You might prefer to use STL - std::list is what you want, iirc. I'm not an STL person though so perhaps you should ask someone else (eibro?)