is there a distinction between single prefixed underscore and double prefixed underscore in the C++ STL implementation?

Question

I am asking this question for readability reasons not for implementation.

I haven't found any article explaining any distinction between single prefixed underscore and double prefixed underscore or double prefix and suffix if any.

Is there a special meaning between these different styles that will help with readability? They seem random. Example 1 has all the variables to be only single prefix but then example 2 has the variables double prefixed.

1. _single

using type = _Template<_Up, _Types...>;

2. __double

struct __replace_first_arg

3. __ prefixAndSuffixUnderscore__

namespace std __attribute__((__visibility__("default")))

From the c++ STL container

e.g: 1

namespace std __attribute__((__visibility__("default")))
{

  class __undefined;

  template <typename _Tp, typename _Up>
  struct __replace_first_arg
  {
  };

  template <template <typename, typename...> class _Template, typename _Up,
            typename _Tp, typename... _Types>
  struct __replace_first_arg<_Template<_Tp, _Types...>, _Up>
  {
    using type = _Template<_Up, _Types...>;
  };

e.g: 2

  template <typename _InputIterator, typename _Distance>
  inline constexpr void
  __advance(_InputIterator & __i, _Distance __n, input_iterator_tag)
  {

    do
    {
      if (__builtin_is_constant_evaluated() && !bool(__n >= 0))
        __builtin_unreachable();
    } while (false);
    while (__n--)
      ++__i;
  }

I have read about the conventions for avoiding prefixed underscores in c++ to avoid collision with names inside the STL headers like global macros objects etc. This is not my question.

Ive tried: https://pubs.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_02.html

What are the rules about using an underscore in a C++ identifier?

https://manual.gromacs.org/5.1.1/dev-manual/naming.html

Prefix try keyword with two underscore in c++

etc...

Answer 1

Is there a distinction between __lower_case names and _TitleCase names in a standard library implementation?

• Yes, in the essentially uninteresting sense that they're different names, just like any other names that don't consist of the same characters.

• Yes, in the sense that some coding style guide may reserve each for different purposes.

• No, in the sense that nothing about either of the first two senses is special to either names reserved for the implementation or the standard library.

There isn't a single standard library implementation. If your question is about why a given implementation chooses __lower_case for functions and _TitleCase for types, that's a question for that particular implementation's style guide.

The reason that every implementation will prefer identifiers of (one or both of) those two forms is that they're reserved for the implementation.

Your claim that you aren't using any implementation is nonsense: if it compiles, it is an implementation. The standard only specifies an interface and some constraints.

Oh, and the standard library, whether we're discussing the specification or an implementation, is not the STL. The Standard Template Library was an influential precursor to the library incorporated into the first C++ standard in 1998.