for (;;)
{
	tcp_stream handle = sock.accept();
	clients.push_back(std::thread(&server::HTTPServer::handleClient, handle));
}

Der Fehler:

c:\program files (x86)\microsoft visual studio 12.0\vc\include\functional(1149): error C2064: Ausdruck ergibt keine Funktion, die 1 Argumente übernimmt
1>          Klasse definiert keinen 'operator()' oder einen benutzerdefinierten Konvertierungsoperator für Zeiger auf Funktion oder Verweis auf Funktion, die die passende Argumentzahl verwenden
1>          c:\program files (x86)\microsoft visual studio 12.0\vc\include\functional(1137): Siehe Verweis auf die Instanziierung der gerade kompilierten Funktions-template "void std::_Bind<true,void,std::_Pmf_wrap<void (__thiscall server::HTTPServer::* )(tcp_stream),void,server::HTTPServer,tcp_stream>,network::socket_stream<network::tcp>>::_Do_call<,0>(std::tuple<>,std::_Arg_idx<0>)".
1>          c:\program files (x86)\microsoft visual studio 12.0\vc\include\functional(1137): Siehe Verweis auf die Instanziierung der gerade kompilierten Funktions-template "void std::_Bind<true,void,std::_Pmf_wrap<void (__thiscall server::HTTPServer::* )(tcp_stream),void,server::HTTPServer,tcp_stream>,network::socket_stream<network::tcp>>::_Do_call<,0>(std::tuple<>,std::_Arg_idx<0>)".
1>          c:\program files (x86)\microsoft visual studio 12.0\vc\include\thr\xthread(195): Siehe Verweis auf die Instanziierung der gerade kompilierten Funktions-template "void std::_Bind<true,void,std::_Pmf_wrap<void (__thiscall server::HTTPServer::* )(tcp_stream),void,server::HTTPServer,tcp_stream>,network::socket_stream<network::tcp>>::operator ()<>(void)".
1>          c:\program files (x86)\microsoft visual studio 12.0\vc\include\thr\xthread(195): Siehe Verweis auf die Instanziierung der gerade kompilierten Funktions-template "void std::_Bind<true,void,std::_Pmf_wrap<void (__thiscall server::HTTPServer::* )(tcp_stream),void,server::HTTPServer,tcp_stream>,network::socket_stream<network::tcp>>::operator ()<>(void)".
1>          c:\program files (x86)\microsoft visual studio 12.0\vc\include\thr\xthread(192): Bei der Kompilierung der  Klassen-template der unsigned int std::_LaunchPad<_Target>::_Run(std::_LaunchPad<_Target> *)-Memberfunktion
1>          with
1>          [
1>              _Target=std::_Bind<true,void,std::_Pmf_wrap<void (__thiscall server::HTTPServer::* )(tcp_stream),void,server::HTTPServer,tcp_stream>,network::socket_stream<network::tcp>>
1>          ]
1>          c:\program files (x86)\microsoft visual studio 12.0\vc\include\thr\xthread(187): Siehe Verweis auf die Instanziierung der gerade kompilierten Funktions-template "unsigned int std::_LaunchPad<_Target>::_Run(std::_LaunchPad<_Target> *)".
1>          with
1>          [
1>              _Target=std::_Bind<true,void,std::_Pmf_wrap<void (__thiscall server::HTTPServer::* )(tcp_stream),void,server::HTTPServer,tcp_stream>,network::socket_stream<network::tcp>>
1>          ]
1>          c:\program files (x86)\microsoft visual studio 12.0\vc\include\thr\xthread(205): Siehe Verweis auf die Instanziierung der gerade kompilierten Klassen-template "std::_LaunchPad<_Target>".
1>          with
1>          [
1>              _Target=std::_Bind<true,void,std::_Pmf_wrap<void (__thiscall server::HTTPServer::* )(tcp_stream),void,server::HTTPServer,tcp_stream>,network::socket_stream<network::tcp>>
1>          ]
1>          c:\program files (x86)\microsoft visual studio 12.0\vc\include\thread(49): Siehe Verweis auf die Instanziierung der gerade kompilierten Funktions-template "void std::_Launch<std::_Bind<true,void,std::_Pmf_wrap<void (__thiscall server::HTTPServer::* )(tcp_stream),void,server::HTTPServer,tcp_stream>,network::socket_stream<network::tcp>>>(_Thrd_t *,_Target &&)".
1>          with
1>          [
1>              _Target=std::_Bind<true,void,std::_Pmf_wrap<void (__thiscall server::HTTPServer::* )(tcp_stream),void,server::HTTPServer,tcp_stream>,network::socket_stream<network::tcp>>
1>          ]
1>          c:\users\xxx\documents\visual studio 2013\projects\webserver\webserver\httpserver.cpp(29): Siehe Verweis auf die Instanziierung der gerade kompilierten Funktions-template "std::thread::thread<void(__thiscall server::HTTPServer::* )(tcp_stream),network::socket_stream<network::tcp>&>(_Fn &&,network::socket_stream<network::tcp> &)".
1>          with
1>          [
1>              _Fn=void (__thiscall server::HTTPServer::* )(tcp_stream)
1>          ]

