Компилятор MSVC2022 не видит конструктор перемещения. (Пикус, CRTP, Policy, type deduction)

@Audeze · Регистрация: 24.12.2022

Студворк — интернет-сервис помощи студентам

Суть проблемы:
Компилятор не видит конструктора перемещения для CRTP шаблона, если этот шаблон создается извлекая типы из шаблона образца, речь идет материале из книги "Пикус Ф. - Идиомы и паттерны проектирования в современном С++ - 2020", глава Перепривязка политики, раздел "Продвинутое проектирование на основе политик", страница 347.
Оригинальный пример не компилируется студией 2022, и я его немного изменил, будут приведены оба варианта мой и оригинал.

Вопросы:
1. Почему компилятор не видит конструктор перемещения.
2. Почему не не компилируется оригинальный вариант.

Пример измененный мной, в котором компилятор не видит конструктор перемещения, детали в комментариях примера.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
// Version 09 with policy rebind
#include <cstdlib>
#include <cassert>
#include <utility>
#include <iostream>
 
template <typename T>
struct DeleteByOperator {
    void operator()(T* p) const {
        delete p;
    }
    template <typename U> using rebind_type = DeleteByOperator<U>;
};
 
template <typename T>
struct DeleteByFree {
    void operator()(T* p) const {
        p->~T();
        free(p);
    }
    template <typename U> using rebind_type = DeleteByFree<U>;
};
 
template <typename T>
struct DeleteDestructorOnly {
    void operator()(T* p) const {
        p->~T();
    }
    template <typename U> using rebind_type = DeleteDestructorOnly<U>;
};
 
class SmallHeap {
public:
    SmallHeap() {}
    ~SmallHeap() {}
    void* allocate(size_t s) {
        assert(s <= size_);
        return mem_;
    }
    void deallocate(void* p) {
        assert(p == mem_);
    }
private:
    static constexpr size_t size_ = 1024;
    char mem_[size_];
    SmallHeap(const SmallHeap&) = delete;
    SmallHeap& operator=(const SmallHeap&) = delete;
};
void* operator new(size_t s, SmallHeap* h) { return h->allocate(s); }
 
template <typename T>
struct DeleteSmallHeap {
    explicit DeleteSmallHeap(SmallHeap& heap)
        : heap_(&heap) {}
    DeleteSmallHeap(const DeleteSmallHeap&) = default;
    DeleteSmallHeap& operator=(const DeleteSmallHeap&) = default;
    DeleteSmallHeap(DeleteSmallHeap&& other)
        : heap_(other.heap_)
    {
        other.heap_ = nullptr;
    }
    void operator()(T* p) const {
        p->~T();
        heap_->deallocate(p);
    }
    template <typename U> using rebind_type = DeleteSmallHeap<U>;
private:
    SmallHeap* heap_;
};
 
class NoMoveNoCopy {
protected:
    NoMoveNoCopy() = default;
    NoMoveNoCopy(NoMoveNoCopy&&) = delete;
    NoMoveNoCopy(const NoMoveNoCopy&) = delete;
    constexpr bool must_delete() const { return true; }
};
 
class MoveNoCopy {
protected:
    MoveNoCopy() = default;
    MoveNoCopy(MoveNoCopy&&) = default;
    MoveNoCopy(const MoveNoCopy&) = delete;
    constexpr bool must_delete() const { return true; }
};
 
class CopyRefCounted {
protected:
    CopyRefCounted() : count_(new size_t(1)) {}
    CopyRefCounted(const CopyRefCounted& other)
        : count_(other.count_)
    {
        ++(*count_);
    }
    ~CopyRefCounted() {
        --(*count_);
        if (*count_ == 0) {
            delete count_;
        }
    }
    bool must_delete() const { return *count_ == 1; }
private:
    size_t* count_;
};
 
template <typename P, typename T>
struct NoRaw {
};
 
template <typename P, typename T>
struct ExplicitRaw {
    explicit operator T* () { return static_cast<P*>(this)->p_; }
    explicit operator const T* () const { return static_cast<const P*>(this)->p_; }
};
 
