Performance of smart pointer and raw pointer in containers [closed]

Start with correct behavior, not performance.

1. Does your container own your objects? If no, use raw pointers. If yes, use smart pointers. But which ones? See below.
2. Do you need to support several containers containing the same object, and is it unclear which container will be deleted first? If the answer to both is "yes", use shared_ptr. Otherwise, use unique_ptr.

Later, if you discover that accessing the smart pointers wastes too much time (unlikely), replace the smart pointers by raw pointers together with highly optimized memory management, which you will have to implement according to your specific needs.

As noted in comments, you could do it without pointers. So, before applying this answer, ask yourself why you need pointers at all (I guess the answer is polymorphism, but not sure).

It's hard to provide a firm solution to your question without seeing the context and the way your struct/class operates.
But I still want to provide some basic info about smart pointers so hopefully, you can make a wise decision.

An example:

#include <iostream>
#include <vector>
#include <memory>

int main( )
{
    struct MyStruct
    {
        int a;
        double b;
    };

    std::cout << "Size of unique_ptr: " << sizeof( std::unique_ptr< MyStruct > ) << '\n';
    std::cout << "Size of shared_ptr: " << sizeof( std::shared_ptr< MyStruct > ) << '\n';
    std::cout << '\n';

    std::vector< std::unique_ptr<MyStruct> > vec1; // a container holding unique pointers
    std::vector< MyStruct* > vec2; // another container holding raw pointers

    vec1.emplace_back( std::make_unique<MyStruct>(2, 3.6) ); // deletion process automatically handled
    vec2.emplace_back( new MyStruct(5, 11.2) ); // you'll have to manually delete all objects later

    std::cout << vec1[0]->a << ' ' << vec1[0]->b << '\n';
    std::cout << vec2[0]->a << ' ' << vec2[0]->b << '\n';
}

The possible output:

Size of unique_ptr: 8
Size of shared_ptr: 16

2 3.6
5 11.2

Check the assembly output here and compare the two containers. As I saw, they generate the exact same code.

The unique_ptr is very fast. I don't think it has any overhead. However, the shared_ptr has a bit of overhead due to its reference counting mechanism. But it still might be more efficient than a handwritten reference counting system. Don't underestimate the facilities provided in the STL. Use them in most cases except the ones in which STL does not exactly perform the specific task you need.

Speaking of performance, std::vector<(struct or class name)> is better in most cases since all the objects are stored in a contiguous block of heap memory, and also dereferencing them is not required.
However, when using a container of pointers, your objects will be scattered around heap memory and your program will be less cache-friendly.

For most cases there's no need to use pointers or smart pointers in standard container templates, access is faster if you let the container manager the memory and use emplace instead of push methods to let it invoke the constructor.

The reason you see containers of raw pointers used in game Dev source is because memory pools are a good way to memory manage and persist objects that may have to have thousands of concrete instances, and thus managed in a way that gets more cache hits when iterating the entire pool for rendering. Occasionally you need a less performance critical container that points to some slice of the entire pool, but not responsible for the memory management.

The recent addition of std::ranges will eventually be a better alternative to raw pointers based view containers.