Russian Qt Forum

/opt/Library/GSL/include/gsl/pointers:81: error: use of deleted function ‘std::unique_ptr<_Tp, _Dp>::unique_ptr(const std::unique_ptr<_Tp, _Dp>&) [with _Tp = int; _Dp = std::default_delete<int>]’
   81 |     constexpr not_null(T u) : ptr_(u)
      |                                     ^

not_null<unique_ptr<int>> p(make_unique(42));
p.get().release(); // oops контракт нарушен

unique_ptr<int> p = foo();
p.release(); // ok
bar(move(p)); // ok

const unique_ptr<int> p = foo();
p.release(); // !ok, не скомпилится, хорошо
bar(move(p)); // тоже !ok, а вот это было бы неплохо скомпилить

struct child
{
    child(parent& object) noexcept
        : m_parent(&object)
    {}

    parent& getParent() noexcept
    {
         return *this->m_parent;
    }

    void setParent(parent& object) noexcept
    {
        this->m_parent = &parent;
    }
    void work()
    {
         // указатель  this->m_parent априори валидный
    }
private:
    parent* m_parent;
};

class Foo
{
public:
    using BarPtr = std::unique_ptr<Bar>;
    void setBar(BarPtr bar) { m_bar = std::move(bar); }
    void doBaz() { m_bar->baz(); }

    BarPtr m_bar;
};

class Foo
{
    using BarPtr = std::shared_ptr<Bar>; // поменялось раз
    void setBar(BarPtr bar) { m_bar = std::move(bar); }
    void doBaz() { m_bar->baz(); }

    BarPtr m_bar;
};

class Foo
{
public:
    void setBar(Bar &&bar) { m_bar = std::move(bar); }
    void doBaz() { m_bar.baz(); }
private:
    Bar m_bar;
};

class Foo
{
    using BarPtr = std::shared_ptr<Bar>; // добавилось 
    void setBar(BarPtr bar) { m_bar = std::move(bar); } // поменялось раз
    void doBaz() { m_bar->baz(); } // поменялось два (точка на ->)

    BarPtr m_bar; // поменялось три
};

son.setParents(&parent{"Stepanida"}, &parent{"Stepan"});

auto* object = api::create();
assert(object);
work(*object);   // <--- это так сложно?

    namespace detail
    {
        template<class s, dfor_lvalue_string(s&&)> 
        constexpr decltype(auto) c_str(s&& text) noexcept 
            { return text.c_str(); }

        template<class s, dfor_array_of_symbols(s)>
        constexpr decltype(auto) c_str(const s& arr) noexcept
            { return arr; }

        template<class s, dfor_pointer_to_symbol(s)>
        constexpr auto c_str(const s& ptr) noexcept -> const auto*
        { 
            assert(ptr);
            return ptr;
        }

    } //namespace detail

    son.setParents(mother, parent{"Stepan"}); // <--- rvalue and lvalue

#include <iostream>
#include <string>

struct parent
{
    parent(const std::string& n)
        : name(n)
    {
        std::cout << "parent(" << name << "): was built\n";
    }
    
    ~parent()
    {
        std::cout << "parent(" << name << "): was destroyed\n";
    }
    std::string name;
};

struct child
{
    
    template<class parent>
    child(parent&& mother, parent&& father) noexcept
        : m_mother(), m_father()
    {
        this->setParents(
            ::std::forward<parent>(mother),
            ::std::forward<parent>(father)
        );
    }

    const parent& getMother() noexcept { return *this->m_mother; }
    const parent& getFather() noexcept { return *this->m_father; }

    void setParents(parent&& mother, parent&& father) noexcept = delete;
    void setParents(const parent& mother, const parent& father) noexcept
    {
        this->m_mother = &mother;
        this->m_father = &father;
    }

    void work()
    {
        std::cout << "mother: " << getMother().name << std::endl;
        std::cout << "father: " << getFather().name << std::endl;
    }

private:
    const parent* m_mother;
    const parent* m_father;
};

