Templates vs Virtual

Overused topic I know, but this is not about performance.

If I use templates then, in this example, I would be limited to only creating lists of HTTP clients -OR- FTP clients, but not both types in the same list due to being different types. As apposed to virtual, obviously.

Sorry about the example and pseudo code.

Code:

class Protocol

class HTTP : Protocol
class FTP : Protocol


templates:

class Client<typename protocol>

template <typename protocol>
func CreateClient()

client = CreateClient<HTTP>()
client = CreateClient<FTP>()

httpList = std::vector<Client<HTTP> >
ftpList = std::vector<Client<FTP> >

virtual:

class Client
    Protocol* protocol

func CreateClient(Protocol* protocol)

client = CreateClient(new HTTP)
client = CreateClient(new FTP)

list = std::vector<Client>

Oh, and my question is if this is correct, and/or there are better options. Thanks.

Or even better:

Code:

class Client
{
...
};

class HTTPClient : public Client
{
...
};

class FTPClient : public Client
{
...
};

vector<Client*> list;
list.push_back(new HTTPClient());
list.push_back(new FTPClient());

Well, I wanted protocol abstracted from the client. But if that's your suggestion, I assume you prefer a virtual base class. It comes down to the same thing.