std::unique_ptr has memory overhead only if you provide it with some non-trivial deleter.
std::shared_ptr always has memory overhead for reference counter, though it is very small.
std::unique_ptr has time overhead only during constructor (if it has to copy the provided deleter and/or null-initialize the pointer) and during destructor (to destroy the owned object).
std::shared_ptr has time overhead in constructor (to create the reference counter), in destructor (to decrement the reference counter and possibly destroy the object) and in assignment operator (to increment the reference counter). Due to thread-safety guarantees of
std::shared_ptr, these increments/decrements are atomic, thus adding some more overhead.
Note that none of them has time overhead in dereferencing (in getting the reference to owned object), while this operation seems to be the most common for pointers.
To sum up, there is some overhead, but it shouldn’t make the code slow unless you continuously create and destroy smart pointers.