The mystery of any type conversion

background

struct A{

  A(int a){
    this->a = a;
  }
  
  int a;
};

namespace Test{

  struct A{
    
    A(int a){
      this->a = a;
    }
    
    int a;
  };
}

void AnyCast(std::any& param){

    const auto value = std::any_cast<Test::A>(param).a;
    std::cerr << "value : " << value << std::endl;
}

int main(){
    
    A a = 1;
    auto param = std::make_any<A>(a);
    AnyCast(param);
    
    return 0;
}

• Whether the above conversion is successful ?

doubt 1

Why do you customize the same type name with the same memory structure , Just because the namespace is different, it will lead to conversion exceptions ？ Whether namespace removal is normal ？ To make sure that the compilation passes , You need to separate custom types in different modules .

// module.h
#pragma once
#include <memory>
#include <any>

class ModuleImpl;

class Module{
public:
    Module();

    void AnyCast(std::any& param);
private:
    std::shared_ptr<ModuleImpl> _impl;
};

// module.cpp

#include "module.h"
#include <iostream>

struct A {

    A(int a) {
        this->a = a;
    }

    int a;
};

class ModuleImpl {
    
public:
    void AynyCast(std::any& param)
    {
        const auto value = std::any_cast<A>(param).a;
        std::cerr << "value : " << value << "\n";
    }
};


Module::Module()
    : _impl(std::make_shared<ModuleImpl>())
{
}

void Module::AnyCast(std::any& param)
{
    _impl->AynyCast(param);
}

• Will there be any exceptions in the above conversion ？

doubt 2

Separate modules , Adding namespaces won't be a problem ？ In response to this question , It's not impossible , To validate the ：

There is a feeling of knowing each other from time to time .

uncover any_cast The veil of

Here we use MSVC Version implementation any_cast For example . First, let's look at its implementation logic ：

template <class _Ty>
_NODISCARD remove_cv_t<_Ty> any_cast(any& _Any) {
    static_assert(is_constructible_v<remove_cv_t<_Ty>, _Remove_cvref_t<_Ty>&>,
        "any_cast<T>(any&) requires remove_cv_t<T> to be constructible from remove_cv_t<remove_reference_t<T>>&");

    const auto _Ptr = _STD any_cast<_Remove_cvref_t<_Ty>>(&_Any);
    if (!_Ptr) {
        _Throw_bad_any_cast();
    }

    return static_cast<remove_cv_t<_Ty>>(*_Ptr);
}

The key function :any_cast<_Remove_cvref_t<_Ty>>(&_Any)

template <class _ValueType>
_NODISCARD _ValueType* any_cast(any* const _Any) noexcept {
    // retrieve a pointer to the _ValueType contained in _Any, or null
    static_assert(!is_void_v<_ValueType>, "std::any cannot contain void.");

    if constexpr (is_function_v<_ValueType> || is_array_v<_ValueType>) {
        return nullptr;
    } else {
        if (!_Any) {
            return nullptr;
        }

        return _Any->_Cast<_Remove_cvref_t<_ValueType>>();
    }
}

The key function :_Any->_Cast<_Remove_cvref_t<_ValueType>>()

 template <class _Decayed>
    _NODISCARD _Decayed* _Cast() noexcept { // if *this contains a value of type _Decayed, return a pointer to it
        return const_cast<_Decayed*>(static_cast<const any*>(this)->_Cast<_Decayed>());
    }

The key function :static_cast<const any>(this)->_Cast<_Decayed>()*

 template <class _Decayed>
    _NODISCARD const _Decayed* _Cast() const noexcept {
        // if *this contains a value of type _Decayed, return a pointer to it
        const type_info* const _Info = _TypeInfo();
        if (!_Info || *_Info != typeid(_Decayed)) {
            return nullptr;
        }

        if constexpr (_Any_is_trivial<_Decayed>) {
            // get a pointer to the contained _Trivial value of type _Decayed
            return reinterpret_cast<const _Decayed*>(&_Storage._TrivialData);
        } else if constexpr (_Any_is_small<_Decayed>) {
            // get a pointer to the contained _Small value of type _Decayed
            return reinterpret_cast<const _Decayed*>(&_Storage._SmallStorage._Data);
        } else {
            // get a pointer to the contained _Big value of type _Decayed
            return static_cast<const _Decayed*>(_Storage._BigStorage._Ptr);
        }
    }

The key code of this problem :

// if *this contains a value of type _Decayed, return a pointer to it
        const type_info* const _Info = _TypeInfo();
        if (!_Info || *_Info != typeid(_Decayed)) {
            return nullptr;
        }

You can use a line of code to explain :

typeid(A) == typeid(Test::A)

Set up ？

I don't say much nonsense , Let's go straight to work ：

struct A {

    A(int a) {
        this->a = a;
    }

    int a;
};

namespace Test {

    struct A {

        A(int a) {
            this->a = a;
        }

        int a;
    };
}

int main()
{
    const auto same = typeid(A) == typeid(Test::A);

    std::cerr << "same : " << std::boolalpha << same << std::endl;

    return 0;
}

summary

As a partner ( feel ) grid ( fish ) Software development engineer of , Finally, it's not too much to summarize .

• In the use of any During type conversion , Make sure that the type source is unique
• Do not copy code casually between different modules
• Only code can solve BUG

This time any The mystery of type conversion End of the flower ！！！