template <typename P, typename T>
struct ImplicitRaw {
    operator T* () { return static_cast<P*>(this)->p_; }
    operator const T* () const { return static_cast<const P*>(this)->p_; }
};
 
template <typename T,
    typename DeletionPolicy = DeleteByOperator<T>,
    typename CopyMovePolicy = NoMoveNoCopy,
    template <typename, typename> class ConversionPolicy = ExplicitRaw
>
class SmartPtr : private DeletionPolicy,
    public CopyMovePolicy,
    public ConversionPolicy<SmartPtr<T, DeletionPolicy, CopyMovePolicy, ConversionPolicy>, T>
{
private:    
    template <typename P, typename T1>
    friend class ImplicitRaw;
    //friend class ImplicitRaw<SmartPtr<T, DeletionPolicy, CopyMovePolicy, ConversionPolicy>, T>;
 
    template <typename P, typename T1>
    friend class ExplicitRaw;     
    //friend class ExplicitRaw<SmartPtr<T, DeletionPolicy, CopyMovePolicy, ConversionPolicy>, T>;
    
public:
    using value_t = T;
    using deletion_policy_t = DeletionPolicy;
    using copy_move_policy_t = CopyMovePolicy;    
    
    template <typename P, typename T1> 
    using conversion_policy_t = ConversionPolicy<P, T1>;   
    
    explicit SmartPtr(T* p = nullptr,
        DeletionPolicy&& deletion_policy = DeletionPolicy()
    ) : DeletionPolicy(std::move(deletion_policy)),
        p_(p)
    {}
 
    
    SmartPtr(SmartPtr&& other) noexcept
        : DeletionPolicy(std::move(other)),
        CopyMovePolicy(std::move(other)),
        p_(other.p_)
    {
        std::cout << "Move\n";
        other.release();
    }
 
    SmartPtr(const SmartPtr& other)
        : DeletionPolicy(other),
        CopyMovePolicy(other),
        p_(other.p_)
    {
        std::cout << "Copy\n";
    }
 
    ~SmartPtr() {
        if (CopyMovePolicy::must_delete()) DeletionPolicy::operator()(p_);
    }
 
    void release() { p_ = NULL; }
    T* operator->() { return p_; }
    const T* operator->() const { return p_; }
    T& operator*() { return *p_; }
    const T& operator*() const { return *p_; }
 
    // переопределеляем тип
    // все так же как раньше просто менямем тип скажем с int на double
    template <typename U> using rebind_type = SmartPtr<U, typename DeletionPolicy::template rebind_type<U>, CopyMovePolicy, ConversionPolicy>;
 
    
protected:
    T* p_;
 
private:
    // оба этих варианта не компилирутся
    //template<typename, typename> friend class ConversionPolicy;    
    //friend class ConversionPolicy<SmartPtr<T, DeletionPolicy, CopyMovePolicy, ConversionPolicy>, T>;    
};
 
