How to safely change the type of a pointer

» cpp » How to safely change the type of a pointer

By : user3100376

Date : January 12 2021, 07:00 PM

this one helps. I don't think casting the pointers will ever solve your problem, if the classes have virtual functions. When you call one of these, the object pointed to will 'know' (through its v-table) that it is either A or B, and call the appropriate function. You should probably have a function that really replaces the A with a (new) B - but that should be relatively easy, as you can create a constructor for B that takes an A as an argument!

code :

Share :

can I safely cast a pointer to const member to the same type but non-const?

By : pohao shih

Date : March 29 2020, 07:55 AM

Does that help In the "non-const" specialization, FT is simply deduced to include the const qualifier. It doesn't disappear, it's just passed in.
Try this:

code :

template<typename Class, typename FT> struct tmpl<FT(Class::*)>{
    static void f(){
        if ( std::is_const< FT >::value ) {
            cout<<"const as non const"<<endl;
        } else {
            cout<<"non const"<<endl;
        }
    }
};

How to safely destruct class with smart pointer to incomplete object type?

By : Twisted Chikon

Date : March 29 2020, 07:55 AM

This might help you I don't think your code should compile (and it doesn't in gcc)
std::unique_ptr uses std::default_delete, and std::default_delete::operator() should fail to instantiate for an incomplete type Cow.

Can I change the type of a SharedPreferences variable safely?

By : Kozeljac

Date : March 29 2020, 07:55 AM

wish help you to fix your issue I have a value saved in SharedPreferences that is a float. I tried to save this as a int after some design changes, but I cam getting a ClassCastException. The exception is thrown when I try to load this value. , You should remove the value from preferences first.
Call

code :

Editor.remove(String key);

How can I test if an pointer type can be safely converted to another potiner type?

By : Soylu Hosting

Date : March 29 2020, 07:55 AM

this one helps. Use std::enable_if in combination with a test to see if dynamic_cast is well-formed to SFINAE the right assertion. This will avoid using dynamic_cast whenever it would be ill-formed, such as when:
Casting to or from a non-class type, or Casting from a non-polymorphic class type A to a class type B where B is not an accessible base of A.

code :

template <typename T, typename U>
using dynamic_cast_r = decltype(dynamic_cast<U*>(static_cast<T*>(nullptr)));

template <typename T, typename U>
using can_dynamic_cast = can_apply<dynamic_cast_r, T, U>;

template <typename T>
class foo
{
public:
    foo(T *p) : p(p) { }

public:
    template <typename U>
    typename std::enable_if<can_dynamic_cast<T, U>::value, bool>::type convert_ok()
    {
        return dynamic_cast<U*>(p) != nullptr;
    }

    template <typename U>
    typename std::enable_if<!can_dynamic_cast<T, U>::value, bool>::type convert_ok()
    {
        return std::is_same<T, U>::value;
    }

private:
    T *p;
};