Что приняли в C++17, фотография Бьярне Страуструпа и опрос для C++20

Он очень красивый (нет)

    explicit vector(size_type _Count)
        : _Mybase()
        {   // construct from _Count * value_type()
        if (_Buy(_Count))
            {   // nonzero, fill it
            _Alty _Alval(this->_Getal());
            _TRY_BEGIN
            _Uninitialized_default_fill_n(this->_Myfirst, _Count, _Alval);
            this->_Mylast += _Count;
            _CATCH_ALL
            _Tidy();
            _RERAISE;
            _CATCH_END
            }
        }

Он классный (нет)

    iterator _Insert_n(const_iterator _Where,
        size_type _Count, const value_type& _Val)
        {   // insert _Count * _Val at _Where
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_VICONT(_Where) != this
            || _VIPTR(_Where) < this->_Myfirst
            || this->_Mylast < _VIPTR(_Where))
            _DEBUG_ERROR("vector insert iterator outside range");
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        size_type _Off = _VIPTR(_Where) - this->_Myfirst;
        if (_Count == 0)
            ;
        else if (_Unused_capacity() < _Count)
            {   // not enough room, reallocate
            if (max_size() - size() < _Count)
                _Xlen();    // result too long

            size_type _Capacity = _Grow_to(size() + _Count);
            pointer _Newvec = this->_Getal().allocate(_Capacity);
            size_type _Whereoff = _VIPTR(_Where) - this->_Myfirst;
            int _Ncopied = 0;

            _TRY_BEGIN
            _Ufill(_Newvec + _Whereoff, _Count,
                _STD addressof(_Val));  // add new stuff
            ++_Ncopied;
            _Umove(this->_Myfirst, _VIPTR(_Where),
                _Newvec);   // copy prefix
            ++_Ncopied;
            _Umove(_VIPTR(_Where), this->_Mylast,
                _Newvec + (_Whereoff + _Count));    // copy suffix
            _CATCH_ALL
            if (1 < _Ncopied)
                _Destroy(_Newvec, _Newvec + _Whereoff);
            if (0 < _Ncopied)
                _Destroy(_Newvec + _Whereoff, _Newvec + _Whereoff + _Count);
            this->_Getal().deallocate(_Newvec, _Capacity);
            _RERAISE;
            _CATCH_END

            _Count += size();
            if (this->_Myfirst != pointer())
                {   // destroy and deallocate old array
                _Destroy(this->_Myfirst, this->_Mylast);
                this->_Getal().deallocate(this->_Myfirst,
                    this->_Myend - this->_Myfirst);
                }

            this->_Orphan_all();
            this->_Myend = _Newvec + _Capacity;
            this->_Mylast = _Newvec + _Count;
            this->_Myfirst = _Newvec;
            }
        else if ((size_type)(this->_Mylast - _VIPTR(_Where))
            < _Count)
            {   // new stuff spills off end
            value_type _Tmp = _Val; // in case _Val is in sequence

            _Umove(_VIPTR(_Where), this->_Mylast,
                _VIPTR(_Where) + _Count);   // copy suffix

            _TRY_BEGIN
            _Ufill(this->_Mylast,
                _Count - (this->_Mylast - _VIPTR(_Where)),
                _STD addressof(_Tmp));  // insert new stuff off end
            _CATCH_ALL
            _Destroy(_VIPTR(_Where) + _Count,
                this->_Mylast + _Count);
            _RERAISE;
            _CATCH_END

            this->_Mylast += _Count;
            _Orphan_range(_VIPTR(_Where), this->_Mylast);
            _STD fill(_VIPTR(_Where), this->_Mylast - _Count,
                _Tmp);  // insert up to old end
            }
        else
            {   // new stuff can all be assigned
            value_type _Tmp = _Val; // in case _Val is in sequence

            pointer _Oldend = this->_Mylast;
            this->_Mylast = _Umove(_Oldend - _Count, _Oldend,
                this->_Mylast); // copy suffix

            _Orphan_range(_VIPTR(_Where), this->_Mylast);
            _Copy_backward(_VIPTR(_Where), _Oldend - _Count,
                _Oldend);   // copy hole
            _STD fill(_VIPTR(_Where),
                _VIPTR(_Where) + _Count, _Tmp); // insert into hole
            }
        return (begin() + _Off);
        }

те, кто не знает, как должен выглядеть нормальный читаемый код, могут минусовать дальше. я переживу.

А эта красота работает только для нескольких стандартных классов? Или пользовательские тоже смогут?

Концепты с двусторонними последствиями (т.е. бьют по рукам и вызывающий код, и за непредусмотренный юз в теле ф-ции). Мечты, мечты...

Эти функции вошли в основном потому, что они уже как 18 лет есть в С. И рассинхронизацию надо было устранять.

Для начала хотелось бы концепты. Причём не лайт, с ограничением только "наружу", но и с ограничением "внутрь".

@antoshkka А что с C#? Имхо 99% всей сложности языка из-за макросов существуют. А шарп 2.0 от шарпа 7.0 для пользователя отличается только незначительным сахаром. Ну там, свойства можно инициализировать не в конструкторе, а прямо при объявлении, да экстеншн-методы пописывать… Самое сложное, что есть в языке — yield и async/await, ни в какое сравнение со сложностями плюсов не идет. Да, системы усложняются, появляются фреймворки, все такое… Но сама база не меняется никогда. И это очень серьезно ограничивает сложность: нетрудно разобраться с любым бизнес-фреймворком, если каждый элемент по-отдельности понятен и не изменился с момента академической юности.