How exactly does the accept() Function in Winsock work?

I am learning Winsock with c++ right now.

Once the ListenSocket has started with listen(), how am i supposed to handle more than one connection in a clean way?

Right now, everytime a new connection is established it is moved into the ConnectedSocket, and when a new connectiion is established, it gets overridden.

    //Listen & Success Report
    result = listen(ListenSocket, int(2));
    if (result == 0)
    {
        PRINT("Listening...")
    }
    else
    {
        closesocket(ListenSocket);
        PRINT("Failed to Listen")
        return;
    }

    //Accept
    ConnectedSocket = accept(m_Socket, nullptr, NULL);

My first Idea was to create an Array that holds the Sockets but how do i know when a new connection has been established, since i don't get to write my own code for handling new connections. The only way i can think of right now is to check everytime i run my code, wether the connected Socket is Invalid or not, and then move it into an Array(if it is valid), which is not a good alternative because when other Clients try to Connect at the same time, one of them might get overriden.

I am sure there is a better way, isn't it?

Any non-trivial server will call accept in a loop like so:

while (true) {
  SOCKET connected = accept(m_Socket, nullptr, nullptr);
  // do something with connected
}

Note that the return value of accept is assigned to a variable that is local to the while loop.

A typical "do something" could be to spawn a new thread that receives a copy of the socket in connected.
Alternatively, you might want to add the socket to a global set that you poll with select or equivalent mechanism.

In a single threaded server you typically put the socket descriptor in a container, like a std::vector<SOCKET>, and then wait for events on all the sockets using
select or a similar function that can wait on events on many sockets at the same time.

Example:

std::vector<SOCKET> sockets;

sockets.push_back(m_Socket); // the server socket

fd_set readfds{};
for(auto s : sockets) FD_SET(s, &readfds); // put sockets in the fd_set

int ready_count = select(0 /*ignored in WinSock*/,
                         &readfds, nullptr, nullptr, nullptr);

// for bookkeeping of new and closed connections:
std::vector<bool> closed_sockets(sockets.size());
std::vector<SOCKET> new_sockets;

for(int i = 0; i < ready_count; ++i) {
    if(not FD_ISSET(sockets[i], &readfds) { // not ready
        ++ready_count;
        continue;
    }

    // sockets[i] is ready to be read

    if(sockets[i] == m_Socket) {
        // server
        SOCKET ConnectedSocket = accept(m_Socket, nullptr, NULL);

        if(ConnectedSocket == INVALID_SOCKET) {
            // error
        } else {
            // save this connection
            new_sockets.push_back(ConnectedSocket);
        }
    } else {
        // one of the client sockets

        // if reading from `socket[i]` indicates that the client
        // closed the connection:
        closed_sockets[i] = true;
    }
}

// Remove sockets set to `true` in `closed_sockets`
// Add new connections to `sockets` from `new_sockets`