Re: Template base class - inheritance works different
On Sep 11, 1:27 am, Jason <bumperman...@hotmail.com> wrote:
Your problem (as reported) has absolutely nothing to do with
templates. It's simply that your derived class copy constructor
is incorrect. You don't initialize base class members in the derived
class copy constructor (see embedded comments below). Also, see my
comment at the very bottom.
Hi,
I have made a template base class and deriving a class from that base
class. It doesn't work the way I expect it to work. See following:
// base.h
#include <cstring>
Don't use cstring.
#include <algorithm>
template<class T>
class MyBase;
template<class T>
MyBase<T> operator+(const MyBase<T>& v1, const MyBase<T>& v2);
template<class T>
class MyBase
{
protected:
T m_array[8];
protected:
MyBase(const MyBase& rhs)
{
memcpy(m_array, rhs.m_array, sizeof(T) * 8);
std::copy(rhs.m_array, rhs.m_array+8, m_array);
}
MyBase() { memset(m_array, 0, sizeof(T) * 8); }
MyBase(const T(array)[8])
Are you trying to pass a reference to an array of 8? This decays to a
T*.
Use either "const T* array", or "const T(&array)[8]"
{
memcpy((T*)m_array, array, 8 * sizeof(T));
C style cast is bad, and unnecessary. m_array decays to a T*.
Don't use memcpy.
std::copy(array, array+8, m_array);
}
friend MyBase<T> operator+<>(const MyBase<T>&, const MyBase<T>&);
};
class MyDerived : public MyBase<int>
{
public:
MyDerived() {}
template<typename T>
MyDerived(const MyBase<T>&);
MyDerived(const MyDerived& other)
: m_array(other.m_array)
The specific error you were getting is here.
m_array is not initialized as part of the MyDerived constructor. It
should be initialized as part of the MyBase constructor.
MyDerived(const MyDerived& other)
: MyBase(other)
{
}
};
// base.cpp
#include "base.h"
int main(int argc, char* argv[])
{
MyDerived d1, d2;
MyDerived d3 = d1 + d2;
Error: operator+ not implemented.
return 0;
}
Compiling with GCC, gives me:
base.h: In copy constructor 'MyDerived::MyDerived(const MyDerived&)':
base.h:38: error: class 'MyDerived' does not have any field named
'm_array'
base.cpp: In function 'int main()':
base.h:19: error: 'MyBase<T>::MyBase(const MyBase<T>&) [with T = int]'
is protected
base.cpp:6: error: within this context
Isn't MyDerived a MyBase<int>? Therefore, isn't m_array inherited? I
have declared operator as a free function. I think when deriving from
a template base class, one needs to overload copy constructor and a
few more things to get this compiling. Why is this happening? I saw
similar issues multiple times but I don't have any explanation! One of
my friends resolved a similar compilation problem but we have no
answer to why is that happening?
It looks like you're a relative newbie. I'd start with non-template
classes
to understand how inheritance, constructors, and operators work before
I bothered
with templates.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]