int main() {
    {
        SmartPtr<int, DeleteByOperator<int>, MoveNoCopy, ImplicitRaw> p(new int(42));
        std::cout << *p << std::endl;
        auto p1(std::move(p));
        std::cout << *p1 << std::endl;
        int* p2(p1);
        std::cout << *p2 << std::endl;
 
        using dptr_t = decltype(p)::rebind_type<double>;
        dptr_t q(new double(4.2));
        std::cout << *q << std::endl;
        auto q1(std::move(q));
        std::cout << *q1 << std::endl;
        double* q2(q1);
        std::cout << *q2 << std::endl;
    }
    
    {
        // а так все работает        
        // донор политик        
        SmartPtr<int, DeleteByOperator<int>, MoveNoCopy, ImplicitRaw> p(new int(7));
 
        SmartPtr<int, DeleteByOperator<int>, MoveNoCopy, ImplicitRaw> q(std::move(p));
        /*
        SmartPtr<int, DeleteByOperator<int>, MoveNoCopy, ImplicitRaw> q(std::move(p));
        00007FF782D124DE  mov         edx,10h
        00007FF782D124E3  lea         rcx,[rbp+138h]
        00007FF782D124EA  call        SmartPtr<int,DeleteByOperator<int>,MoveNoCopy,ImplicitRaw>::__autoclassinit2 (07FF782D11DD0h)
        00007FF782D124EF  lea         rcx,[rbp+108h]
 
        как и должно быть sdt::move
        00007FF782D124F6  call        std::move<SmartPtr<int,DeleteByOperator<int>,MoveNoCopy,ImplicitRaw> &> (07FF782D11550h)
 
        запуск конструктора перемещения
        00007FF782D124FB  mov         rdx,rax
        00007FF782D124FE  lea         rcx,[rbp+138h]
        00007FF782D12505  call        SmartPtr<int,DeleteByOperator<int>,MoveNoCopy,ImplicitRaw>::SmartPtr<int,DeleteByOperator<int>,MoveNoCopy,ImplicitRaw> (07FF782D115B0h)
        00007FF782D1250A  nop
        std::cout << *q << std::endl;
       */
        std::cout << *q << std::endl;
    }
 
    {
        // не работает
        // донор политик        
        SmartPtr<int, DeleteByOperator<int>, MoveNoCopy, ImplicitRaw> p(new int(7));
     
        
        // SmartPtr<int, DeleteByOperator<int>, MoveNoCopy, NoRaw> p(new int(7)); 
        // если попробовать сделать так, то это будет приводить к ошибке на SmartPtr<ptr_t::value_t, ptr_t::deletion_policy_t, ptr_t::copy_move_policy_t, ptr_t::conversion_policy_t> q(std::move(p));
        // так как почемуто конструктор перемещения не видим компилятором
        // Error    C2664   'SmartPtr<int,DeleteByOperator<int>,MoveNoCopy,SmartPtr<int,DeleteByOperator<int>,MoveNoCopy,NoRaw>::conversion_policy_t>::SmartPtr(T *,DeletionPolicy &&)': cannot convert argument 1 from 'SmartPtr<int,DeleteByOperator<int>,MoveNoCopy,NoRaw>' to 'T *'
        
        // извлекаем политики, и создаем похожий класс
        using ptr_t = decltype(p);
        // ошибка при использовании сохраненных типов
        // почему то невидим конструктор перемещения, и после мува(р) идет получение уаказателя ImplicitRaw и запуск основного конструктора
        //  здесь возможно срабатывает оптимизация и вместо конструктора перемещение запускается обычный конструктор        
        SmartPtr<ptr_t::value_t, ptr_t::deletion_policy_t, ptr_t::copy_move_policy_t, ptr_t::conversion_policy_t> q(std::move(p));
        
        /* 
         SmartPtr<ptr_t::value_t, ptr_t::deletion_policy_t, ptr_t::copy_move_policy_t, ptr_t::conversion_policy_t> q(std::move(p));
        00007FF61EB6354E  mov         edx,10h  
        00007FF61EB63553  lea         rcx,[rbp+138h]  
        00007FF61EB6355A  call        SmartPtr<int,DeleteByOperator<int>,MoveNoCopy,SmartPtr<int,DeleteByOperator<int>,MoveNoCopy,ImplicitRaw>::conversion_policy_t>::__autoclassinit2 (07FF61EB614A6h)  
        
        мув
        00007FF61EB6355F  lea         rcx,[rbp+108h]  
        00007FF61EB63566  call        std::move<SmartPtr<int,DeleteByOperator<int>,MoveNoCopy,ImplicitRaw> & __ptr64> (07FF61EB61537h)  
 
        вот тут начитаются проблемы
 
        получает указатель у перемещенного класса
        00007FF61EB6356B  add         rax,2  
        00007FF61EB6356F  mov         rcx,rax  
        00007FF61EB63572  call        ImplicitRaw<SmartPtr<int,DeleteByOperator<int>,MoveNoCopy,ImplicitRaw>,int>::operator int * __ptr64 (07FF61EB61136h)  
 
        запускает explicit SmartPtr(T* p = nullptr,
        00007FF61EB63577  lea         r8,[rbp+3A4h]  
        00007FF61EB6357E  mov         rdx,rax  
        00007FF61EB63581  lea         rcx,[rbp+138h]  
        00007FF61EB63588  call        SmartPtr<int,DeleteByOperator<int>,MoveNoCopy,SmartPtr<int,DeleteByOperator<int>,MoveNoCopy,ImplicitRaw>::conversion_policy_t>::SmartPtr<int,DeleteByOperator<int>,MoveNoCopy,SmartPtr<int,DeleteByOperator<int>,MoveNoCopy,ImplicitRaw>::conversion_policy_t> (07FF61EB61375h)  
        00007FF61EB6358D  nop  
        Все это естественно приведет к двойному удалению памяти и к исключению.
        Что не так с извлеченными типами? судя по ассемблерному листингу они были извлечены верно(00007FF61EB6355A  call        SmartPtr<int,DeleteByOperator<int>,MoveNoCopy,SmartPtr<int,DeleteByOperator<int>,MoveNoCopy,ImplicitRaw>)
        */
 
        std::cout << *q << std::endl;       
    }    
}

