Какой из этих компиляторов имеет ошибку, согласно стандарту?

Учитывая следующий исходный код:

#include <memory>
#include <iostream>

using namespace std;

struct concept
{
    virtual void perform() = 0;
};


struct model : concept, enable_shared_from_this<model>
{
    void perform() override {
        cout << "my pointer is " << shared_from_this().get() << endl;
    }
};

int main(int argc, const char * argv[])
{
    // shared_ptr<concept> concept_ptr = make_shared<model>();
    shared_ptr<concept> concept_ptr { new model };
    concept_ptr->perform();
    return 0;
}

Компиляция под gcc, этот код компилирует и связывает внутренний weak_ptr с адресом model.

В clang код не будет компилироваться (сообщение об ошибке включено в конце)

Если вы замените инициализацию concept_ptr на shared_ptr<concept> concept_ptr = make_shared<model>();, она скомпилируется на обоих.

Что правильно?

изменить:

Моя версия clang - это та, которая поставляется с Xcode:

$ clang --version
Apple LLVM version 5.1 (clang-503.0.40) (based on LLVM 3.4svn)
Target: x86_64-apple-darwin13.3.0
Thread model: posix

edit2:

Просто хотел сказать спасибо всем за вклад. Если вам интересно, причина, по которой я хочу сделать это, - это то, что я хочу непрозрачный интерфейс для реализации с семантикой shared-handle. Некоторые реализации (асинхронные) требуют, чтобы объекты обратного вызова гарантировали, что объект реализации все еще существует (утверждает shared_from_this и weak_ptr::lock). Другие реализации этого не требуют. Я хотел избегать обременения концепции (публичного интерфейса) базовым классом enable_shared_from_this<>, поскольку эта реализация пар с интерфейсом - известное зло.

В большинстве случаев разумно использовать make_shared для создания объекта реализации. В более редких случаях, требующих настраиваемого деструктора, следующее выглядит переносимым:

    auto concept_ptr = static_pointer_cast<concept>(shared_ptr<model> {
                                                        new model ,
                                                        [](model* self) {
                                                            // some_deletion_operation on self;
                                                        } });

Приложение: сообщение об ошибке на clang:

In file included from /Users/richardh/Documents/dev/Scratchpad/tryit/tryit/try2.cpp:1:
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../lib/c++/v1/memory:4013:35: error: no viable overloaded '='
            __e->__weak_this_ = *this;
            ~~~~~~~~~~~~~~~~~ ^ ~~~~~
...etc...

Ответы

Ответ 1

Я понимаю, что libstdС++ более точно соответствует стандарту.

Относительно требований для

shared_ptr<T> shared_from_this(); 
shared_ptr<const T> shared_from_this() const;

оба N3337 §20.7.2.4 (7) и N3936 §20.8.2.5 (7) требуют только

enable_shared_from_this<T> должен быть доступным базовым классом of T. *this должен быть подобъектом объекта T типа T. Там быть хотя бы одним экземпляром shared_ptr p, которому принадлежит &t.

Требование не указано, что один shared_ptr владеющий &t фактически должен быть shared_ptr<T> или shared_ptr<A_to_T_Convertible>.

И эта самая функция является ядром функциональности этого класса.

Таким образом, учитывая Tp как фактический параметр enabled_shared_from_this и Tp1 как фактический параметр того, что владелец shared_ptr, is_convertible<Tp1, Tp>::value == true, не говоря уже о is_same<Tp1, Tp>::value == true, не требуется стандартом, для соответствующих указателей.

И действительно, полный вывод clang++ с использованием libС++ имеет

/usr/local/bin/../include/c++/v1/memory:3997:35: error: no viable overloaded '='
                __e->__weak_this_ = *this;
                ~~~~~~~~~~~~~~~~~ ^ ~~~~~
/usr/local/bin/../include/c++/v1/memory:4035:5: note: in instantiation of
      function template specialization
      'std::__1::shared_ptr<concept>::__enable_weak_this<model>' requested here
    __enable_weak_this(__p);
    ^
