title: g++ Double Free or corruption...But How?
body: <p>I seem to be having problems with my code and wondered if you guys could help me locate the problem...I have tried using gdb and valgrind, the latter being 'more' useful but still I am unable to fix my bug.</p>
  
  <p>Below is my code for my classes (This is my shrunk down version but the main essence of the problem persists):</p>
  
  <p>/* Vector.h */</p>
  
  <pre><code>template&lt;typename _TYPE_, Int _SIZE_&gt;
  class Vec
  {
    public:
               Vec(void);
               Vec(const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec);
      virtual ~Vec(void);
  
      Boolean             operator==(const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec ) const;
      Boolean             operator!=(const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec ) const;  
      Boolean             operator&lt; (const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec ) const;
      Boolean             operator&gt; (const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec ) const;
      Boolean             operator&lt;=(const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec ) const;
      Boolean             operator&gt;=(const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec ) const;
  
      const _TYPE_&amp;       operator[](const Int index) const;
      _TYPE_&amp;             operator[](const Int index);
  
      Vec&lt;_TYPE_,_SIZE_&gt;  operator+ (const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec) const;
      Vec&lt;_TYPE_,_SIZE_&gt;  operator- (const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec) const;
      Vec&lt;_TYPE_,_SIZE_&gt;  operator* (const _TYPE_ val ) const;
  
      _TYPE_              operator* (const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec) const;
  
      Vec&lt;_TYPE_,_SIZE_&gt;&amp; operator+=(const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec);
      Vec&lt;_TYPE_,_SIZE_&gt;&amp; operator-=(const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec);
      Vec&lt;_TYPE_,_SIZE_&gt;&amp; operator*=(const _TYPE_ val );
  
    private:
      _TYPE_* __data;
  };
  
  template&lt;typename _TYPE_, Int _SIZE_&gt;
  Vec&lt;_TYPE_,_SIZE_&gt;::Vec(void)
  {
    me.__data = new _TYPE_[_SIZE_];
  
    for(Int i = 0; i &lt; _SIZE_; i++)
      me.__data[i] = 0;
  }
  
  template&lt;typename _TYPE_, Int _SIZE_&gt;
  Vec&lt;_TYPE_,_SIZE_&gt;::Vec(const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec)
  {
    me.__data = new _TYPE_[_SIZE_];
  
    for(Int i = 0; i &lt; _SIZE_; i++)
      me.__data[i] = vec[i];
  }
  
  template&lt;typename _TYPE_, Int _SIZE_&gt;
  Vec&lt;_TYPE_,_SIZE_&gt;::~Vec(void)
  {
    printf("~Vec&lt;%p&gt;...", (void*)this);
  
    if(me.__data != NOTHING)
      delete[] me.__data;
  }
  
  /*******************************************************************************
  * COMPARISON OPERATORS.
  *******************************************************************************/
  
  template&lt;typename _TYPE_, Int _SIZE_&gt;
  Boolean Vec&lt;_TYPE_,_SIZE_&gt;::operator==(const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec) const
  {
    if(this == &amp;vec)
      return true;
  
    for(Int i = 0; i &lt; _SIZE_; i++)
      if(me.__data[i] != vec[i])
        return false;
  
    return true;
  }
  
  template&lt;typename _TYPE_, Int _SIZE_&gt;
  Boolean Vec&lt;_TYPE_,_SIZE_&gt;::operator!=(const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec) const
  {
    return !(me == vec);
  }
  
  template&lt;typename _TYPE_, Int _SIZE_&gt;
  Boolean Vec&lt;_TYPE_,_SIZE_&gt;::operator&lt; (const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec ) const
  {
    if(this == &amp;vec)
      return false;
  
    for(Int i = 0; i &lt; _SIZE_; i++)
      if(me.__data[i] &gt;= vec[i])
        return false;
  
    return true;
  }
  
  template&lt;typename _TYPE_, Int _SIZE_&gt;
  Boolean Vec&lt;_TYPE_,_SIZE_&gt;::operator&gt; (const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec ) const
  {
    if(this == &amp;vec)
      return false;
  
    for(Int i = 0; i &lt; _SIZE_; i++)
      if(me.__data[i] &lt;= vec[i])
        return false;
  
    return true;
  }
  
  template&lt;typename _TYPE_, Int _SIZE_&gt;
  Boolean Vec&lt;_TYPE_,_SIZE_&gt;::operator&lt;=(const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec ) const
  {
    return !(me &gt; vec);
  }
  
  template&lt;typename _TYPE_, Int _SIZE_&gt;
  Boolean Vec&lt;_TYPE_,_SIZE_&gt;::operator&gt;=(const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec ) const
  {
    return !(me &lt; vec);
  }
  
  /*******************************************************************************
  * ELEMENT ACCESSORS.
  *******************************************************************************/
  
  template&lt;typename _TYPE_, Int _SIZE_&gt;
  const _TYPE_&amp; Vec&lt;_TYPE_,_SIZE_&gt;::operator[](const Int index) const
  {
    return me.__data[index];
  }
  
  template&lt;typename _TYPE_, Int _SIZE_&gt;
  _TYPE_&amp; Vec&lt;_TYPE_,_SIZE_&gt;::operator[](const Int index)
  {
    return me.__data[index];
  }
  
  
  /*******************************************************************************
  * ARITHMATICAL OPERATORS.
  *******************************************************************************/
  
  template&lt;typename _TYPE_, Int _SIZE_&gt;
  Vec&lt;_TYPE_,_SIZE_&gt; Vec&lt;_TYPE_,_SIZE_&gt;::operator+ (const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec) const
  {
    Vec&lt;_TYPE_,_SIZE_&gt; tmp;
  
    for(Int i = 0; i &lt; _SIZE_; i++)
      tmp[i] = me.__data[i] + vec[i];
  
    return tmp;
  }
  
  template&lt;typename _TYPE_, Int _SIZE_&gt;
  Vec&lt;_TYPE_,_SIZE_&gt; Vec&lt;_TYPE_,_SIZE_&gt;::operator- (const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec) const
  {
    Vec&lt;_TYPE_,_SIZE_&gt; tmp;
  
    for(Int i = 0; i &lt; _SIZE_; i++)
      tmp[i] = me.__data[i] - vec[i];
  
    return tmp;
  }
  
  template&lt;typename _TYPE_, Int _SIZE_&gt;
  Vec&lt;_TYPE_,_SIZE_&gt; Vec&lt;_TYPE_,_SIZE_&gt;::operator* (const _TYPE_ val ) const
  {
    Vec&lt;_TYPE_,_SIZE_&gt; tmp;
  
    for(Int i = 0; i &lt; _SIZE_; i++)
      tmp[i] = me.__data[i] * val;
  
    return tmp;
  }
  
  template&lt;typename _TYPE_, Int _SIZE_&gt;
  _TYPE_ Vec&lt;_TYPE_,_SIZE_&gt;::operator* (const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec) const
  {
    _TYPE_ tmp = 0;
  
    for(Int i = 0; i &lt; _SIZE_; i++)
      tmp += me.__data[i] * vec[i];
  
    return tmp;
  }
  
  template&lt;typename _TYPE_, Int _SIZE_&gt;
  Vec&lt;_TYPE_,_SIZE_&gt;&amp; Vec&lt;_TYPE_,_SIZE_&gt;::operator+=(const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec)
  {
    for(Int i = 0; i &lt; _SIZE_; i++)
      me.__data[i] = me.__data[i] + vec[i];
  
    return me;
  }
  
  template&lt;typename _TYPE_, Int _SIZE_&gt;
  Vec&lt;_TYPE_,_SIZE_&gt;&amp; Vec&lt;_TYPE_,_SIZE_&gt;::operator-=(const Vec&lt;_TYPE_,_SIZE_&gt;&amp; vec)
  {
    for(Int i = 0; i &lt; _SIZE_; i++)
      me.__data[i] = me.__data[i] - vec[i];
  
    return me;
  }
  
  template&lt;typename _TYPE_, Int _SIZE_&gt;
  Vec&lt;_TYPE_,_SIZE_&gt;&amp; Vec&lt;_TYPE_,_SIZE_&gt;::operator*=(const _TYPE_ val )
  {
    for(Int i = 0; i &lt; _SIZE_; i++)
      me.__data[i] = me.__data[i] * val;
  
    return me;
  }
  
  /*******************************************************************************
  ********************************************************************************
  **  3D Vector Class.
  ********************************************************************************
  *******************************************************************************/
  
  template&lt;typename _TYPE_&gt;
  class Vec3 : public Vec&lt;_TYPE_,3&gt;
  {
    public:
      Vec3(_TYPE_ x = 0, _TYPE_ y = 0, _TYPE_ z = 0);
      Vec3(const Vec&lt;_TYPE_,3&gt;&amp; vec);
      ~Vec3(void);
  };
  
  #define Vec3_f  Vec3&lt;Float&gt;
  
  template&lt;typename _TYPE_&gt;
  Vec3&lt;_TYPE_&gt;::Vec3(_TYPE_ x, _TYPE_ y, _TYPE_ z)
  {
    me[XYZ::X] = x;
    me[XYZ::Y] = y;
    me[XYZ::Z] = z;
  }
  
  template&lt;typename _TYPE_&gt;
  Vec3&lt;_TYPE_&gt;::Vec3(const Vec&lt;_TYPE_,3&gt;&amp; vec)
  {
    me[XYZ::X] = vec[XYZ::X];
    me[XYZ::Y] = vec[XYZ::Y];
    me[XYZ::Z] = vec[XYZ::Z];
  }
  
  template&lt;typename _TYPE_&gt;
  Vec3&lt;_TYPE_&gt;::~Vec3(void)
  {
  
  }
  </code></pre>
  
  <p>/* PhysicalState.h */</p>
  
  <pre><code>class PhysicalState
  {
    public:
      PhysicalState(Vec3_f pos = Vec3_f(1,1,1), Vec3_f rot = Vec3_f(2,2,2), Vec3_f scale = Vec3_f(3,3,3));
      PhysicalState(const PhysicalState&amp; phys);
      ~PhysicalState(void);
  
      PhysicalState&amp; operator=(const PhysicalState&amp; phys);
  
    //Private:
      Vec3_f position;
      Vec3_f rotation;
      Vec3_f scale;
  };
  </code></pre>
  
  <p>/* PhysicalState.cpp */</p>
  
  <pre><code>PhysicalState::PhysicalState(Vec3_f pos, Vec3_f rot, Vec3_f scale)
  {
    me.position = pos;
    me.rotation = rot;
    me.scale    = scale;
  }
  
  PhysicalState::PhysicalState(const PhysicalState&amp; phys)
  {
    me.position = phys.position;
    me.rotation = phys.rotation;
    me.scale    = phys.scale;
  }
  
  PhysicalState::~PhysicalState(void)
  {
  
  }
  
  PhysicalState&amp; PhysicalState::operator=(const PhysicalState&amp; phys)
  {
    if(this != &amp;phys)
    {
      me.position = phys.position;
      me.rotation = phys.rotation;
      me.scale    = phys.scale;
    }
  
    return me;
  }
  </code></pre>
  
  <p>/* Test.cpp */</p>
  
  <pre><code>int main(void)
  {
    PhysicalState ps;
  
    return 0;
  }
  </code></pre>
  
  <p>Sorry about the length. Here is the output from valgrind:</p>
  
  <pre><code>darkdivine@darkdivine-laptop:~/Development/Projects/Engines/DarkDivine$ LD_LIBRARY_PATH=./Bin/Debug/ valgrind
  --track-origins=yes --leak-check=full ./Bin/Debug/Test
      ==18549== Memcheck, a memory error detector
      ==18549== Copyright (C) 2002-2009, and GNU GPL'd, by Julian Seward et al.
      ==18549== Using Valgrind-3.6.0.SVN-Debian and LibVEX; rerun with -h for copyright info
      ==18549== Command: ./Bin/Debug/Test
      ==18549== 
      ==18549== Invalid free() / delete / delete[]
      ==18549==    at 0x40244D3: operator delete[](void*) (vg_replace_malloc.c:409)
      ==18549==    by 0x804905A: DarkDivine::Vec&lt;float, 3&gt;::~Vec() (Vector.h:91)
      ==18549==    by 0x8048FE3: DarkDivine::Vec3&lt;float&gt;::~Vec3() (Vector.h:282)
      ==18549==    by 0x4036B69: DarkDivine::PhysicalState::~PhysicalState() (PhysicalState.cpp:23)
      ==18549==    by 0x8048E77: main (Test.cpp:15)
      ==18549==  Address 0x4740128 is 0 bytes inside a block of size 12 free'd
      ==18549==    at 0x40244D3: operator delete[](void*) (vg_replace_malloc.c:409)
      ==18549==    by 0x804905A: DarkDivine::Vec&lt;float, 3&gt;::~Vec() (Vector.h:91)
      ==18549==    by 0x8048FE3: DarkDivine::Vec3&lt;float&gt;::~Vec3() (Vector.h:282)
      ==18549==    by 0x8048E3B: main (Test.cpp:13)
      ==18549== 
      ==18549== Invalid free() / delete / delete[]
      ==18549==    at 0x40244D3: operator delete[](void*) (vg_replace_malloc.c:409)
      ==18549==    by 0x804905A: DarkDivine::Vec&lt;float, 3&gt;::~Vec() (Vector.h:91)
      ==18549==    by 0x8048FE3: DarkDivine::Vec3&lt;float&gt;::~Vec3() (Vector.h:282)
      ==18549==    by 0x4036B77: DarkDivine::PhysicalState::~PhysicalState() (PhysicalState.cpp:23)
      ==18549==    by 0x8048E77: main (Test.cpp:15)
      ==18549==  Address 0x4740168 is 0 bytes inside a block of size 12 free'd
      ==18549==    at 0x40244D3: operator delete[](void*) (vg_replace_malloc.c:409)
      ==18549==    by 0x804905A: DarkDivine::Vec&lt;float, 3&gt;::~Vec() (Vector.h:91)
      ==18549==    by 0x8048FE3: DarkDivine::Vec3&lt;float&gt;::~Vec3() (Vector.h:282)
      ==18549==    by 0x8048E04: main (Test.cpp:13)
      ==18549== 
      ==18549== Invalid free() / delete / delete[]
      ==18549==    at 0x40244D3: operator delete[](void*) (vg_replace_malloc.c:409)
      ==18549==    by 0x804905A: DarkDivine::Vec&lt;float, 3&gt;::~Vec() (Vector.h:91)
      ==18549==    by 0x8048FE3: DarkDivine::Vec3&lt;float&gt;::~Vec3() (Vector.h:282)
      ==18549==    by 0x4036B9C: DarkDivine::PhysicalState::~PhysicalState() (PhysicalState.cpp:23)
      ==18549==    by 0x8048E77: main (Test.cpp:15)
      ==18549==  Address 0x47401a8 is 0 bytes inside a block of size 12 free'd
      ==18549==    at 0x40244D3: operator delete[](void*) (vg_replace_malloc.c:409)
      ==18549==    by 0x804905A: DarkDivine::Vec&lt;float, 3&gt;::~Vec() (Vector.h:91)
      ==18549==    by 0x8048FE3: DarkDivine::Vec3&lt;float&gt;::~Vec3() (Vector.h:282)
      ==18549==    by 0x8048DE2: main (Test.cpp:13)
      ==18549== 
      ==18549== 
      ==18549== HEAP SUMMARY:
      ==18549==     in use at exit: 36 bytes in 3 blocks
      ==18549==   total heap usage: 10 allocs, 10 frees, 120 bytes allocated
      ==18549== 
      ==18549== 12 bytes in 1 blocks are definitely lost in loss record 1 of 3
      ==18549==    at 0x402532E: operator new[](unsigned int) (vg_replace_malloc.c:299)
      ==18549==    by 0x804923C: DarkDivine::Vec&lt;float, 3&gt;::Vec() (Vector.h:72)
      ==18549==    by 0x8048F76: DarkDivine::Vec3&lt;float&gt;::Vec3(float, float, float) (Vector.h:265)
      ==18549==    by 0x40367F1: DarkDivine::PhysicalState::PhysicalState(DarkDivine::Vec3&lt;float&gt;, DarkDivine::Vec3&lt;float&gt;, DarkDivine::Vec3&lt;float&gt;) (PhysicalState.cpp:6)
      ==18549==    by 0x8048DD7: main (Test.cpp:13)
      ==18549== 
      ==18549== 12 bytes in 1 blocks are definitely lost in loss record 2 of 3
      ==18549==    at 0x402532E: operator new[](unsigned int) (vg_replace_malloc.c:299)
      ==18549==    by 0x804923C: DarkDivine::Vec&lt;float, 3&gt;::Vec() (Vector.h:72)
      ==18549==    by 0x8048F76: DarkDivine::Vec3&lt;float&gt;::Vec3(float, float, float) (Vector.h:265)
      ==18549==    by 0x403681A: DarkDivine::PhysicalState::PhysicalState(DarkDivine::Vec3&lt;float&gt;, DarkDivine::Vec3&lt;float&gt;, DarkDivine::Vec3&lt;float&gt;) (PhysicalState.cpp:6)
      ==18549==    by 0x8048DD7: main (Test.cpp:13)
      ==18549== 
      ==18549== 12 bytes in 1 blocks are definitely lost in loss record 3 of 3
      ==18549==    at 0x402532E: operator new[](unsigned int) (vg_replace_malloc.c:299)
      ==18549==    by 0x804923C: DarkDivine::Vec&lt;float, 3&gt;::Vec() (Vector.h:72)
      ==18549==    by 0x8048F76: DarkDivine::Vec3&lt;float&gt;::Vec3(float, float, float) (Vector.h:265)
      ==18549==    by 0x4036843: DarkDivine::PhysicalState::PhysicalState(DarkDivine::Vec3&lt;float&gt;, DarkDivine::Vec3&lt;float&gt;, DarkDivine::Vec3&lt;float&gt;) (PhysicalState.cpp:6)
      ==18549==    by 0x8048DD7: main (Test.cpp:13)
      ==18549== 
      ==18549== LEAK SUMMARY:
      ==18549==    definitely lost: 36 bytes in 3 blocks
      ==18549==    indirectly lost: 0 bytes in 0 blocks
      ==18549==      possibly lost: 0 bytes in 0 blocks
      ==18549==    still reachable: 0 bytes in 0 blocks
      ==18549==         suppressed: 0 bytes in 0 blocks
      ==18549== 
      ==18549== For counts of detected and suppressed errors, rerun with: -v
      ==18549== ERROR SUMMARY: 6 errors from 6 contexts (suppressed: 63 from 6)
  </code></pre>
  
  <p>Thanks in advance to anyone who can help me with this it is driving me crazy!!
  GD.</p>
  
  <p>PS: me = (*this);
      NOTHING = 0;</p>