Kann sich das jmd. erklären?

namespace network
{
	class ss_interface : public network_error
	{
	public:
		template <typename socket_type>
		friend class socket_stream;

		ss_interface(SOCKET s);
		virtual ~ss_interface();

		void close();
		virtual std::vector<char> recv() = 0;
		virtual void send(const char *msg, std::size_t length) = 0;

	private:
		SOCKET m_sock;
	};

	template <typename protocol>
	class socket_stream {};

	template <>
	class socket_stream<tcp> : public ss_interface
	{
	public:
		socket_stream(SOCKET sock) : ss_interface(sock) {}

		socket_stream(socket_stream const &rhs) : ss_interface(rhs.m_sock)
		{
			setError(static_cast<network::error>(rhs.error().value()));
		}

		std::vector<char> recv() override;
		void send(const char *msg, std::size_t length) override;

		socket_stream& operator=(socket_stream const&) = delete;
	};
}

void server::HTTPServer::handleClient(tcp_stream handle)
{
	if (handle.fail())
	{
		// Error
	}

	auto buffer = handle.recv();
}

und:

namespace server
{
	class HTTPServer : public server_error
	{
	public:
		void start();

	private:
		void handleClient(tcp_stream handle);
		std::vector<std::thread> clients;
	};
}

handle ist doch einfach das typedef auf socket_stream<tcp>.

Keine Ahnuing, du zeigst es ja nicht.

