Защо преместването на променлива на указател не го настройва на нула?

Задаването на необработен указател на нула след преместването му предполага, че указателят представлява собственост. Въпреки това, много указатели се използват за представяне на връзки. Освен това, дълго време се препоръчва отношенията на собственост да се представят по различен начин от използването на необработен указател. Например отношението на собственост, за което говорите, е представено от std::unique_ptr<T>. Ако искате неявно генерираните операции за преместване да се грижат за вашата собственост, всичко, което трябва да направите, е да използвате членове, които всъщност представляват (и прилагат) желаното поведение на собственост.

Освен това поведението на генерираните операции за преместване е в съответствие с това, което е направено с операциите за копиране: те също не правят никакви допускания за собственост и не правят напр. дълбоко копие, ако е копиран указател. Ако искате това да се случи, трябва също да създадете подходящ клас, кодиращ съответната семантика.

Преместването прави преместения обект "невалиден". Той не го задава автоматично в безопасно „празно“ състояние. В съответствие с дългогодишния принцип на C++ "не плащайте за това, което не използвате", това е ваша работа, ако я искате.

Мисля, че отговорът е: прилагането на такова поведение сами е доста тривиално и следователно Стандартът не чувства нужда да налага каквото и да е правило на самия компилатор. Езикът C++ е огромен и не всичко може да се измисли преди използването му. Вземете например шаблона на C++. Първоначално не е проектиран да се използва по начина, по който се използва днес (т.е. това е способност за метапрограмиране). Така че мисля, че Стандартът просто дава свободата и не е направил никакво конкретно правило за std::move(other.p), следвайки един от него е принципът на дизайна: „Не плащате за това, което не използвате“.

template<typename T>
struct movable_ptr
{
    T *pointer;
    movable_ptr(T *ptr=0) : pointer(ptr) {} 
    movable_ptr<T>& operator=(T *ptr) { pointer = ptr; return *this; }
    movable_ptr(movable_ptr<T> && other) 
    {
        pointer = other.pointer;
        other.pointer = 0;
    }
    movable_ptr<T>& operator=(movable_ptr<T> && other) 
    {
        pointer = other.pointer;
        other.pointer = 0;
        return *this;
    } 
    T* operator->() const { return pointer; }
    T& operator*() const { return *pointer; }

    movable_ptr(movable_ptr<T> const & other) = default;
    movable_ptr<T> & operator=(movable_ptr<T> const & other) = default;
};

struct T
{
   movable_ptr<A> aptr;
   movable_ptr<B> bptr;
   //...

   //and now you could simply say
   T(T&&) = default; 
   T& operator=(T&&) = default; 
};