Оригинальный код, не компилируется MSVC2022

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
// Version 09 with policy rebind
#include <cstdlib>
#include <cassert>
#include <utility>
#include <iostream>
 
template <typename T>
struct DeleteByOperator {
    void operator()(T* p) const {
        delete p;
    }
    template <typename U> using rebind_type = DeleteByOperator<U>;
};
 
template <typename T>
struct DeleteByFree {
    void operator()(T* p) const {
        p->~T();
        free(p);
    }
    template <typename U> using rebind_type = DeleteByFree<U>;
};
 
template <typename T>
struct DeleteDestructorOnly {
    void operator()(T* p) const {
        p->~T();
    }
    template <typename U> using rebind_type = DeleteDestructorOnly<U>;
};
 
class SmallHeap {
    public:
    SmallHeap() {}
    ~SmallHeap() {}
    void* allocate(size_t s) {
        assert(s <= size_);
        return mem_;
    }
    void deallocate(void* p) {
        assert(p == mem_);
    }
    private:
    static constexpr size_t size_ = 1024;
    char mem_[size_];
    SmallHeap(const SmallHeap&) = delete;
    SmallHeap& operator=(const SmallHeap&) = delete;
};
void* operator new(size_t s, SmallHeap* h) { return h->allocate(s); }
 
template <typename T>
struct DeleteSmallHeap {
    explicit DeleteSmallHeap(SmallHeap& heap)
        : heap_(&heap) {}
    DeleteSmallHeap(const DeleteSmallHeap&) = default;
    DeleteSmallHeap& operator=(const DeleteSmallHeap&) = default;
    DeleteSmallHeap(DeleteSmallHeap&& other)
        : heap_(other.heap_)
    {
        other.heap_ = nullptr;
    }
    void operator()(T* p) const {
        p->~T();
        heap_->deallocate(p);
    }
    template <typename U> using rebind_type = DeleteSmallHeap<U>;
    private:
    SmallHeap* heap_;
};
 
class NoMoveNoCopy {
    protected:
    NoMoveNoCopy() = default;
    NoMoveNoCopy(NoMoveNoCopy&&) = delete;
    NoMoveNoCopy(const NoMoveNoCopy&) = delete;
    constexpr bool must_delete() const { return true; }
};
 
class MoveNoCopy {
    protected:
    MoveNoCopy() = default;
    MoveNoCopy(MoveNoCopy&&) = default;
    MoveNoCopy(const MoveNoCopy&) = delete;
    constexpr bool must_delete() const { return true; }
};
 