int main()
{
    parent mother{"Marfa"};
    parent father{"Miron"};

    child  son{mother, father};
    son.work();

    son.setParents(mother, parent{"Stepan"}); // <--- rvalue and lvalue
    son.work();

    return 0;
}

bool filterFoo(const Foo &foo) { ... } // ну ок, тут ссылка по делу
void processFoo(shared_ptr<Foo> foo)
{
    // вот вы предлагаете перед разыменованием проверять, ну ок, вполне себе подход
    if (!foo)
       return;
    // ну разыменовали, никакого UB, всё круто
    if (filterFoo(*foo))
       return;
    // чтобы понятно, почему нельзя заюзать ссылку изначально, форвардим сигналом дальше, скажем, в иной тред
    // ну или в мапу кладем
    emit fooProcessed(foo);
}

bool filterFoo(const Foo &foo) { ... }
void processFoo(not_null<shared_ptr<Foo>> foo)
{
    if (filterFoo(*foo)) // оппа, это больше не UB!
       return;
    ....
}

shared_ptr<Foo> foo = getFoo();
processFoo(foo); // ooops!

# * &
0 + - // перегрузка операторов доступа содержимому объекта
1 + - // "умные" классы (следствие 0)
2 + - // возможность задавать семантику владения (следствие 1)
3 + - // опциональность (занулябельность), решается для ссылок типа optional<ref<T>>
4 - + // занулябельность, решается для указателей типа not_null<smart_ptr<T>>

struct base
{
    virtual ~base(){}
    virtual void foo(int&) = 0;
    virtual void foo(int&&) = delete;
};

node.setParents(mother, father);

node.setParents(&mother, &father);

#include <iostream>

struct node
{
    virtual ~node(){}
    
    template<class parent1, class parent2>
    void setParents(parent1&& mother, parent2&& father) 
    {
        static_assert(
            !::std::is_rvalue_reference<parent1&&>::value,
            "temporary objects 'mother' prohibited"
        );
        static_assert(
            !::std::is_rvalue_reference<parent2&&>::value,
            "temporary objects 'father' prohibited"
        );
        const auto& m = static_cast<const node&>(mother);
        const auto& f = static_cast<const node&>(father);
        this->setParents(m, f);
    }    
    virtual void setParents(const node& mother, const node& father) = 0;
};

struct label: node
{
    virtual void setParents(const node&, const node&){}
};
 
int main()
{
    label mother;
    label father;
    label child;
    node& example = child;
    
    example.setParents(mother, father);
}

#include <iostream>

struct node
{
    virtual ~node(){}
    
    template<class parent1, class parent2, dfor_lvalue(parent1), dfor_lvalue(parent2) >
    void setParents(parent1&& mother, parent2&& father) 
    {
        const auto& m = static_cast<const node&>(mother);
        const auto& f = static_cast<const node&>(father);
        this->setParents(m, f);
    }    
    virtual void setParents(const node& mother, const node& father) = 0;
};

struct label: node
{
    virtual void setParents(const node&, const node&){}
};
 
int main()
{
    label mother;
    label father;
    label child;
    node& example = child;
    
    example.setParents(mother, father);
}

#include <iostream>

struct node
{
    virtual ~node(){}
    
    template<class p1, class p2>
    void setParents(lvalue<p1>& mother, lvalue<p2>& father) 
    {
        const auto& m = static_cast<const node&>(mother);
        const auto& f = static_cast<const node&>(father);
        this->setParents(m, f);
    }    
    virtual void setParents(const node& mother, const node& father) = 0;
};

struct label: node
{
    virtual void setParents(const node&, const node&){}
};
 
int main()
{
    label mother;
    label father;
    label child;
    node& example = child;
    
    example.setParents(mother, father);
}

virtual void setParents(const node&, const node&){}

struct node
{
    virtual ~node(){}
    virtual void setParents(const node& mother, const node& father) = 0;
};

child getChild()
{
    parent mother("ma");
    parent father("pa");
    return child(mother, father);
}