The "(optional)" marker in cppreference.com documentation

user_7599740 0
Viewed 1221

Last week, I had a discussion with a colleague in understanding the documentation of C++ features on cppreference.com. We had a look at the documentation of the parameter packs, in particular the meaning of the (optional) marker:

Enter image description here

(Another example can be found here.)

I thought it means that this part of the syntax is optional. Meaning I can omit this part in the syntax, but it is always required to be supported by the compiler to comply with the C++ standard. But he stated that it means that it is optional in the standard and that a compiler does not need to support this feature to comply to the standard. Which is it? Both of these explanations make sense to me.

I couldn't find any kind of explanation on the cppreference web site. I also tried to google it but always landed at std::optional...

language-lawyer c++
3 Answers

The opt / (optional) suffix means the symbol is optional [for the C++ programmer to use; not the compiler to support]

As this question has been tagged language-lawyer, and as general when we look for a definite reference, let's move away from CppReference and into the standard.

Where CppReference uses the (optional) subscript, the standard uses opt; e.g. as in [temp.param]/1:

The syntax for template-parameters is:

  • template-parameter:
    • type-parameter
    • parameter-declaration
  • type-parameter:
    • type-parameter-key ...opt identifieropt
    • [... and so on]

[syntax]/1 describe the syntax notation [emphasis mine]:

In the syntax notation used in this document, syntactic categories are indicated by italic type, and literal words and characters in constant width type. Alternatives are listed on separate lines except in a few cases where a long set of alternatives is marked by the phrase “one of”. If the text of an alternative is too long to fit on a line, the text is continued on subsequent lines indented from the first one. An optional terminal or non-terminal symbol is indicated by the subscript “opt", so

  • { expressionopt }

indicates an optional expression enclosed in braces.

Thus, you are correct, and your colleague is wrong. Particularly for your example of template parameter packs (which we introduce by the optional ... after typename) the identifier that follows after typename..., which names the pack (or the template parameter, if ... is omitted), is optional.

But he stated that it means that it is optional in the standard and that a compiler does not need to support this feature to comply to the standard.

The ridiculousness of this claim becomes even more clear if we annotate the "optional permutations" of a class template with a single type template parameter:

template<typename>
      // ^^^^^^^^ type-parameter
      // (omitting optional '...' and 'identifier')
struct S;

template<typename T>
      // ^^^^^^^^^^ type-parameter
      // (omitting optional '...')
struct S;

template<typename...>
      // ^^^^^^^^^^^ type-parameter
      // (omitting optional 'identifier')
struct S;

template<typename... Ts>
      // ^^^^^^^^^^^^^^ type-parameter
struct S;

If the claim above was true, only the first of these four would need to be supported by a compliant implementation (based solely on grammar, in this contrived example), which would mean a compiler vendor could offer a compliant implementation where we could never name neither template (type) parameters nor function parameters.

user_45732470

It means that particular token is optional. For instance both these declarations work:

template <class... Args>
void foo();

template <class...>
void bar();
user_28053050

While I found a page that lists all of the marks, I was unable to find a page that specifies what the marks are intended to mean. Still, I might ask your colleague to take a look at some other pages, with the goal of the colleague abandoning the idea that "optional" means "optional to support". (This is not a definitive argument, but many would find it persuasive.) I found two good examples at Function declaration.

  1. Function declaration:
    noptr-declarator ( parameter-list ) cv(optional) ref(optional) except(optional) attr(optional)
    Focus on cv (short for "const-volatile"), which is marked "optional" and which is "only allowed in non-static member function declarations". Your colleague's interpretation of this marker would mean that compilers do not have to support const member functions, as the const keyword is "optional".

  2. Function definition, the first option for function-body:
    ctor-initializer(optional) compound-statement
    The "optional" part here is the member initializer list (only allowed in constructors). Is your colleague ready to claim that a compiler need not support member initializer lists?

Sometimes one should look at the familiar to understand annotations.

user_98373010
Related