C++ runtime error in my class - c++

Question

I have tried to make my own list for C++.
I have this Class:
template <class T>
class List
{
private:
T *value, *valueHelper;
int valueSize;
public:
int size;
List()
{
valueSize = 2;
value = (T*)malloc(sizeof(T) * valueSize);
size = 0;
}
void Add(T val)
{
size++;
if (size > valueSize)
{
valueSize *= 2;
valueHelper = (T*)malloc(sizeof(T) * valueSize);
memcpy(valueHelper, value, sizeof(T) * (valueSize / 2));
free(value);
value = valueHelper;;
}
value[size - 1] = val;
}
T operator[](int P)
{
return value[P];
}
};
When I try to use it in the main it works fine to Int.
Buy to Struct it is doing problems:
struct Material
{
string materialName;
int faceNum;
int meshNum;
Material(): materialName(""), faceNum(0), meshNum(0){};
};
void main()
{
List <Material> myList = List<Material>();
myList.Add(Material());
}
I got runtime error in the class on the line:
value[size - 1] = val;
Why?

Answer 1

You have at least two errors in your code :
- you cannot use memcpy to move class memory from one place to another except in very few cases. a std::string is not one of these cases.
- When you call an operator= it needs that the receiver is well formed, and it means that it is construct.
You hit the second error, because the value[0] is never construct, when you call the operator=, it is filled with garbage, and most probably try to delete random pointer value.
I imagine you prefer to construct object only when it is need, just like std::vector ? So a better implementation would be :
template <class T>
class List {
int m_size;
int m_capacity;
T * m_elems;
public:
List() :
m_size(),
m_capacity( 2 ),
m_elems( (T*) malloc( sizeof(T) * m_capacity ) ) {
}
void Add( T const & val ) {
if ( m_size + 1 > m_capacity ) {
m_capacity *= 2;
T * elems = (T*) malloc( sizeof(T) * m_capacity );
for( int i = 0 ; i != m_size ) {
new ( elems + i ) T( m_elems[i] ); // copy constructor
( m_elems + i )->~T(); // manually call the destructor
}
free( m_elems );
m_elems = elems;
}
new( m_elems + m_size++ ) T( val );
}
T operator[](int P) {
assert( P < m_size );
return m_elems[P];
}
};

Answer 2

This is because i did not pay attention to a third error in your original code ! The operator[] need to return by reference, not by value.
T & operator[](int P) {
assert( P < m_size );
return m_elems[P];
}
You probably want the const version too
T const & operator[](int P) const {
assert( P < m_size );
return m_elems[P];
}