Send big string into socket

Yes, that is the best way.

You have to obtain a pointer to the data anyway, to use send, so just adjust the pointer as you see fit.

Something like:

int SendAll(SOCKET client_socket, const std::string& str)
{
    const char* data_ptr  = str.data();
    std::size_t data_size = str.size();

    int bytes_sent;

    while (data_size > 0)
    {
        bytes_sent = send(client_socket, data_ptr, data_size, 0);
        if (bytes_sent == SOCKET_ERROR)
            return -1;

        data_ptr += bytes_sent;
        data_size -= bytes_sent;
    }

    return 1;
}

This is perfectly fine and idiomatic.

If you want to keep both versions of the function, just forward the string's buffer to your existing overload:

int SendAll(SOCKET client_socket, const std::string& str)
{
    return SendAll(
        client_socket,
        reinterpret_cast<const void*>(str.data()),
        str.size()
    );
}

ssize_t send(int sockfd, const void *buf, size_t len, int flags);

This is the signature of send. It requires a pointer to the buffer. Although a C++ API would probably prefer a pair of iterators, rather than a pointer and a size, this is not really possible here, seeing that the pointer to the actual buffer is required. So, there's nothing you can do about it, really. You can just use the string's data() member function to get a poninter to the start of the buffer, and work with that. This should be perfectly fine.

As suggested by Some programmer dude in the comments, you could add a simple overload that facilitates this:

int SendAll(SOCKET client_socket, std::string const& str) {
    return SendAll(client_socket, reinterpret_cast<const void*>(str.data()), str.size());
}