Ich habe hier zwei Klassen, wobei ich die Funktionen der ersten Klasse in der zweiten benötige.
Wie kann ich das machen?

Es gibt viele Möglichkeiten. Die technische Umsetzung sollte sich jedoch an der Modellierung orientieren, niemals umgekehrt. Was sollen deine Klassen darstellen, wie verhalten sich die Klassen und Objektinstanzen zueinander?

#include <iostream>

class A
{
  int i_;
public:
  A(int i)
    : i_(i)
  {}
  void foo()
  {
    std::cout << i_ << '\n';
  }
};

class B
{
  A a_;
public:
  B(int i)
    : a_(i)
  {}
  void foo()
  {
    a_.foo();
  }
};

int main()
{
  B b(5);
  b.foo();
}

Es gibt viele Möglichkeiten. Die technische Umsetzung sollte sich jedoch an der Modellierung orientieren, niemals umgekehrt. Was sollen deine Klassen darstellen, wie verhalten sich die Klassen und Objektinstanzen zueinander?

Genauer: Ich habe eine Klasse, die die socket-Funktionen der Win-API durch eigene Methoden ersetzt, dazu Fehlerbehandlung etc..
Das hat den Sinn, dass ich in der zweiten Klasse dann zum Beispiel nur noch createSocket() aufrufen muss wenn ich eins erstellen will.

@cooky451: Woher weißt du, dass er Komposition suchte, nicht Vererbung (in einer ihrer vielen Spielarten), Übergabe (in einer ihrer vielen Spielarten) oder sonstwas, das ich gerade vergessen habe (in einer seiner vielen Spielarten)?

Ich hab ihm einfach irgendwas geschrieben damit er einsieht, dass die Informationen nicht reichen. Geht meiner Erfahrung nach schneller als Diskussionen.

amolacar schrieb:

Genauer: Ich habe eine Klasse, die die socket-Funktionen der Win-API durch eigene Methoden ersetzt, dazu Fehlerbehandlung etc..
Das hat den Sinn, dass ich in der zweiten Klasse dann zum Beispiel nur noch createSocket() aufrufen muss wenn ich eins erstellen will.

Such mal nach RAII.

Wie kann ich diese "socket-Klasse" jetzt in meiner zweiten Klasse nutzen?

RAII klingt auf jeden Fall interessant, wird hier meiner Meinung nach nicht benötigt.

Nur auf die Art und Weise, wie ein Flugzeug nicht "nötig" ist, um von London nach New York zu kommen. Es mag auch ohne gehen, ist dann aber unnötig langsam und umständlich. Guck dir das unbedingt nochmal an. Das ist eine wichtige Grundtechnik!

Wie kann ich diese "socket-Klasse" jetzt in meiner zweiten Klasse nutzen?

Die Frage erübrigt sich, wenn die Klassen ihre Ressourcen selber verwalten, siehe oben.

(Used sei im foglenden die zu nutzende Klasse, User die nutzende Klasse):
1.- du kannst User von Used erben lassen um die funktionalität zu nutzen

class Used { };
class User : public/private/protected Used {};

2.- du kannst Used in User reinkomponieren

class Used { };
class User { Used m_used; };

3.- du kannst dir innerhalb von methoden lokal ein Used objekt erstellen und dieses dann nutzen

class Used { };
class User
{
    void foo()
    {
        Used u;
    }
};

das sind 3 grundlegende möglichkeiten, es geht noch mehr, aber rück erstmal infos raus

@cooky451: Woher weißt du, dass er Komposition suchte, nicht Vererbung?

Aus dem Titel zu entnehmen.

class A
{
public:
    void foo();
};

class B
{
public:
    B() : a(nullptr) {}
    void SetA(A& a) {this->a = &a;}
    void func() {a->foo();}

private:
    A* a;
};

oder sogar

class A
{
public:
    void foo();
};

class B
{
public:
    void someFunc(A& a) {a.foo();}
};

MfG

class A
{
public:
    void foo();
};

class B
{
public:
    B() : a(nullptr) {}
    void SetA(A& a) {this->a = &a;} // <----
    void SetA(A * a) {this->a = a;};
    void func() {a->foo();}

private:
    A* a;
};

yihaaa: Das ist eine semantische Frage. Ich finde die Referenzübergabe sinnvoller, weil ich meistens bei Dependency Injection nicht im Nachhinein einen Zeiger ungültig machen möchte. Soll man das nicht können, dann ist die Referenz zur Indikation dessen angebrachter, wie ich finde.

