Template syntax and coercion

[Grumpulus]

Here's another one for the gurus.

The following code compiles in GCC 4.7.3. However, if you go to the implementation of the destructor (near the end), and replace the line marked "Compiles" with the commented out line that follows it, you will get a compile-time error.

Fine -- so it's a syntax error. The odd thing, though, is that if you then proceed to comment out the coercion constructor from the template (and remove the definition of cf1 from main(), of course), the error goes away.

Why is this?

// Template declaration:


template<class T>
class C
{
 public:
  T val;


  C(C const& that);      // Copy constructor


  C(T const& thing);     // Argument constructor


  template <class U>     // Coercion constructor; assumes T=U is defined
  C(C<U> const& thatU);


 ~C();                   // Destructor
};


// Template implementation:


template<class T>        // Copy constructor implementation
C<T>::C(C<T> const& that)
{
  val = that.val;
}


template<class T>        // Argument constructor implementation
C<T>::C(T const& thing)
{
  val = thing;
}


template<class T>        // Coercion constructor implementation
template<class U>
C<T>::C(C<U> const& thatU)
{
  val = thatU.val;
}


template<class T>        // Destructor implementation
C<T>::~C()               // Compiles
//C<T>::~C<T>()          // "error: expected identifier", *if* coercion exists
{
}


int main()
{
  C<int>   ci1(3);       // Argument construction
  C<int>   ci2(ci1);     // Copy construction
  C<float> cf1(ci1);     // Coercion
}

[Aslaville]

What you are observing is indeed the expected behavior

The same way you write:

template<class T>        // Argument constructor implementation
C<T>::C(T const& thing)
{
  val = thing;
}

The syntax you are following is the 'class :: function' and you should similarly do that with the destructor

C<T>::C()
{

}

Assuming the syntax you use for the destructor is what is right( The syntax that you complain is not compiling), you could be writing your other functions like this

template<class T>        // Argument constructor implementation
C<T>::C<T>(T const& thing)
{
  val = thing;
}

which clearly is not correct

[Elysia]

Possible compiler bug, if what you say is true.
Anyway, C<T>::~C<T> is an error because the class C itself is a template class hence needing <>, but the destructor is NOT a template function (whose name is ~C), therefore it does NOT need <>. The destructor may have the same name as the class itself, but it is not in any way related to the class name. It is a function with the same name only.

[Grumpulus]

Yeah -- I realized right away that the C<T>::~C<T> syntax was wrong (though your response and the other fellow's did clarify the reason for that -- thanks).

What baffles me is why commenting out the coercion constructor should stop the syntax error from being reported.

I stumbled across this completely by accident. Maybe it really is a bug.

[Aslaville]

Yeah -- I realized right away that the C<T>::~C<T> syntax was wrong (though your response and the other fellow's did clarify the reason for that -- thanks).

What baffles me is why commenting out the coercion constructor should stop the syntax error from being reported.

I stumbled across this completely by accident. Maybe it really is a bug.

Well, just for the record, I tried this out with gcc 4.8.1 and I got the same behaviour.

Odd enough, on clang 3.3 both destructor implementations compile - there is no error in both case

[phantomotap]

O_o

Wow.

I'm sure the quirk is a side effect of parsing optional syntax for correct code, but a compiler not giving a notice about the wonky version is kind of bizarre.

Soma

#include <iostream>

template
<
    typename F
>
struct STest1
{
    STest1(){std::cout << "STest1\n";}
    ~STest1(){std::cout << "~STest1\n";}
};

template
<
    typename F
>
struct STest2
{
    STest2<F>(){std::cout << "STest2\n";}
    ~STest2<F>(){std::cout << "~STest2\n";}
};

template
<
    typename F
>
struct STest3
{
    STest3();
    ~STest3();
};

template
<
    typename F
>
STest3<F>::STest3() // not STest3<F>::STest3<F>
{
    std::cout << "STest3\n";
}

template
<
    typename F
>
STest3<F>::~STest3() // not STest3<F>::~STest3<F>
{
    std::cout << "~STest3\n";
}

template
<
    typename F
>
struct STest4
{
    STest4<F>();
    ~STest4<F>();
};

template
<
    typename F
>
STest4<F>::STest4() // not STest4<F>::STest4<F>
{
    std::cout << "STest4\n";
}

template
<
    typename F
>
STest4<F>::~STest4() // not STest4<F>::~STest4<F>
{
    std::cout << "~STest4\n";
}

int main()
{
    STest1<int> s1;
    STest2<int> s2;
    STest3<int> s3;
    STest4<int> s4;
}

[Grumpulus]

Okay guys, thanks for your input. Sounds like we have a real issue here. As soon as I get the chance, I'll report it.