C++ Template Function Instantiation Code Size - c++

Question

I'm trying to reduce the number of template function instantiations, but am running into a snag.
Suppose we have the following class (I know it's not optimized: this is done on purpose to illustrate the issue):
//class no_inherit is implemented the same way as class base (below).
//This is done to illustrate the issue I'm seeing.
template<typename T, size_t SIZE>
class no_inherit
{
private:
T m_data[SIZE];
const size_t m_size;
public:
no_inherit() :m_size(SIZE){}
T& operator[](size_t i)
{return m_data[i];}
inline size_t size() const
{return m_size;}
};
The following function:
template<typename T>
void huge_func(T& v)
{
//..do lots of stuff with v. For example
for(size_t i = 0; i < v.size(); ++i)
v[i] = v[i] + i;
//...do lots more with v
}
And the following code:
int main()
{
no_inherit<int, 4> v1;
no_inherit<int, 2> v2;
huge_func(v1);
huge_func(v2);
}
huge_func() would get instantiated twice:
void huge_func(no_inherit<int, 4>& v);
void huge_func(no_inherit<int, 2>& v);
Since huge_func() is, well, huge, I'm trying to reduce the instantiation count by taking one of the template parameters and turning it into a dynamic parameter by creating the following class hierarchy:
//Base class only has 1 template parameter.
template<typename T>
class base
{
private:
T *m_data;
const size_t m_size; //hold child's templated size parameter.
protected:
inline base(T* data, size_t size): m_data(data), m_size(size){}
public:
T& operator[](size_t i)
{return m_data[i];}
inline size_t size() const
{return m_size;}
};
//Child class has two template parameters
template<typename T, size_t SIZE>
class inherit: public base<T>
{
private:
T m_data[SIZE];
public:
//Pass template parameter to base class
inherit() : base<T>(m_data, SIZE){}
};
And I call huge_func() as follows:
int main()
{
inherit<int, 4> v1;
inherit<int, 2> v2;
//make sure only one instantiation of huge_func() is made
//by using the same type.
base<int> &v1b = v1;
base<int> &v2b = v2;
huge_func(v1b);
huge_func(v2b);
}
This would only instantiate a single huge_func() function:
void huge_func(base<int>& v);
And thus would decrease the code size.
But ALAS! The code size increases when I use the class hierarchy. How is this possible?
Even more bizzare, if I have the following code.
int main()
{
inherit<int, 4> v1;
inherit<int, 2> v2;
huge_func(v1);
huge_func(v2);
}
The code size is the same as calling huge_func(v1b) and huge_func(v2b).
What is the compiler doing?

Answer 1

First of all, if huge_func is indeed "huge", you likely would benefit from splitting it up into several reusable smaller functions.
That aside, you can also template-ize it:
template<typename T, int SIZE> void huge_func(no_inherit<T, SIZE>& v)
{
// function implementation goes here
}
Then you are implementing it once, and you maintain your flat class structure.