thread_fails__( schrieb:

namespace server
{
	class HTTPServer : public server_error
	{
	public:
		void start();

	private:
		void handleClient(tcp_stream handle);
		std::vector<std::thread> clients;
	};
}

Ja, genau das war zu erwarten. Woher soll der thread einen HTTPServer nehmen, den er für den Aufruf einer nicht statischen Memberfunktion braucht? Den wirst du schon selber mit übergeben müssen.

Naja, bei so viel Fantasie erwarte ich ein vollständiges Minimalbeispiel, was den Fehler produziert.

Aber ich hab doch gezeigt was ... handle ist im 2ten Post?

Nein, hast du nicht.

Die müssen wir natürlich erstmal zusammenfassen, weil das irgendwie besser ist:

class SocketInterface//Allein hier steckt der Wurm drin, oder? 

class TCPSocket:public SocketInterface

class UDPSocket:public SocketInterface

So, fertig. Funktionen können beliebig SocketInterface* bekommen und ihnen ist egal, ob das nun TCP oder UDP ist.

Fertig??? Nee, eigentlich nicht. Die Sockets sind doch zu unterschiedlich, bieten ja sogar unterschiedliche Funktionen an, man müßte ständig mit if zwischen den Typen trennen, das geht zu verbessern:

struct tcp{};
struct udp{};

template <typename protocol>
class socket_stream

template <>
class socket_stream<tcp>:public TCPSocket

template <>
class socket_stream<udp>:public UDPSocket

und dann ist jeder Anwender genervt davon und trennt wieder.

typedef network::socket_stream<network::tcp> tcp_stream;

Viola!

(Der Nebenwitz ist, daß man dann in Jahren kein einziges mal nen UDPSocket gebraucht hätte.)

Nein, hast du nicht.

Im ersten Post steht, dass handle vom Typ tcp_stream ist, im 2ten das typedef und die dazugehörige Deklaration.

@volkard

Zugegeben, das ich von network_error erbe ist nicht gut. Allerdings finde ich die Bedienung letzten Endes intuitiver. Man könnte natürlich auch einfach network_error als privaten Member machen und mit einer Wrapper-Funktion darauf zugreifen.

Das ss steht für socket stream.
Das close() für ein explizites Schließen eines Sockets, im Destruktor wird das natürlich auch gemacht. Zumindest ich brauche das manchmal.

Der Kopierkonstruktor dürfte sich hiermit erklären:

template <class A, class B>
class Error
{
public:
	Error()
	{
		setError(A::ok);
	}

	bool fail() const
	{
		if (ec_.value() != static_cast<int>(A::ok))
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	const std::error_code &error() const
	{
		return ec_;
	}

protected:
	void setError(A code)
	{
		static B cat;
		ec_.assign(static_cast<int>(code), cat);
	}

private:
	std::error_code ec_;
};

namespace network
{
	enum class error
	{
		ok,
		socket_error,
		send_failed,
		connect_failed,
		accept_failed,
		bind_failed,
		recv_failed,
		listen_failed
	};

	class error_category : public std::error_category
	{
	public:
		const char *name() const override;
		std::string message(int code) const override;
	};

	typedef Error<network::error, network::error_category> network_error;
}

Und deinen letzten Post kann ich nicht wirklich nachvollziehen, was willst du mir damit jetzt sagen? Ich habe bei mir einmal socket_stream, welches nur send(), recv(), close() und noch die Fehlerfunktionalität bereitstellt.

Ansonsten habe ich u.a. noch einen socket_acceptor und socket_connector, welche mir ein socket_stream-Objekt zurückliefern. Ich fahre damit eigentlich ganz gut. Sicherlich könnte man das schöner machen, aber dazu bin ich in C++ nicht gut genug.

Der Kopierkonstruktor dürfte sich hiermit erklären:

Nee, nicht wie er funktioniert, sondern warum Sockets kopierbar sein sollten.

Hier der Quelltext:
C_chatserver.cpp

#include "H_C_chatserver.h"
#include <thread>
using namespace std;

int C_chatserver::InitWinSock(){
	int Val = 0;
	WSAData wsaDATA;
	WORD DllVersion = MAKEWORD(2, 1);
	Val = WSAStartup(DllVersion, &wsaDATA);
	return Val;
}
int C_chatserver::ServerThread(int ID){
	char* Buffer = new char[256];
	int size = 0;
	while (true){
		ZeroMemory(Buffer, 512);
		if ((size = recv(Connections[ID], Buffer, 256, NULL)) > 0){

			for (int a = 0; a < Counter; a++){
				if (Connections[a] == Connections[ID]){
					cout << Buffer << endl;
				}
				else{
					send(Connections[a], Buffer, 256, NULL);
				}
			}
		}
	}
	return 10;
}
C_chatserver::C_chatserver(string ip,int port){
	system("color 0a");

	int Val = InitWinSock();
	if (Val != 0){
		MessageBoxA(NULL, "WINSOCK STARTUP ERROR!!!", "Error", MB_OK | MB_ICONERROR);
		exit(1);
	}

	Connections = (SOCKET*)calloc(64, sizeof(SOCKET));

	sListen = socket(AF_INET, SOCK_STREAM, NULL);
	sConnect = socket(AF_INET, SOCK_STREAM, NULL);

	addr.sin_addr.s_addr = inet_addr(ip.c_str());
	addr.sin_port = htons(port);
	addr.sin_family = AF_INET;

	bind(sListen, (SOCKADDR*)&addr, sizeof(addr));
	listen(sListen, 64);
	cout << "Server started" << endl<<"Port: "<<port<<endl<<"IP: " << ip.c_str()<< endl;
	while (true){
		if (sConnect = accept(sListen, (SOCKADDR*)&addr, &addrlen)){
			Connections[Counter] = sConnect;
			char *Name = new char[64];
			ZeroMemory(Name, 64);
			sprintf(Name, "%i", Counter);
			send(Connections[Counter], Name, 64, NULL);
			send(Connections[Counter], "Welcome", 64, NULL);

			cout << "New Connection" << endl;
			thread t1(&C_chatserver::ServerThread, Counter);
			Counter++;
		}
		Sleep(50);
	}
}

H_C_chatserver.h

#include <WinSock.h>
#include <iostream>
#include <Windows.h>

using namespace std;

#pragma comment (lib, "ws2_32.lib")

class C_chatserver{
public:
	C_chatserver(string,int);
private:
	SOCKADDR_IN addr;
	int addrlen = sizeof(addr);
	int Counter;
	SOCKET sConnect;
	SOCKET sListen;
	SOCKET *Connections;

	int InitWinSock();
	int ServerThread(int ID);

};

Schon im Voraus vielen Dank für eure Hilfe!