Re: Unqualified lookup fails...
On Jul 26, 1:22 pm, Werner wrote:
------------------------------------------------
template <class T>
struct Xx
{
Xx()
{
T inst;
int n = sequenceSize( inst );
}
};
[snip]
A couple of options exist:
1) Functions sequenceSize would be found if they were
in the same namespaces as classes "Headerx" (by ADL).
This sounds like the way to go.
2) A declaration of sequenceSize need at least exist
prior to the template definition.
No, don't do that. Rely on ADL.
I now have a case like this:
struct MsgX
{
int sequenceSizeOfA_;
int sequenceSizeOfB_;
std::vector<A> a_;
std::vector<B> b_;
};
I still would like the calling code (in the template
to work, therefore:
//Translation Unit A:
namespace {
int sequenceSize( const MsgX& msg )
{
return msg.sequenceSizeOfA_;
}}
#include "Xx.h"
//Translation Unit B:
namespace {
int sequenceSize( const MsgX& msg )
{
return msg.sequenceSizeOfB_;
}}
#include "Xx.h"
... but this makes the compilation dependent on
the order of inclusion.
Not only that. I believe it is also a violation of the ODR (one
definition rule) since you rely on two different versions of
Xx<MessageX>::Xx. So, this is not even an option unless you are fine
with unedfined behaviour.
Also, in this case
I cannot use ADL, because in both instances
of sequenceSz, the argument type is the same.
You could use a wrapper type + ADL:
struct wrapper_MsgX_A
{
MsX data;
};
int sequenceSize(wrapper_MsgX_A const& x)
{ return x.data.sequenceSizeOfA_; }
...
Xx<wrapper_MsgX_A> foo;
Now the question:
1) Is it bad of Xx to depend on an unqualified name?
No. It's good since it allows ADL and ADL is a good thing.
2) If I'm not able to change Xx, what would be a good
solution - to include the declaration of sequenceSize
above Xx?
No.
3) If I am allowed to change Xx, what would you do?
Keep it as it is or introduce another layer of indirection via a
traits
class or additional template parameter for Xx.
Cheers!
SG