C/C++ Birden fazla türde return

İstediğin bir çözüm değil biliyorum fakat cast işlemini kullanıcıdan kurtarabiliriz.

C++:
template <typename U, class T_>
U operator()(const T_& obj, const std::string& name) {
    return std::any_cast<U>(ByName(obj, name));

// auto bar = GetByName<int>(foo, "bar")
}
Ben de böyle bir çözüm düşünmüştüm ama dediğine uymuyor. Yine de belki kullanmak ister.
 
// auto bar = GetByName<int>(foo, "bar")
İllegal kullanım olmasa onu düşünmüştüm, silmedim de daha duruyor hala. :(
1713172432443.png

1713172467423.png

Onun yerine şöyle bir şey yaptım en son;
C++:
template<class R_, class T_>
R_ To(const T_& obj, const std::string& name) const {
    auto ret = ByName(obj, name);
    return (ret.has_value()) ? std::any_cast<R_>(ret) : R_{};
}

Fonksiyona çevirmem lazım aslında ama nasıl std::any ile bu şekilde bi recursive sistem yazabilirim tam emin değilim. Classken böyle kalıyor ne yazık ki.
 
tagged union kullanmayı deneyin hocam.
std::variant type-safe tagged union zaten. İstediğim şey olmadığından bahsetmiştim. En son any için wrapper yazdım, template typecast operator overloadıyla cast yazdım. Implicit typecast ile kullanılabiliyor eğer önceden belirlenmiş bir type'a atama yapıyorsa;
C++:
class any  : public std::any{
    public:
    any() : std::any() {}
    any(const std::any& a) : std::any(a) {}
    any(const std::any&& a) : std::any(std::move(a)) {}

    template<typename T_>
    any(const T_& val) : std::any(val) {}

    template<typename T_>
    void operator=(T_ val) {
        this->emplace<T_>(val);
    }

    template<typename T_>
    operator T_() {
        return any_cast<T_>(*this);
    }

};

any foo(any val) {
    /* do something */
    return val;
}

int main() {
    int bar = foo(45); // implicit typecast
    std::cout << bar << std::endl; // 45
    return 0;
}
Hala tam olarak istediğim şey değil ve riskli. Ama o riski kullanıcıya saldım. Dokümantasyon da belirteceğim ona dikkat etsin diye.
 
Son düzenleme:

Geri
Yukarı