std::string and gcc problem ?

Hi Guys,
i've problem with my small C++ programm. I've just small template
class which represetns a array, everything works fine up to
combination with std::string. I did tried it with M$ VC++ and with GCC
(Cygwin and Linux) and my problem is when i try do this

int main(int argc, char **argv) {
    array<std::string> a(10);

    a[0] = "Huhuhu"; <--- with gcc i got a crash !

    std::string = a[0];
    return 0;
}

the program crashes with segmentation fault on std::string::assign(),
but just with gcc ?!
Can somebode help me solve this problem ?

peter

.... and here is my code

#ifndef _array_h
#define _array_h
#include <stdexcept>
#include <sstream>
#include <stdlib.h>
#include <memory.h>
#ifdef _DEBUG
#include <iostream>
#endif

template <typename T>
class array {
public:
    array(size_t ) throw(std::bad_alloc &);
    array(const array<T> & ) throw(std::bad_alloc &);
    ~array();

    T& operator[](size_t ) throw(std::out_of_range &);
    const T&operator[](size_t ) const throw(std::out_of_range &);

    size_t length() const { return size; }

    int compare(const array<T> & ) const;

    bool operator==(const array<T> &arg ) { return compare(arg) == 0; }
    bool operator!=(const array<T> &arg ) { return compare(arg) != 0; }
    bool operator<(const array<T> &arg ) { return comapre(arg) < 0; }
    bool operator>(const array<T> &arg ) { return compare(arg) > 0; }
    bool operator!() const { return length > 0; }

private:
    T *data;
    size_t size;
};

#endif

template <typename T>
array<T>::array(size_t e) throw(std::bad_alloc & )
{
    data = NULL; size = 0;
  data = new T[e];
  size = e;
}

template <typename T>
array<T>::~array()
{
    if(data != NULL)
        delete [] data;
    data = NULL;
    size = 0;
}

template <typename T>
const T& array<T>::operator[](size_t idx) const
throw(std::out_of_range &)
{
    if(idx > size) {
        std::stringstream error;
        error << "idx > size " << __FILE__ << "(" << __FUNCTION__ << ":" <<
__LINE__ << ")";
        #ifdef _DEBUG
            std::cerr << error.c_str() << std::endl;
        #endif
        throw std::out_of_range(error.str());
    }

    return data[idx];
}

template <typename T>
T& array<T>::operator[](size_t idx) throw(std::out_of_range &)
{
    if(idx > size) {
        std::stringstream error;
        error << "idx > size " << __FILE__ << "(" << __FUNCTION__ << ":" <<
__LINE__ << ")";
        #ifdef _DEBUG
        std::cerr << error.str().c_str() << std::endl;
        #endif
        throw std::out_of_range(error.str());
    }

    return data[idx];
}