Eine Struktur in der Initialisierungsliste initialisieren

BerndD

Hallo,
wie initialisiert man eine Struktur in einer Initialisierungsliste? Durch die SuFu habe ich bereits gelernt, wie man alles mit Null initialisieren kann - siehe Zeile 32, die Struktur OVERLAPPED. Wie kann ich z.B. hEvent einen anderen Wert zweisen?

LG
Bernd

#include <windows.h>
#include <iostream>

/* Aufbau der Struktur OVERLAPPED aus winbase.h 
typedef struct _OVERLAPPED {
    ULONG_PTR Internal;
    ULONG_PTR InternalHigh;
    union {
        struct {
            DWORD Offset;
            DWORD OffsetHigh;
        };

        PVOID Pointer;
    };

    HANDLE  hEvent;
} OVERLAPPED, *LPOVERLAPPED;
*/

class CUSBPipe
{
public:
  CUSBPipe(UCHAR aEndpointAddress);

  UCHAR EndpointAddress;
  OVERLAPPED DeviceOverlapped;
};

CUSBPipe::CUSBPipe(UCHAR aEndpointAddress): 
  EndpointAddress(aEndpointAddress)
  DeviceOverlapped()
{
}

int main()
{
CUSBPipe P(0x82);
std::cout << "Internal    : "  << P.DeviceOverlapped.Internal     << std::endl
          << "InternalHigh: "  << P.DeviceOverlapped.InternalHigh << std::endl 
          << "Pointer     : "  << P.DeviceOverlapped.Pointer      << std::endl 
          << "hEvent      : "  << P.DeviceOverlapped.hEvent       << std::endl;

  return 0;
}

darthdespotism

Du kannst der struct einen Konstruktor geben und diesen dann aus der Initialisierungsliste aufrufen

BerndD

Ja aber die Struktur OVERLAPPED ist aus winbase.h. Da kann ich doch nichts verändern. Geht das nicht ohne Konstruktor?

*D*Evil

Nicht per Initialisierungsliste ...

Swordfish

Naja, dass es auf biegen und brechen nicht gehen würde...

class foo_t {
	private:
		struct bar_t {
			int m_a, m_b;
		} m_bar;

		static bar_t& create_bar( int a, int b ) {
			static bar_t bar;
			bar.m_a = a;
			bar.m_b = b;
			return bar;
		}

	public:
		foo_t( int a, int b )
			: m_bar( create_bar( a, b ) ) {
		}
};

...aber dann kannst du ebensogut den c-tor der Klasse bemühen.

greetz, Swordfish

camper

Swordfish schrieb:

Naja, dass es auf biegen und brechen nicht gehen würde...
class foo_t {
	private:
		struct bar_t {
			int m_a, m_b;
		} m_bar;

		static bar_t& create_bar( int a, int b ) {
			static bar_t bar;
			bar.m_a = a;
			bar.m_b = b;
			return bar;
		}

	public:
		foo_t( int a, int b )
			: m_bar( create_bar( a, b ) ) {
		}
};
...aber dann kannst du ebensogut den c-tor der Klasse bemühen.

greetz, Swordfish

Abgesehen vom static ist das der richtige Ansatz, create_bar ist dann im Grunde so etwas wie ein benannter Konstruktor.

bar_t create_bar( int a, int b ) {
    bar_t bar;
    bar.m_a = a;
    bar.m_b = b;
    return bar;
}

Alle eventuell anfallenden Kopien können trivial eliminiert werden, dies ist also genauso effizient wie direkte Initialisierung.

Swordfish

Hm, komisch. Ich hab' mir aus unerfindlichen Gründen sorgen gemacht, die neue Instanz könnte vor dem kopieren noch irgendwo flötengehen. Deshalb Paranoia-Ref. und static...

greetz, Swordfish