MfG

Wenn ich von meiner Socket-Klasse ausgehe erstelle ich mit jedem Objekt einen Socket, diesen kann ich dann mit Methoden verändern (an einen Port binden etc.) und durch den Destruktor in dem ich den Socket wieder freigebe wird automatisch, wenn ich z.B. ein Socket-Objekt in einer Methode in der Klasse in der ich die Socket-Klasse verwenden möchte erzeuge, dieses Objekt freigegeben, da mit dem verlassen der Funktion auch alle Variablen und Objekte zerstört werden?

Ist das so richtig?

Als privat deklariert:

SOCKET _sock

Das ist mein Konstruktor:

Socket::Socket() : _sock(socket(PF_INET, SOCK_STREAM, 0)) {

	if (_sock == INVALID_SOCKET) {
		throw socketException("socket() failed", WSAGetLastError());
	}
}

Der Destruktor:

Socket::~Socket() {
	error = closesocket(_sock);
	if (error == SOCKET_ERROR) {
		throw socketException("closesocket() failed", WSAGetLastError());
	}
}

Der Programmcode in dem der Fehler auftritt:

Socket saccept;
Socket slisten;

slisten.bind(SERVER_PORT, SERVER_ADDRESS);
slisten.listen();

do {
	saccept.accept(slisten);
} while (1);

Nachdem die erste Verbindung aktzeptiert wurde und der erste Schleifendurchlauf beendet wurde bekomme ich eine Exception geworfen die mir sagt, dass closesocket() fehlgeschlagen ist mit dem Fehlercode 10038.

Kann mir jmd sagen was ich falsch mache?

NIEMALS IN DESTRUKTOREN EXCEPTIONS WERFEN !!!

ansonsten kann es passieren, dass objekte (oder arrays/vectoren) nicht komplett zerstört werden (oder im falle von arrays/listen einige nicht destruiert werden)
genaueres in effective c++ nachzulesen

Edit: Habe die Exception mal rausgenommen, jetzt wird nachdem die erste Verbindung aktzeptiert wurde gar keine Verbindung mehr angenommen, es wird aber auch keine Exception geworfen.

Der Fehler tritt aber denke ich bei dem listen-Socket auf, accept() bekommt nämlich kein gültiges Socket mehr übergeben. Nur wieso das so ist und wie man das beheben kann, keine Ahnung.

Was hier passiert:
accept wird mit listen_sock aufgerufen. Da Du nicht über Referenz übergibst, sondern by value, wird listen_sock erstellt, indem eine Kopie vom übergebenen Socket erstellt wird (Kopie heißt hier einfach, dass alle Attribute kopiert werden).

Wieso listen_sock jetzt nicht gültig ist, weiß ich aber nicht. Ein Socket definiert sich ja meist intern über eine Handle-ID. Klar ist, dass nach dem Funktionsaufruf der Destruktor aufgerufen wird, sodass das Socket danach zerstört wird. Wenn Du by reference übergibst, wird eben keine Kopie erstellt. Wie macht sich denn bemerkbar, dass das Socket ungültig ist? Du kannst gerne auch Mal listen und bind zeigen.

void Socket::accept(Socket listen_sock) {	
	_sock = ::accept(listen_sock._sock, NULL, NULL);
}

du übergibst eine kopie deines objektes (_sock) und diese kopie wird am ende von der methode zerstört. ich vermute, du hast in deiner socket klasse keine eigenen kopierkonstruktor definiert und der generierte kopiert stupide alles hin und her und sobald hier deine methode verlassen wird, werden quasi beide sockets ungültig gemacht, d.h. der eine wird zerstört und zerstört damit die aufgebaute verbindung des anderen

für mehr als dieses vermutungen müsste man sich code angucken

(versuch einfach mal:

void Socket::accept(Socket & listen_sock) {	
	_sock = ::accept(listen_sock._sock, NULL, NULL);
}

nur mal so, ob der fehler dann weg ist. weil dann wäre meine vermutung bestätigt. das design solltest du dann mal überdenken)

Also Kopier-Konstruktor sowas?

Socket::Socket(const Socket &rhs) {
	_sock = rhs._sock;
}

Du kannst copy-ctor und operator= "deaktivieren", wenn man keine Kopien erstellen sollte. Das ist wohl in Deinem Fall zu empfehlen.

Einfach in die Klasse schreiben:

private:
Socket(const Socket&);
Socket& operator=(const Socket&);

ohne Implementierung. Jetzt gehen keine Kopien mehr.