Re: Unqualified lookup fails...

From:

Werner <werasm@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Thu, 26 Jul 2012 07:14:34 -0700 (PDT)

Message-ID:

<b56c4ef1-8598-482d-91be-dd91c0651c3d@q29g2000vby.googlegroups.com>

On Jul 26, 1:57 pm, Victor Bazarov <v.baza...@comcast.invalid> wrote:

[snip]

Here is another solution, and if you can't change the header in which Xx
template resides, wrap it to add the declaration:

    // -- inside the wrapper header
    namespace {
       template<class T> int sequenceSize(const T&);
    }
    // -- the wrapping header includes the Xx header:
    template <class T>
    struct Xx
    {
       int m_size;
       Xx() : m_size(sequenceSize(T()))
       {
       }
    };
    // ---- end of the wrapper

    struct Header1
    {
       int sequenceSize_;
    };

    struct Header2
    {
       int itemCount_;
    };

    namespace {
       template<>
       int sequenceSize<Header1>( const Header1& h )
       {
          return h.sequenceSize_;
       }
       template<>
       int sequenceSize<Header2>( const Header2& h )
       {
          return h.itemCount_;
       }
    }

    int main()
    {
       Xx<Header1> xH1;
       Xx<Header2> xH2;
    }

Keep in mind that if you don't need your 'sequenceSize' specializations
in the unnamed namespace, remove the declaration of the template from it
as well. That's what I'd do anyway.

Interesting idea. I haven't thought of using a wrapper header. It
would still not work for the last case documented, where one
has one type containing two lists:

struct MsgX
{
  int sequenceSizeOfA_;
  int sequenceSizeOfB_;

  std::vector<A> a_;
  std::vector<B> b_;
};

....but it is certainly a nice solution for similar problems
if one is not able to modify the template.

Thanks,

Regards, Werner