내 클래스의 C++ 런타임 오류

Question

C++에 대한 자체 목록을 만들려고했습니다. 나는이 수업이 : 나는 int로 잘 작동 주에서 사용하려고하면

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]; 
} 

}; 

합니다. 는 구매가 문제를하고있다 구조체하기 :

value[size - 1] = val; 

이유 :

struct Material 
{ 
string materialName; 
int faceNum; 
int meshNum; 

Material(): materialName(""), faceNum(0), meshNum(0){}; 
}; 


void main() 
{ 
    List <Material> myList = List<Material>(); 
    myList.Add(Material()); 
} 

내가 줄에 클래스의 런타임 오류가있어? ,

- 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. 

당신은 당신이 연산자 =를 호출 할 때 값이 [0] 구성하지 않기 때문에,이 쓰레기로 가득, 두 번째 오류 충돌 :

Answer 1

이입니다! 연산자 []는 값이 아닌 참조로 반환해야합니다.

T & operator[](int P) { 
    assert(P < m_size); 
    return m_elems[P]; 
} 

당신은 아마`malloc에 ​​제거와 함께 CONST 버전도

T const & operator[](int P) const { 
    assert(P < m_size); 
    return m_elems[P]; 
} 

Answer 2

당신은 당신의 코드에서 두 개 이상의 오류가 아마도 무작위 포인터 값을 삭제하려고합니다.

std :: vector와 같이 필요할 때만 객체를 생성하는 것을 선호한다고 생각하십니까? 그래서 더욱 향상된 기능은 다음과 같습니다 내가 원래 코드에서 세 번째 오류에주의를 지불하지 않았기 때문에

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]; 
    } 
};