In C++14 is it valid to use a double in the dimension of a new expression?

Question

In C++14 given the following code:

void foo() {
  double d = 5.0;
  auto p1 = new int[d];
}

clang compiles this without diagnostic while gcc on the other hand produces the following diagnostic (see it live in godbolt):

error: expression in new-declarator must have integral or enumeration type
    7 |     auto p1 = new int[d];
      |                       ^

I specifically labeled this C++14 because in C++11 mode clang treats this as ill-formed and produces the following diagnostic (see it live in godbolt):

error: array size expression must have integral or unscoped enumeration type, not 'double'
    auto p1 = new int[d];
              ^       ~

Is clang correct? If so what changed in C++14 to allow this?

Out of curiosity, a double allows for fractional quantities, so how would you allocate 0.75 of an integer, such as `int * p_array = new int [0.75];`? Or take something like 0.33333333, which is kind of difficult to allocate. — Thomas Matthews, Dec 12 '18 at 15:13
I expect it to use the binary value of it as an integer even when it's a double so 0.75 would be 0011111111101 as an integer it's 16360 — tomer zeitune, Dec 12 '18 at 15:50
@ThomasMatthews no this would end up being a float to integral conversion and [would truncate the float](http://eel.is/c++draft/conv.fpint#1) — Shafik Yaghmour, Dec 12 '18 at 15:59
@tomerzeitune Well, that (0.75 -> 0) is not what you wrote (0.75 -> 16360) ;) — Bob__, Dec 13 '18 at 09:50
@Bob__ it won't round towards zero it will refer to it as an int like type punning — tomer zeitune, Dec 13 '18 at 11:56
@tomerzeitune: I'm curious what basis you see for asserting that this would use type punning. Of what possible use would that be? Converting a floating-point value to an integer type (`5.0` to `5`) would make a lot more sense. — Keith Thompson, Dec 13 '18 at 22:52

Shafik Yaghmour · Answer 1 · 2018-12-15T15:00:11.073

Clang is correct, the key wording in [expr.new]p6 changes from the following in the C++11 draft:

Every constant-expression in a noptr-new-declarator shall be an integral constant expression ([expr.const]) and evaluate to a strictly positive value. The expression in a noptr-new-declarator shall be of integral type, unscoped enumeration type, or a class type for which a single non-explicit conversion function to integral or unscoped enumeration type exists ([class.conv]). If the expression is of class type, the expression is converted by calling that conversion function, and the result of the conversion is used in place of the original expression. …

to this in the C++14 draft:

Every constant-expression in a noptr-new-declarator shall be a converted constant expression ([expr.const]) of type std::size_t and shall evaluate to a strictly positive value. The expression in a noptr-new-declarator is implicitly converted to std::size_t. …

In C++14 the requirement for the expression in a noptr-new-declarator was weakened to not require an integral, unscoped enumeration or a class with a single non-explicit conversion function to one of those types but just allow implicit conversions to size_t.

The change in wording came from the proposal A Proposal to Tweak Certain C++ Contextual Conversions, v3.

I am dubious about the usefulness of allowing `double` to be used as the size of an array... it seems more likely to let bugs pass silently than anything else :( — Matthieu M., Dec 12 '18 at 15:48
@MatthieuM. I agree, I believe it is a defect and that the intent was really to say `contextually implicitly converted`. I am filing a defect report on this hopefully today but who knows maybe I am wrong :-( — Shafik Yaghmour, Dec 12 '18 at 15:57
@MatthieuM. FYI I filed a defect report, processing takes a while so I don't expect to have an update anytime soon though. — Shafik Yaghmour, Dec 14 '18 at 17:56

score 1 · Answer 2 · edited Jan 10 '19 at 08:42

From c++14 to c++17 (for the ones that wonder like me), the phrasing remains practically the same (unlike from C++11 to C++14 as @ShafikYaghmour answered), as stated in this C++17 draft:

Every constant-expression in a noptr-new-declarator shall be a converted constant expression of type std::size_t and shall evaluate to a strictly positive value. The expression in a noptr-new-declarator is implicitly converted to std::size_t. [..]

with only this part ([expr.const]) missing from the C++17 draft.

In C++14 is it valid to use a double in the dimension of a new expression?

2 Answers2