class CopyRefCounted {
    protected:
    CopyRefCounted() : count_(new size_t(1)) {}
    CopyRefCounted(const CopyRefCounted& other)
        : count_(other.count_)
    {
        ++(*count_);
    }
    ~CopyRefCounted() {
        --(*count_);
        if (*count_ == 0) {
            delete count_;
        }
    }
    bool must_delete() const { return *count_ == 1; }
    private:
    size_t* count_;
};
 
template <typename P, typename T>
struct NoRaw {
};
 
template <typename P, typename T>
struct ExplicitRaw {
    explicit operator T*() { return static_cast<P*>(this)->p_; }
    explicit operator const T*() const { return static_cast<const P*>(this)->p_; }
};
 
template <typename P, typename T>
struct ImplicitRaw {
    operator T*() { return static_cast<P*>(this)->p_; }
    operator const T*() const { return static_cast<const P*>(this)->p_; }
};
 
template <typename T,
          typename DeletionPolicy = DeleteByOperator<T>,
          typename CopyMovePolicy = NoMoveNoCopy,
          template <typename, typename> class ConversionPolicy = ExplicitRaw
         >
class SmartPtr : private DeletionPolicy,
                 public CopyMovePolicy,
                 public ConversionPolicy<SmartPtr<T, DeletionPolicy, CopyMovePolicy, ConversionPolicy>, T>
{
    public:
    using value_t = T;
    using deletion_policy_t = DeletionPolicy;
    using copy_move_policy_t = CopyMovePolicy;
    template <typename P, typename T1> using conversion_policy_t = ConversionPolicy<P, T1>;
    explicit SmartPtr(T* p = nullptr,
                      DeletionPolicy&& deletion_policy = DeletionPolicy()
        ) : DeletionPolicy(std::move(deletion_policy)),
            p_(p)
    {}
    SmartPtr(SmartPtr&& other)
        : DeletionPolicy(std::move(other)),
          CopyMovePolicy(std::move(other)),
          p_(other.p_)
    {
        other.release();
    }
    SmartPtr(const SmartPtr& other)
        : DeletionPolicy(other),
          CopyMovePolicy(other),
          p_(other.p_)
    {
    }
    ~SmartPtr() {
        if (CopyMovePolicy::must_delete()) DeletionPolicy::operator()(p_);
    }
    void release() { p_ = NULL; }
    T* operator->() { return p_; }
    const T* operator->() const { return p_; }
    T& operator*() { return *p_; }
    const T& operator*() const { return *p_; }
 
    template <typename U> using rebind_type = SmartPtr<U, typename DeletionPolicy::template rebind_type<U>, CopyMovePolicy, ConversionPolicy>;
    private:
    template<typename, typename> friend class ConversionPolicy;
    T* p_;
};
 
int main() {
    {
        SmartPtr<int, DeleteByOperator<int>, MoveNoCopy, ImplicitRaw> p(new int(42));
        std::cout << *p << std::endl;
        auto p1(std::move(p));
        std::cout << *p1 << std::endl;
        int* p2(p1);
        std::cout << *p2 << std::endl;
 
        using dptr_t = decltype(p)::rebind_type<double>;
        dptr_t q(new double(4.2));
        std::cout << *q << std::endl;
        auto q1(std::move(q));
        std::cout << *q1 << std::endl;
        double* q2(q1);
        std::cout << *q2 << std::endl;
    }
 
    {
        SmartPtr<int, DeleteByOperator<int>, MoveNoCopy, ImplicitRaw> p(new int(7));
        using ptr_t = decltype(p);
        SmartPtr<ptr_t::value_t, ptr_t::deletion_policy_t, ptr_t::copy_move_policy_t, ptr_t::conversion_policy_t> q(std::move(p));
        std::cout << *q << std::endl;
    }
}

PS.
Не в новичковом разделе так как книга позиционируется как не для начинающих.

@zayats80888 · 25.12.2022, 13:13

Сообщение от Audeze

1. Почему компилятор не видит конструктор перемещения.

Потому что типы объектов p и q различны, а конструктор перемещения только для одинаковых типов определен.
А различны они потому, что алиас шаблона фактически объявляет новое имя шаблона.
Простой пример:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <type_traits>
 