[...]enable_shared.cxx:34:25: note: in instantiation
      of function template specialization
      'std::__1::shared_ptr<concept>::shared_ptr<model>' requested here
    shared_ptr<concept> model_ptr1(new model);
                        ^
/usr/local/bin/../include/c++/v1/memory:4942:15: note: candidate function not
      viable: no known conversion from 'std::__1::shared_ptr<concept>' to 'const
      std::__1::weak_ptr<model>' for 1st argument
    weak_ptr& operator=(weak_ptr const& __r) _NOEXCEPT;
              ^
/usr/local/bin/../include/c++/v1/memory:4953:15: note: candidate function not
      viable: no known conversion from 'std::__1::shared_ptr<concept>' to
      'std::__1::weak_ptr<model>' for 1st argument
    weak_ptr& operator=(weak_ptr&& __r) _NOEXCEPT;
              ^
/usr/local/bin/../include/c++/v1/memory:4949:9: note: candidate template
      ignored: could not match 'weak_ptr' against 'shared_ptr'
        operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT;
        ^
/usr/local/bin/../include/c++/v1/memory:4960:9: note: candidate template
      ignored: could not match 'weak_ptr' against 'shared_ptr'
        operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT;
        ^
/usr/local/bin/../include/c++/v1/memory:4967:13: note: candidate template
      ignored: disabled by 'enable_if' [with _Yp = concept]
            is_convertible<_Yp*, element_type*>::value,
            ^

Итак, libС++ здесь хочет

is_convertible<Tp1* /*= Base* = concept**/, Tp* /*= Derived* = model* */>

который, конечно, терпит неудачу здесь, что время выполнения *this этого самого shared_ptr<Tp1> будет dynamic_cast -able до Tp* здесь вне ансатца.

С этой точки зрения также ясно, почему shared_ptr<concept> concept_ptr = make_shared<model>(); не страдает от этого; на rhs существует конструктор shared_ptr<Tp /* = derived = model */> и для этого выполняется ptr is_convertible.

libstdС++ не страдает от этого, поскольку он передает аргумент , таким образом его тип (= Derived = model), конструктора shared_ptr<Tp1 /* = Base = concept*/> до внутреннего назначения weak_ptr<T /*= Derived = model*/>, а не shared_ptr в конструкции.

https://github.com/mirrors/gcc/blob/master/libstdc%2B%2B-v3/include/bits/shared_ptr_base.h#L848

  template<typename _Tp, _Lock_policy _Lp>
    class __shared_ptr
{

https://github.com/mirrors/gcc/blob/master/libstdc%2B%2B-v3/include/bits/shared_ptr_base.h#L858

template<typename _Tp1>
explicit __shared_ptr(_Tp1* __p)
    : _M_ptr(__p), _M_refcount(__p)
{
  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
  static_assert( !is_void<_Tp1>::value, "incomplete type" );
  static_assert( sizeof(_Tp1) > 0, "incomplete type" );
  __enable_shared_from_this_helper(_M_refcount, __p, __p);
}

https://github.com/mirrors/gcc/blob/master/libstdc%2B%2B-v3/include/bits/shared_ptr_base.h#L1459

  template<typename _Tp, _Lock_policy _Lp>
    class __enable_shared_from_this
    {

https://github.com/mirrors/gcc/blob/master/libstdc%2B%2B-v3/include/bits/shared_ptr_base.h#L1482

private:
  template<typename _Tp1>
void
_M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
{ _M_weak_this._M_assign(__p, __n); }


  template<typename _Tp1>
friend void
__enable_shared_from_this_helper(const __shared_count<_Lp>& __pn,
                 const __enable_shared_from_this* __pe,
                 const _Tp1* __px) noexcept
{
  if (__pe != 0)
    __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
}

Только моя точка зрения; комментарии приветствуются.

@Рихард Ходжес: +1, очень интересная тема