Dynamic Arrays, the 'right' way.

[Mr.Anderson]

I'm confused, as is not so uncommon a circumstance.
I've been working on building a dynamically resizable data structure
in C++. I've heard a number of people talk about malloc as a method to resize existing arrays, but I've never been able to get it to work. I did complete one application that used (ARRAY) = new (type) with a pretty good deal of success, but I'm wondering if there's a better way.
In a sense, I'm asking about malloc vs. new and why someone would use malloc when 'new' is available.

Comments? Criticism?

If need be, I can post some code from the other application I have.

[Ed.] D'oh, and only moments after posting.
Nevermind, I found a link in another tut.
http://www.cplusplus.com/doc/tutorial/tut3-4.html
^_^;

[cheawick]

If it is not a bother, could you email me or post your full code. No matter where it comes from, learning is still learning.

[Mr.Anderson]

No problem. I hope this helps someone.

/////////////// test.cpp ///////////////
/// Use dVars.h and see if it works. ///
////////////////////////////////////////

#include <iostream.h>
#include "dVars.h"

int main( void )
{

	dInt num( 10 );

	num.setItem( 5, 10 );

	for(int x=0; x<10; x++)
		cout << num.getItem(x) << ' ';

	cout << endl;

	num.resize( 15 );

	num.setItem( 12, 42 );

	for(x=0; x<15; x++)
		cout << num.getItem(x) << ' ';

	cout << endl;

	return 0;
}

/////////////// dVars.cpp //////////////
// The header for a resizable array. ///
////////////////////////////////////////

#ifndef dVars_h
#define dVars_h

class dInt
{
public:
	dInt( int arraySize ); // Constructor
	~dInt( void ); // Deconstructor
	void resize( unsigned int newSize ); // Returns true if the resize is successful.
	int getItem( unsigned int itemNumber ); // Returns the value of the item number specified.
	bool setItem( unsigned int itemNumber, int itemValue ); // Sets the value
private:
	unsigned int size; // Hold the size of the vector.
	int *array; // A pointer to the array.
	int *temp; // A holder for the data when the array is resized.
};

#endif

And finally...

/////////////// dVars.cpp ///////////////

#include <iostream.h>
#include <stdlib.h>
#include "dVars.h"

dInt::dInt( int arraySize )
{
	if(arraySize > 0)
	{
		size = arraySize;
		array = new int[ size ];

		for(int x=0; x<size; x++)
			array[x] = 0;
	}
}

dInt::~dInt( void )
{
// TODO: Fix this.
//	delete array;
//	delete temp;
}

int dInt::getItem( unsigned int itemNumber )
{
	if(itemNumber <= size)
		return array[ itemNumber ];
	return 0;
}

bool dInt::setItem( unsigned int itemNumber, int itemValue )
{
	if(itemNumber <= size)
	{
		array[itemNumber] = itemValue;
		return 1;
	}
	else
	{
		return 0;
	}
}

void dInt::resize( unsigned int newSize )
{
	temp = new int[ size ];

	for(unsigned int x=0; x < size; x++)
	{
		temp[x] = 0;
		temp[x] = array[x];
	}

	array = new int[ newSize ];

	for(x=0; x <= newSize; x++)
		array[x] = 0;

	for(x=0; x < size; x++)
	{
		array[x] = temp[x];
	}

	temp = new int[0];
	size = newSize;

	return;
}

I'm guessing that I could fine tune this quite a bit.
I didn't do the clean up right, and there isn't enough commenting
in the source. I'm also uncertain as to whether or not I'd even need
to make the temporary array when I resize.

Feedback and constructive criticism are appreciated.

[Valmont]

Did you get this code from a tutorial?

[Valmont]

#include "dVars.h"
#include <iostream>

using namespace std;

int main()
{
	dInt num( 10 );
	num.setItem(5, 33);
	for(int i = 0; i < 10 ; ++i)
		cout<<num.getItem(i)<<endl;

	cout<<endl;

	num.resize( 15 );
	num.setItem(14, 33);
	for(int i = 0; i < 15 ; ++i)
		cout<<num.getItem(i)<<endl;

	return 0;
}

/////////////// dVars.h //////////////
// The header for a resizable array. ///
////////////////////////////////////////

#ifndef dVars_h
#define dVars_h

class dInt
{
public:
	dInt( int arraySize ); 
	~dInt( );
public:
	void resize(  int newSize ); 
	int getItem(int i)
	{
		return array[i];
	}
	void dInt::setItem(  int pos, int val )
	{
		if(pos <= size)	
			array[pos] = val;
	}

private:
	int size; 
	int *array; 
};

#endif //dVars_h

/////////////// dVars.cpp ///////////////

WTF? WHY DO I GET ERROR WHEN I TRY TO POST THE REST OF THE CODE?
CONTINUES IN NEXT POST.

[Valmont]

/////////////// dVars.cpp ///////////////

#include "dVars.h"
#include <iostream>

using namespace std;

dInt::dInt( int arraySize )
{
	if(arraySize > 0)
	{
		size = arraySize;
		array = new int[ size ];
		for(int i = 0; i < size ; ++i)
			array[i] = i;
	}
}

dInt::~dInt()
{
	delete[] array;
}

void dInt::resize(  int newSize )
{
	int *temp = new int[ size ];
	for( int  x = 0; x < size; ++x)
		temp[x] = array[x];

	delete[] array;
	array = new int[ newSize ];

	for(int x = 0; x < newSize; ++x)
		array[x] = 0;

	for(int x = 0; x < size; ++x)
		array[x] = temp[x];
        delete[] temp;
	size = newSize;
}

1) You used <= instead of <.
2) Always use "delete[]" instead of "delete" when allocating with "new[ ]"
3) I localized the temporary.

[Mr.Anderson]

(I know, I'm reviving an old post, sorry.)

Nope, didn't get it from a tutorial. Just found out about new and decided to give it a try.

Thanks for the corrections.

I'm wondering if there's any way to create a dynamic char or float without rewriting the code. E.g. pass the data type and have the program use that instead of int. Am I clear enough? I don't know.

dVar blarg( float, 2 );

dVar w00t( char, 6 );

dVar foobar( long, 3 );

Any ideas?

[Valmont]

Templates mate. Templates.

template <typename T> class MyArrayClass
{
public:
	MyArrayClass( int arraySize ); 
private:
	int size; 
	T* array; 

}

And below is how you could define a setItem method:

void dInt::setItem(  int pos, T val )
	{
		if(pos <= size)	
			array[pos] = val;
	}

And so forth. But I warn you, setting up a decent abstract array is hard .
For example, what do you have to do to make this always work?

array[pos] = val;

Try it if you like a challenge .

[Mr.Anderson]

Muchissimas gracias. This should be fun.


ありがとございます

[thecyphermage]

あいがとうございます arigatoU gozaimasu

a lot of their words do that..

"domo" is actually doUmo.. freakin silent U's.. -.-

*goes back to coding*

oh yeah.. and katakana is typically used for foreign/borrowed words.. :p

[Valmont]

I wonder... have you figured it out yet?