Class Template Trouble

I am trying to implement a class template called Array to use with different types, the declaration looks like this:

Code:

#ifndef _ARRAY_HPP_
#define _ARRAY_HPP_

#include <iostream>  // for cout, cin
#include <exception> // for exception base class
#include <new>       // for bad_alloc

template <typename Type>
class Array
{
private:
	// Holds the size of the array
	unsigned len;

	// Pointer for dynamically allocated array
	Type * array;

public:
	// Constructor with array size explicitly provided
	explicit Array(unsigned arraySize = 0);

	// Homogeneous copy constructor
	Array(const Array<Type> & ST_Array);
	
	// Heterogeneous copy constructor, can take a different type of array as argument
	template <typename U>
	Array(const Array<U> & DT_Array);

	// Overloaded bracket operator const version
	const Type & operator[](unsigned i) const;

	// Overloaded bracket operator non-const version
	Type & operator[](unsigned i);

	// Homogeneous assignment operator
	Array<Type> & operator=(const Array<Type> & a);

	// Heterogeneous assignment operator
	template <typename U>
	Array<Type> & operator=(const Array<U> & a);

	// Returns the size of the array
	unsigned Size(void) const;

	// Destructor
	~Array(void);

};



// ***********Implementation************										

template <typename Type>
Array<Type>::Array(unsigned arraySize) : len(arraySize)
{
	array = new Type[len];
}

// Returns the size of the array
template <typename Type>
unsigned Array<Type>::Size(void) const
{
	return this->len;
}

// Homogeneous copy constructor
template <typename Type>
Array<Type>::Array(const Array<Type> & ST_Array)
{
	len = ST_Array.len;
	array = new Type[len];
	for (unsigned i = 0; i < len; i++)
		array[i] = ST_Array[i];
}

// Heterogeneous copy constructor, can take a different type of array as argument
template <typename Type>
template <typename U>
Array<Type>::Array(const Array<U> & DT_Array)
{
	len = DT_Array.Size();
	array = new Type[len];
	for (unsigned i = 0; i < len; i++)
		array[i] = Type(DT_Array[i]);
}

// Overloaded bracket operator const version
template <typename Type>
const Type & Array<Type>::operator[](unsigned i) const
{
	return array[i];
}

// Overloaded bracket operator non-const version
template <typename Type>
Type & Array<Type>::operator[](unsigned i)
{
	return array[i];
}

// Homogeneous assignment operator
template <typename Type>
Array<Type> & Array<Type>::operator=(const Array<Type> & a)
{
	if (this != &a)
	{
		delete [] array;
		array = new Type[a.len];
		for (unsigned i = 0; i < len; i++)
			array[i] = a[i];
	}
	return *this;
}


// Heterogeneous assignment operator
template <typename Type>
template <typename U>
Array<Type> & Array<Type>::operator=(const Array<U> & a)
{
	delete [] array;
	len = a.Size();
	array = new Type[len];
	for (unsigned i = 0; i < len; i++)
		array[i] = Type(a[i]);
	return *this;
}


// Destructor
template <typename Type>
Array<Type>::~Array(void)
{
	delete [] array;
}

#endif

and my driver is very simple right now just

Code:

#include <iostream>
#include "Array.hpp"

using namespace std;

int main(void)
{
	Array<float> a(1);
	return 0;
}

But when I ran it I got this message

Code:

C:\Program Files\Microsoft Visual Studio .NET 2003\Vc7\include\xstring(32): fatal error C1001: INTERNAL COMPILER ERROR
        (compiler file 'msc1.cpp', line 2701) 
         Please choose the Technical Support command on the Visual C++ 
         Help menu, or open the Technical Support help file for more information

I really can't see where I am doing wrong, please help. Thanks.

Start by correcting following errors:
Size returns unsigned so that line should be:

Code:

unsigned Array<Type>::Size(void)

also DT_Array is not same as DT_array

Yay, it works now. I knew it was something stupid like that, thanks a lot Micko! I got another quest though, why do I have to make my

unsigned Size(void) const;

a const member function? I was getting error from my copy constructor when I didn't put the const at the end.

I'm not sure because this works for me:

Code:

//dec....
	// Returns the size of the array
	unsigned Size(void);
//imp...
template <typename Type>
unsigned Array<Type>::Size(void) 
{
	return this->len;
}

But if you try something like this you'll get a compiler error:

Code:

const Array<float> b(a);
b.Size();

const function means that function is not allowed to change object and that's it.
It's not a bad practice do declare/define functions that don't change object to const...

- Micko

You can only call const methods on a const object. Thefore, if none of your methods are const, a const object is completely useless. As copy constructors and similar functions are passed references to const objects, the objects must have some const functions. Size(), since it doesn't change the object, is a perfect candidate for this.