Question

我有一个将const ref引用到集合的方法。我想打电话给他通过一套。如果有的话。所以首先我看看是否有一套：

    public void getWager(final WagerCallback wagerCallback) {
    FCGames.addValueEventListener(new ValueEventListener() {
        @Override
        public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
            for (DataSnapshot snapshot: dataSnapshot.getChildren()) {
                double wagerr = snapshot.child("wager").getValue(Double.class);
                String wagerD = Double.toString(wagerr);
                boolean wage = wagerD.endsWith("0");

                if(wage) {
                    wagerD = "$"+Double.toString(wagerr)+"0";
                } else
                    wagerD = "$"+Double.toString(wagerr);

                wages.add(wagerD);

                        wagerCallback.onCallback(wagerD);
            }
        }

        @Override
        public void onCancelled(@NonNull DatabaseError databaseError) {
            throw databaseError.toException();
        }
    });
}

惯用的方法是什么？我不喜欢上面的内容，因为对myFunction的调用被重复了两次，并且还有其他一些参数，所以有一些不必要的代码重复。

我体内的C程序员只想更改函数以接受指针，并在未找到set的情况下传递nullptr，但是我觉得C ++就是现在就避免使用指针？..

Answer 1

您可以使用条件运算符：

myFunction(it != mapOfSets.end() ? it->second : MySetType{});

我不认为这是惯用的方式。

Answer 2

如果编写辅助函数以在地图中查找集合，则在找不到任何东西的情况下可以返回对特殊空集合的引用：

const MySetType& find(const MyMapType& mapOfSets, const std::string& key) {
    auto it = mapOfSets.find(key);
    if (it != std::end(mapOfSets)) {
        return it->second;
    }
    static const MySetType emptySet;
    return emptySet;
}

那么您的呼叫代码就是：

myFunction(find(mapOfSets, "token"));

Answer 3

也许是一个手写的optional_reference，可以引用nullptr，但是在取消引用时会throw，并且没有其他bool

#include <stdexcept>
#include <memory>

class null_access_exception: public std::logic_error
{
    using base = std::logic_error;
public:
    null_access_exception():
        base("Try to dereference null optional_reference!")
    {}
};

template <class Ptr_t>
class optional_reference
{
    using self = optional_reference;
    using reference = decltype(*std::declval<Ptr_t>());
    Ptr_t ptr = nullptr;

public:
    optional_reference() = default;
    optional_reference(const self&) = default;

    self& operator = (const self&) = delete;

    template <class U>
    constexpr optional_reference(U &&obj) noexcept: 
        ptr(std::addressof(obj))
    {}

    constexpr explicit operator bool() const noexcept
    { return has_value(); }

    constexpr bool has_value() const noexcept
    { return ptr != nullptr; }

    constexpr auto& value() const
    {
        if (!has_value())
            throw null_access_exception();

        return *ptr;
    }

    template <class U>
    constexpr auto& value_or(U &&obj) const noexcept
    {
        if (has_value())
            return *ptr;
        else
            return reference(std::forward<U>(obj));
    }
};

然后

更改myfunction，使其接受optional_reference，然后进行检查。
像下面这样包装。

constexpr const静态自动null_set（）; 无效的Myfunction（optional_wrapper ref） { myfunction（ref.value_or（null_set））; }

C ++避免指针的惯用方式是什么？

3 个答案: