#include <iostream>

class TrackedClass {
private:
    int _id;
    bool _isDesctructed = false;

public:
    // Default constructor
    TrackedClass() {
        std::cout << "Default constructor\n";
    }
    
    TrackedClass(int id) : _id(id) {
        std::cout << "Constructor id=" << id << "\n";
    }
    
    // Destructor
    ~TrackedClass() {
        _isDesctructed = true;
        std::cout << "Destructor id=" << _id << "\n";
    }

    // Copy constructor
    TrackedClass(const TrackedClass& other) {
        std::cout << "Copy constructor\n";
    }

    // Move constructor
    TrackedClass(TrackedClass&& other) noexcept {
        std::cout << "Move constructor\n";
    }

    // Copy assignment operator
    TrackedClass& operator=(const TrackedClass& other) {
        std::cout << "Copy assignment operator\n";
        return *this;
    }

    // Move assignment operator
    TrackedClass& operator=(TrackedClass&& other) noexcept {
        std::cout << "Move assignment operator\n";
        return *this;
    }
    
    void test() {
        std::cout << "desctructed=" << (_isDesctructed ? "true" : "false") << std::endl;
    }
};

class Wrapper {
private:
    TrackedClass _trackedClass;
    
public:
    Wrapper() : _trackedClass(1) {
    }
    
    TrackedClass&& take() {
        return std::move(_trackedClass);;
    }
};

TrackedClass&& fun1() {
    Wrapper w = Wrapper();
    return w.take();
}

int main(int argc, const char * argv[]) {
    TrackedClass&& t = fun1();
    t.test();
    std::cout << "test" << std::endl;
}

Constructor id=1
Destructor id=1
desctructed=false
test

Constructor id=1
Destructor id=1
desctructed=true
test

TrackedClass&& fun1() {
    Wrapper w = Wrapper();
    return std::move(w.take());
}

class Wrapper {
private:
    TrackedClass _trackedClass;
    
public:
    Wrapper() : _trackedClass(1) {
    }
    
    TrackedClass take() {
        return  _trackedClass; // <- тут копия порождается.
    }
};

TrackedClass fun1() {
    Wrapper w = Wrapper();
    TrackedClass t = w.take(); 
    return t;
}

class Wrapper {
private:
    TrackedClass _trackedClass;
    
public:
    Wrapper() : _trackedClass(1) {
    }
    
    TrackedClass take() {
        TrackedClass tc = std::move(_trackedClass); // <- Копия не порождается.
        return tc;
    }
};

TrackedClass fun1() {
    Wrapper w = Wrapper();
    TrackedClass t = w.take(); // <- копия НЕ порождается.
    return t;
}

int main(int argc, const char * argv[]) {
    TrackedClass t = fun1();
    t.test();
    std::cout << "test" << std::endl;
}

S>    TrackedClass take() {
S>        return  _trackedClass; // <- тут копия порождается.
S>    }
S>};
S>

S>    TrackedClass take() {
S>        TrackedClass tc = std::move(_trackedClass); // <- Копия не порождается.
S>        return tc;
S>    }
S>

    TrackedClass take() { return std::move(_trackedClass); }

S>TrackedClass fun1() {
S>    Wrapper w = Wrapper();
S>    TrackedClass t = w.take(); // <- копия НЕ порождается.
S>    return t;
S>}
S>

TrackedClass fun1() {
    Wrapper w = Wrapper();
    return w.take(); // <- копия НЕ порождается СТОПУДОВО!
}

TrackedClass&& take() {
    return std::move(_trackedClass); // Ни копии, ни перемещения - просто возврат rvalue ссылки.
}

TrackedClass fun1() {
    Wrapper w = Wrapper();
    return w.take(); // То самое одно неизбежное перемещение.
}

class Wrapper {
// . . .    
    const TrackedClass& get() const & { return _trackedClass; }
    TrackedClass&& get() && { return std::move(_trackedClass); }
};

TrackedClass fun1() {
    Wrapper w = Wrapper();
    return std::move(w).get(); // Клиент заказывает перемещение явно. И это хорошо!
}

TrackedClass fun1() {
    return Wrapper().get(); // Перемещение автоматом, поскольку объект враппера временный.
}

R>>class Wrapper {
R>>// . . .    
R>>    const TrackedClass& get() const & { return _trackedClass; }
R>>    TrackedClass&& get() && { return std::move(_trackedClass); }
R>>};
R>>

class Wrapper {
// . . .    
    template <typename Self>
    decltype(auto) get(this Self&& self) {
        return (std::forward<Self>(self)._trackedClass); 
    }
};

class Wrapper {
// . . .    
    template <typename Self>
    requires (
        std::is_rvalue_refrence_v<Self>
        or std::is_const_v<std::remove_refrerence_t<Self>>)
    decltype(auto) get(this Self&& self) {
        return (std::forward<Self>(self)._trackedClass); 
    }
};