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.