Strange "incomplete type" compile error

[wien]

Hey guys. I am currently experimenting with some different ideas for a Unicode string class, and I came up with a problem I just can't figure out. I hope someone else here can.

The following code has been tested on both VC++ 7.1, GCC 3.3 and Comeau (The online version), and none of them can compile it.

#include <iostream>
#include <cstddef>

struct utf8_tag {};
struct utf16_tag {};
struct utf32_tag {};

namespace detail
    {
    typedef std::size_t size_type;
    typedef unsigned int value_type;
    }

template<typename enc>
struct encoding_traits;

template<>
struct encoding_traits<utf32_tag>
    {
    static detail::value_type get_at_index(detail::size_type index)
        {
        return index;
        }
    };

class encoded_string
    {
    public:
        typedef detail::size_type size_type;
        typedef detail::value_type value_type;
           
    private:
        value_type (*get_at_index)(size_type);

    public:
        template<typename enc>
        encoded_string(enc dummy)
            {
            get_at_index = &encoding_traits<enc>::get_at_index;
            }

        value_type operator [] (size_type index)
            {
            return get_at_index(index);
            }
    };

int main()
    {
    encoded_string test(utf32_tag());

    std::cout << test[1337] << std::endl;

    system("pause");
    }

Basically all of them complain that the type of test is incomplete. (Although only Comeau is kind enough to let you know that's what the problem is.)

Comeau C/C++ 4.3.3 (Aug  6 2003 15:13:37) for ONLINE_EVALUATION_BETA1
Copyright 1988-2003 Comeau Computing.  All rights reserved.
MODE:strict errors C++

"ComeauTest.c", line 52: error: expression must be a pointer to a complete object
          type
      std::cout << test[1337] << std::endl;
                   ^

1 error detected in the compilation of "ComeauTest.c".

The really strange bit though, is that if I change "encoded_string test(utf32_tag());" to "encoded_string test = utf32_tag(); Everything suddenly compiles without a hitch.

Anyone care to enlighten me?

[RoboTact]

VC++6 compiled it well (output is "1337").

[wien]

VC++6 compiled it well.

Really? That was one compiler I really didn't expect to compile this. Still don't understand what the problem is though...

[wien]

Experimenting a little more, I found out that making a template function that returns the encoding tag fixes the problem, but I still don't understand why the original code is wrong.

template<typename enc>
enc make_tag()
    {
    return enc();
    }

...
encoded_string test(make_tag<utf32_tag>());

[cilu]

It also work without problems on VC++7.0 .

[Paul McKenzie]

The only thing I can possibly imagine is that for a constructor template function, the rules are more explicit, and that the lookup rules as to resolving the template doesn't apply. The following gives no errors for Comeau C++.

#include <iostream>
#include <cstddef>

struct utf8_tag {};
struct utf16_tag {};
struct utf32_tag {};

namespace detail
{
    typedef std::size_t size_type;
    typedef unsigned int value_type;
}

template<typename enc>
struct encoding_traits;

template<>
struct encoding_traits<utf32_tag>
{
    static detail::value_type get_at_index(detail::size_type index)
    {
        return index;
    }
};

class encoded_string
{
    public:
        typedef detail::size_type size_type;
        typedef detail::value_type value_type;
           
    private:
        value_type (*get_at_index)(size_type);

    public:
        encoded_string()
        {
        }

        template<typename enc>
         void init(enc dummy)
         {
            get_at_index = &encoding_traits<enc>::get_at_index;
         }

        value_type operator [] (size_type index)
            {
            return get_at_index(index);
            }
    };

int main()
    {
    encoded_string test;

    test.init(utf32_tag());

    std::cout << test[1337] << std::endl;

    system("pause");
    }

Note that all I did was to construct the object with a non-templated constructor, and then call a templated "init" function.

Regards,

Paul McKenzie

[wien]

The only thing I can possibly imagine is that for a constructor template function, the rules are more explicit, and that the lookup rules as to resolving the template doesn't apply.

Hmm.. I think you're on to something here.

The problem seems to come from the fact that the only parameter to the constructor is templated. I tried making a version where the constructor has two parameters, the first of which has a known type (That is, not a templated one), and that works flawlessly in Comeau and VC++. It does however crash sometimes on GCC. (It does compile correctly... strange.)

template<typename enc>
encoded_string(float first_dummy, enc dummy)
    {
    get_at_index = &encoding_traits<enc>::get_at_index;
    }

...

encoded_string test(2.0f, utf32_tag());

Guess I have to get myself a copy of the standard. There must be something about this in there, since this is consistent behaviour across multiple compilers.