Is it safe to .pop_back() from an std::vector in order to avoid pointers/memory shifting?

Since your pollFdsVec is reserved to a fixed size, you don't really need to remove any pollfds from it at all. Simply set the pollfd::fd field to -1 when the corresponding Socket is closed, and then reassign the pollfd::fd when a new Socket is created. poll() ignores pollfds that have fd=-1:

https://man7.org/linux/man-pages/man2/poll.2.html

The field fd contains a file descriptor for an open file. If this field is negative, then the corresponding events field is ignored and the revents field returns zero. (This provides an easy way of ignoring a file descriptor for a single poll() call: simply set the fd field to its bitwise complement.)

Try this:

class Socket
{
    int fd;
    pollfd* pfdPtr;
    // ...
};

class Manager
{
    std::vector<pollfd> pollFdsVec;
    std::vector<std::shared_ptr<Socket>> socketsVec;

    Manager()
    {
        pollFdsVec.reserve(MAX_CLIENTS_CONECTED);
    }

    void Accept()
    {
        // When a new connection is created
        std::shared_ptr<Socket> sock = Accept(...); // listener returns a shared ptr

        // Add the new connection to the pfds
        auto pfdIter = std::find(pollFdsVec.begin(), pollFdsVec.end(),
           [](const pollfd &pfd){ return pfd.fd == -1; });
        if (pfdIter == pollFdsVec.end()) {
            pollFdsVec.emplace_back();
            pfdIter = --pollFdsVec.end();
        }

        pollfd &pfd = *pfdIter;
        pfd.fd = sock->fd;
        pfd.events = ...;
        pfd.revents = 0;

        // Set the pointer
        sock->pfdPtr = &pfd;

        socketsVec.push_back(sock);
    }

    void Poll()
    {
        int res = poll(pollFdsVec.data(), pollFdsVec.size(), 0);
        for (int i = 0; i < res; ++i)
        {
            // use pollFdsVec[i] as needed ...
        }
    }
};

...

// when a Socket is closed...
sock->fdPtr->fd = -1;

That being said, pollfd is a very light-weight type to copy, so you could simply get rid of the pollFdsVec vector altogether and store each pollfd directly inside its owning Socket object. poll() doesn't care where the array comes from, so its very trivial to create a new array each time poll() is called. This way, you don't have to worry about managing any pollfd* pointers at all.

Try this:

class Socket
{
    int fd;
    pollfd pfd;
    // ...
};

class Manager
{
    std::vector<std::shared_ptr<Socket>> socketsVec;

    void Accept()
    {
        // When a new connection is created
        std::shared_ptr<Socket> sock = Accept(...); // listener returns a shared ptr
        sock->pfd.fd = sock->fd;
        sock->pfd.events = ...;
        sock->pfd.revents = 0;

        socketsVec.push_back(sock);
    }

    void Poll()
    {
        pollfd pollFds[MAX_CLIENTS_CONECTED];
        nfds_t nfds = 0;

        for(auto &sock : socketsVec)
            pollFds[nfds++] = sock->pfd;

        int res = poll(pollFds, nfds, 0);
        for (int i = 0; i < res; ++i)
        {
            // use pollFds[i] as needed ...
        }
    }
};

Alternatively, you could use epoll() instead and get rid of pollfd completely, eg:

class Socket
{
    int fd;
    // ...
};

class Manager
{
    std::vector<std::shared_ptr<Socket>> socketsVec;
    int epfd;

    Manager()
    {
        epfd = epoll_create(MAX_CLIENTS_CONECTED);
        if (epfd == -1)
            throw ...;
    }

    ~Manager()
    {
         close(epfd);
    }

    void Accept()
    {
        // When a new connection is created
        std::shared_ptr<Socket> sock = Accept(...); // listener returns a shared ptr

        // Add the new connection to the epfd
        epoll_event event = {};
        event.events = ...;
        event.data = ...;

        if (epoll_ctl(epfd, EPOLL_CTL_ADD, sock->fd, &event) < 0)
            throw ...;

        socketsVec.push_back(sock);

        // ...
    }

    void Poll()
    {
        epoll_event events[MAX_CLIENTS_CONECTED];
        int res = epoll_wait(epfd, events, MAX_CLIENTS_CONECTED, 0);
        for(int i = 0; i < res; ++i)
        {
            // use events[i] as needed ...
        }
    }
};

The downside to this approach is that each time you want to flip the events to poll for a given Socket, you would have to call epoll_ctl(EPOLL_CTL_MOD) to update the epfd's interest list. You don't have to do that with poll() since you pass it an updated pollfd array each time you call it.