template<class T> struct S{};
 
template<class T>
using AliasS = S<T>;
 
template<template<class> class TT>
struct TemplateId{};
 
int main()
{
    static_assert(std::is_same_v<TemplateId<S>, TemplateId<AliasS>>, "not gcc will fail");
}

Если в качестве шаблонного параметра шаблона указать один и тот же идентификатор, то всё будет работать:

Сообщение от Audeze

SmartPtr<ptr_t::value_t, ptr_t::deletion_policy_t, ptr_t::copy_move_policy_t, ptr_t::conversion_policy_t> q(std::move(p))

->

C++
1
SmartPtr<ptr_t::value_t, ptr_t::deletion_policy_t, ptr_t::copy_move_policy_t, ImplicitRaw> q(std::move(p));

Сообщение от Audeze

2. Почему не не компилируется оригинальный вариант.

Примерно по той же причине. Я не знаю как зафрендить алиас шаблона.
Однако полную специализацию алиаса можно зафрендить:

Сообщение от Audeze

// оба этих варианта не компилирутся
//template<typename, typename> friend class ConversionPolicy;
//friend class ConversionPolicy<SmartPtr<T, DeletionPolicy, CopyMovePolicy, ConversionPolicy>, T>;

->
У второго варианта уберите ключевое слово class, должно компилироваться.
Делать друзьями все специализации тут не требуется.
А для первого варианта ConversionPolicy не должен быть алиасом или параметром шаблона.

@Audeze · 25.12.2022, 17:53 **[ТС]**

Благодарю за разъяснение.

Сообщение от zayats80888

У второго варианта уберите ключевое слово class, должно компилироваться.

А чем мешает class? Без него и правда все работает.

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

Что посоветуете прочитать? Я, явно плохо ориентируюсь в вопросе.

@zayats80888 · 25.12.2022, 18:12

Сообщение от Audeze

А чем мешает class? Без него и правда все работает.

Вот тут подробно: https://www.open-std.org/jtc1/... /n1791.pdf

Сообщение от Audeze

Я так понял что у Пикуса не было проблем

Компилятор компилирует этот код и пример мой тоже (хотя не должен).

Добавлено через 1 минуту

Сообщение от Audeze

Что посоветуете прочитать? Я, явно плохо ориентируюсь в вопросе.

В таких деталях только стандарт поможет разобраться (и то не всегда).

@Audeze · 25.12.2022, 19:06 **[ТС]**

Сообщение от zayats80888

Вот тут подробно: https://www.open-std.org/jtc1/... /n1791.pdf

Ох и тяжким там языком написано.
Но как я понял elaborated-type-specifier должен использоваться для классов о которых пока ничего не известно, а во всех остальных случаях
friend simple-type-specifier ;
friend typename-specifier ;
Хотя понял это наверное не то слово, тут скорее принял что делай вот так потому что потому.
А есть какие то внятные труды объясняющие стандарт? что бы извлекать понимание сути из справочников нужно уже быть очень хорошо погруженным в тему, иначе это экстрим какой то. Речь про именно понять.

Добавлено через 25 минут
Да вот кстати а как грамотно решить эту задачу с извлечением типа из объекта донора?
SmartPtr<ptr_t::value_t, ptr_t::deletion_policy_t, ptr_t::copy_move_policy_t, ImplicitRaw> q(std::move(p));
это ведь не решение, мы же не можем знать что там ImplicitRaw.

@zayats80888 · 25.12.2022, 19:16

Сообщение от Audeze

Но как я понял elaborated-type-specifier должен использоваться для классов о которых пока ничего не известно, а во всех остальных случаях

Не, суть в том, что когда вы в 256 строке инстанцировали SmartPtr с ptr_t::conversion_policy_t, то elaborated-type-specifier не мог применятся к алиасу. Если заменить ptr_t::conversion_policy_t на имя шаблона класса, как я писал, то скомпилируется и с ключевым словом class.

