"auto"关键字：如何自定义？

Question

标题含糊不清，我知道。考虑一下：

template<typename T>
using Ref = std::shared_ptr<T>;

template<typename T>
using StrongRef = std::shared_ptr<T>&;

struct Person {
    std::string m_name;
    Person(const std::string& l_name) : m_name(l_name) {}
};

class Container{
    Ref<Person> m_person;
public:
    People(const std::string& l_name) {
        m_person = std::make_shared<Person>(l_name);
    }

    ~People() {}

    StrongRef<Person> GetPerson() { return m_person; } //returning a ref to a shared 
                                     //pointer, so it doesn't increase the use_count
};

int main(){
Container container("Pedro");
/*Here lies my problem. The auto keyword is presuming a shared_ptr, not a shared_ptr&*/
auto person = container.GetPerson(); 
/*I want it auto keyword to be StrongRef<Person> not std::shared_ptr<Person>*/
}

有没有办法让我的 auto 关键字成为 StrongRef 而不是推导 std::shared_ptr？

Answer 1

你可以告诉auto你想要一个像

这样的参考

auto& person = container.GetPerson();

这确实有一个缺点，虽然好像 GetPerson 按值更改为 return，然后您试图将左值引用绑定到右值，这将导致编译器错误。

要解决这个问题，您可以使用像

这样的转发引用

auto&& person = container.GetPerson();

现在，如果 container.GetPerson() return 一个右值，person 将是一个右值引用，它将延长临时对象的生命周期以匹配 [=15= 的生命周期].

如果 container.GetPerson() return 是左值，那么 person 将是对 returned 对象的普通旧左值引用，就像您使用 auto& 代替。

Answer 2

@NathanOliver 我是这样工作的：

而不是

template <typename T>
using StrongRef = std::shared_ptr<T>&;

我正在使用

template <typename T>
using StrongRef = std::shared_ptr<T>&&;

当我 return m_person 我只是把它投射到 StrongRef

StrongRef<Person> GetPerson() { return (StrongRef<Person>)m_person; }

现在我的 auto 关键字将成为对它的引用。因此，不增加计数：

int main() {
    People people("Pedro");
    
    auto person = people.GetPerson();


    if (person) {
        std::cout << person.use_count() << "\n"; //Remains 1
        std::cout << person->m_name << "\n";
    }

    return 0;
}

"auto"关键字：如何自定义？

"auto" keyword: How to customize it?

c++

smart-pointers

auto