[Bug c++/20414] New: C-style cast fails to do proper conversion (explicit type conversion)

["simonc235 at yahoo dot com" <gcc-bugzilla at gcc dot gnu dot org>]

It seems that g++ is not compliant with the standard for old-style C casts -
potentially causing programs to crash.

Below is a code sample followed by an detailing of what happens in practice, and
what I think should happen. Cast#5 is the problematic cast.

======== CODE STARTS HERE =========

#include <iostream>

struct B
{
  B (const char *s):str (s)
  {
  }
  const char *str;
};
struct H
{
  H (const char *s)
  {
    strcpy (str, s);
  }
  operator const B ()
  {
    return B (str);
  }
  char str[1024];
};

void
f (const B & b)
{
  std::cout << b.str << std::endl;
}

int
main (int argc, char *argv[])
{
  H h ("hi4243");
  
  // cast #1: initialization by conversion for reference binding OK
  const B &b = h;

  // cast #2: direct-initialization
  const B b2(h);

  // cast #3: explicit static_cast OK
  f (static_cast<const B &>(h));

  // cast #4: C-style cast, works as expected OK
  f ((const B)h);

  // cast #5: C-style cast, should cause an implicit conversion sequence,
  // but it does not ERROR!! program will crash
  f ((const B &)h);
  
  return 0;
}

======== CODE ENDS HERE =========

Here is what g++ does for each cast:

#1 - call the conversion operator in H to turn 'h' to type B and then proceed
using a standard conversion sequence. This is compliant with "Section 13.3.1.6
Initialization by conversion function for direct reference binding" of the standard.

#2 - essentially does the same as #1, but is there to show the validity of the
static_cast in cast #3 based on "Section 5.2.9 Static cast clause 2" of the
standard. The process itself is described in "Section 8.5 clauses 12 and 14" of
the standard.

#3 - performs an explicit static_cast to a reference type. Cast #2 shows that
this is well-formed.

#4 - performs a cast using the user-defined conversion operator as expected.

#5 - performs the equivalent of a reinterpret_cast. This causes the program to
crash. 

The standard is clear in saying that when an old-style C-cast("explicit type
conversion"/"cast notation") is used, the compiler should attempt the conversion
 -exactly- in this order: const_cast, static_cast, static_cast followed by
const_cast, reinterpret_cast, and reinterpret_cast followed by a const_cast. It
goes on to say that if more than one cast is possible, the -first- one in this
list should be used.

The code sample above shows that a static_cast works properly(#3), but an
explicit cast(#5) fails to detect the possibility of using a static_cast;
moreover, cast #4 seems to indicate that the problem is g++'s failure to do a
standard conversion sequence before looking up the user-defined conversion
operator in H.

I might be misreading or misunderstanding the standard, so if that is the case,
please let me know.

Thanks,
Simon

-- 
           Summary: C-style cast fails to do proper conversion (explicit
                    type conversion)
           Product: gcc
           Version: 3.4.3
            Status: UNCONFIRMED
          Severity: normal
          Priority: P2
         Component: c++
        AssignedTo: unassigned at gcc dot gnu dot org
        ReportedBy: simonc235 at yahoo dot com
                CC: gcc-bugs at gcc dot gnu dot org


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=20414