Сообщение от Audeze

А есть какие то внятные труды объясняющие стандарт?

Я не знаю, не читал ничего такого, где бы разжевывались простым языком эти тонкости...

Сообщение от Audeze

Да вот кстати а как грамотно решить эту задачу с извлечением типа из объекта донора?
SmartPtr<ptr_t::value_t, ptr_t::deletion_policy_t, ptr_t::copy_move_policy_t, ImplicitRaw> q(std::move(p));
это ведь не решение, мы же не можем знать что там ImplicitRaw.

Проблема в том, что это не тип, а шаблон типа.
Можно извлечь только его специализацию, чтоб она "ссылалась" на тот же тип.
Но это тут ничем не поможет.

@Audeze · 25.12.2022, 19:55 **[ТС]**

Сообщение от zayats80888

Не, суть в том, что когда вы в 256 строке инстанцировали SmartPtr с ptr_t::conversion_policy_t, то elaborated-type-specifier не мог применятся к алиасу. Если заменить ptr_t::conversion_policy_t на имя шаблона класса, как я писал, то скомпилируется и с ключевым словом class.

В тот пдф стоило бы добавить:

class C {};
typedef C Ct;
....

class X3 {
friend class C;
};

class X4 {
friend class Ct; // Error C2371 'Ct': redefinition; different basic types
};

Книгу что ли написать про стандарт

@SmallEvil · 26.12.2022, 17:46

Сообщение от Audeze

Книгу что ли написать про стандарт

Он (стандарт) слишком быстро меняется, что бы по нему писать книги.

Новые блоги и статьи Все статьи Все блоги /
Символические и жёсткие ссылки в Linux. algri14 15.03.2026 Существует два типа ссылок — символические и жёсткие. Ссылка в Linux — это дополнительная запись в каталоге, которая может указывать либо на inode «файла-ИСТОЧНИКА», тогда это будет «жёсткая. . .	[Owen Logic] Поддержание уровня воды в резервуаре количеством включённых насосов: моделирование и выбор регулятора ФедосеевПавел 14.03.2026 Поддержание уровня воды в резервуаре количеством включённых насосов: моделирование и выбор регулятора ВВЕДЕНИЕ Выполняя задание на управление насосной группой заполнения резервуара,. . .	делаю науч статью по влиянию грибов на сукцессию anaschu 13.03.2026 прикрепляю статью	SDL3 для Desktop (MinGW): Создаём пустое окно с нуля для 2D-графики на SDL3, Си и C++ 8Observer8 10.03.2026 Содержание блога Финальные проекты на Си и на C++: hello-sdl3-c. zip hello-sdl3-cpp. zip Результат:
Установка CMake и MinGW 13.1 для сборки С и C++ приложений из консоли и из Qt Creator в EXE 8Observer8 10.03.2026 Содержание блога MinGW - это коллекция инструментов для сборки приложений в EXE. CMake - это система сборки приложений. Здесь описаны базовые шаги для старта программирования с помощью CMake и. . .	Как дизайн сайта влияет на конверсию: 7 решений, которые реально повышают заявки Neotwalker 08.03.2026 Многие до сих пор воспринимают дизайн сайта как “красивую оболочку”. На практике всё иначе: дизайн напрямую влияет на то, оставит человек заявку или уйдёт через несколько секунд. Даже если у вас. . .	Модульная разработка через nuget packages DevAlt 07.03.2026 Сложившийся в . Net-среде способ разработки чаще всего предполагает монорепозиторий в котором находятся все исходники. При создании нового решения, мы просто добавляем нужные проекты и имеем. . .	Модульный подход на примере F# DevAlt 06.03.2026 В блоге дяди Боба наткнулся на такое определение: В этой книге («Подход, основанный на вариантах использования») Ивар утверждает, что архитектура программного обеспечения — это структуры,. . .

Компилятор MSVC2022 не видит конструктор перемещения. (Пикус, CRTP, Policy, type deduction)

Решение