Re: Template Partial Specialization
On 9 Jul., 07:39, "Alex K." <alex.j...@gmail.com> wrote:
I am learning about templates and I have a hard time making some
code to compile.
I found out about a trick to make partial specialization for functions
-- but apparently I did not understand it correctly as I can't compile
my code.
The trick is supposed to work by writing the base template for the
needed template function as just a call to a method of a class -- and
then partially specialize the class, which is allowed by C++.
This is correct.
But the code bellow does not compile:
----------------------------------------
#include <vector>
template<class the_type>
struct Implement_is_equal {
static bool _is_equal(the_type first, the_type second);
};
template<class the_type>
bool is_equal(the_type first, the_type second){
return Implement_is_equal<the_type>::_is_equal(first, second);
};
template<class the_type>
inline
bool Implement_is_equal<the_type>::_is_equal(the_type first, the_type
second) {
return (first == second);
};
OK, this is just an out-of-class definition of the member function
_is_equal of the *primary* class template Implement_is_equal.
template<class the_type>
inline
bool Implement_is_equal<std::vector<the_type> >::_is_equal
(std::vector<the_type> first, std::vector<the_type> second) {
bool _result = true;
if (first.size() != second.size()) {_result = false;}
else {for (int i = 0, _size = first.size(); i < _size; i++){
if (first.at(i) != second.at(i)) {_result = false;
break;}
}
}
return _result;};
This is the cause of your problem. It is *not* a partial
specialization of your class Implement_is_equal. To
realize such a partial specialization you need to write
it this way:
a) Define the partial specialization of the *class
template* Implement_is_equal [I intentionally substituted
your argument types by references to const to prevent
unnecessary copies of the vector. I suggest to replace
the argument types in your free function template
is_equal similarly]:
template<class the_type>
struct Implement_is_equal< std::vector<the_type> > {
static bool _is_equal(const std::vector<the_type>& first,
const std::vector<the_type>& second);
};
b) Define the member _is_equal of your partial
specialization Implement_is_equal< std::vector<the_type> >:
template<class the_type>
inline bool
Implement_is_equal< std::vector<the_type> >::_is_equal(
const std::vector<the_type>& first,
const std::vector<the_type>& second) {
// Your code as before
}
Note: For this particular example your manual specialization
for std::vector<T> is not very advantageous, because the
standard library already defines operator== for std::vector
with the guarantee that two vectors of different size
immediately return false. Also, your usage of member function
at is no win, because inside your loop you do exactly know
that the argument of at is in the domain valid for oeprator[].
HTH & Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]