#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

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

using namespace std;

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

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

unsigned Array<Type>::Size(void)

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

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