Can all instantiations of a class template share the same template independent member function?

Question

In the example below, I assume there will be two different instantiations of the class template function get_count(), which is redundant since they are not depending on the template parameter. Is this true (or optimized away?), and is there a way to make all instantiations of a template use a common function (maybe some template argument wildcard, like <*>?) when it comes to some member functions?

template<class T>
class A {
    private:
        T obj;
        int count;
    public:
        int get_count(); 
};

template<class T>
int A<T>::get_count() { // This function doesn't really need to
                        // depend on the template parameter.
    return this->count;
}

int main() {
    A<int> a;  //<--First template instantiation
    A<bool> b; //<--Second template instantiation
    int i = a.get_count(); //<--Could theoretically use the same code
    int j = b.get_count(); //<--
    return 0;
}

Also, what if the member variables are re-arranged?

Deduplicator · Accepted Answer · 2014-10-23T13:46:10.540

4

You are quite mistaken in your assumption that all instantiations can use the same code for A<..>::get_count().

Look at the class members:

    T obj;
    int count;

Thus, the tamplate-argument T determines the offset of count, which is the member get_count() returns.

Anyway, should two instantiations happen to produce the same instructions, nothing prohibits the compiler from mergeing them.
As a QoI-issue, it should if optimizations are enabled.

There is a way to make multiple classes use the same code for a function without relying on compiler-optimization:
Derive from a common base providing that function.

struct A_base {
    int get_count();
protected:
    int count;
}
template<class T>
class A : A_base {
    T obj;
};

int A_base::get_count() {
    return this->count;
}

(Still, in the end the as-if-rule reigns supreme: The compiler may duplicate code to expose optimization possibilities otherwise not useable.)

edited Oct 23 '14 at 13:46

answered Oct 23 '14 at 13:35

Deduplicator

44,692
7
66
118

True, turn them around then and put count on top... then they could share code :) – fast-reflexes Oct 23 '14 at 13:37
My answer also accounts for the case of those members being re-arranged. I also broadened your question with that. – Deduplicator Oct 23 '14 at 13:43
Great! Ok, so if I for some reason wanna define my method inside the template, the way to go is like in my example? – fast-reflexes Oct 23 '14 at 13:51
1

Yes, but you pay the penalty: Reliance on the compiler to optimize it away. – Deduplicator Oct 23 '14 at 13:52
I'll go with inheritance! Thank you! – fast-reflexes Oct 23 '14 at 13:55
If anything takes the address of `get_count`, it may have to differ between templates, even if the implementarions are identical. Not sure how to test that with methods, as method pointers are magic. hmm. – Yakk - Adam Nevraumont Oct 23 '14 at 14:59
@Yakk: Nope. There is no guarantee that any two functions are different. – Deduplicator Oct 23 '14 at 16:27
@Deduplicator really? Hmm, I cannot find anything disagreeing in the standard. Do you have a citation, or is it just the lack of contradiction in the standard? – Yakk - Adam Nevraumont Oct 23 '14 at 16:52
@Yakk: I don't think there is anything to quote in the standard, they just leave it undefined. – Deduplicator Oct 23 '14 at 16:55
1

@Deduplicator asked a question on the subject here: http://stackoverflow.com/q/26533740/1774667 – Yakk - Adam Nevraumont Oct 23 '14 at 17:53

score 0 · Answer 2 · answered Oct 23 '14 at 13:48

Yes, there is a way and it is an implementation technique used:

Make a base class that does not depend on the template parameter and put the template-independent code there. This will make the instantiation only once. For the template parameters dependent code, do it in the template class itself:

class base {
   int count;
public:
    std::size_t get_count()...
};

template <class T>
class derived : public base {};

Similar techniques are used to reduce code bloat in implementations.

oh true, did not read that. Just focused on the question. That will do it then. — Germán Diago, Oct 23 '14 at 13:50

Can all instantiations of a class template share the same template independent member function?

2 Answers2