Calling methods for template types

Suppose I have a class like this:

 template<typename Type>
 struct Policy {
	 virtual bool cause() = 0;
	 virtual void implement(std::shared_ptr<Type> type) = 0;
 };

I want to create a method as follows:

 template<template<typename> typename TPolicy, typename TObj>
 void integrate(TPolicy<TObj>&& policy, std::shared_ptr<TObj> val) {
	if (policy.cause())
		policy.implement(val);
 }

The method has to take in a policy parameter and the object on which to apply this policy.

1. Is there a way to implement the method integrate() in a way that it will also accept pointer types as Policies? For instance Policy<T>*, shared_ptr<Policy<T>>? Because this implementation uses the . operator that is not supported by pointer types.

2. How to properly check that TPolicy actually derives from the class Policy<T>?

Basically you are looking for std::is_base_of_v from <type_traits>.

Then you need to use that compile time trait to check if your function should compile or not. Various techniques exist to do that depending on your compiler version (in general the newer versions of C++ make this more easy).

Live example here (https://onlinegdb.com/VEaScpqbF).
And source code :

#include <memory>
#include <type_traits>

class Policy
{
};

class MyPolicy :
    public Policy
{
};

class NotAPolicy
{
};

// is_base_of_v is enough, I usually make 
// a constepr function for readability
// and sometimes a check requires multiple trait checks 
// it also allows for compile time check (see main)
template<typename policy_t>
static constexpr bool is_policy()
{
    return std::is_base_of_v<Policy, policy_t>;
}

//C++20 has concepts for  more readable meta (template) programming techniques
template<typename policy_t>
concept IsPolicy = is_policy<policy_t>();

// for C++17 and lower, use std::enable_if SFINAE
// returning an "error type" (non existent type) will result in function
// not being compilable
// NOTE : simplified your signature a bit, to show the principle 
template<typename policy_t>
auto integrate_cpp17(policy_t&& policy) 
    -> std::enable_if_t<is_policy<policy_t>(),void> // return type is void if there is a policy, an "error type" otherwise 
{
}

void integrate_cpp20(IsPolicy auto&& policy)
{
}

int main()
{
    static_assert(is_policy<MyPolicy>());
    static_assert(!is_policy<NotAPolicy>());

    integrate_cpp17(MyPolicy{});
    integrate_cpp17(NotAPolicy{}); // does not compile as intended

    integrate_cpp20(MyPolicy{});
    integrate_cpp20(NotAPolicy{}); // does not compile as intended


    return 0;
}