Administrace komentářů

I když se z C++ dají volat C knihovny přímo, přijde mi lepší si nad tím udělat třídy v C++, kterými se to obalí, což usnadní správu paměti a člověk nezapomene příslušný zdroj zavřít – prostě se to zavře samo, když skončí platnost proměnné.

C knihovny většinou vrací při otevření zdroje (např. USB zařízení) nějakou strukturu a na konci je potřeba ji poslat do nějaké close() funkce, kde se daná knihovna postará o uvolnění zdrojů. V C++ si tuto strukturu vytvoříme v konstruktoru a uložíme do instanční proměnné. V destruktoru pak zavoláme tu close() funkci. Tohle vypadá jednoduše a v funguje to… dokud instanci naší třídy nepředáme někam dál jako parametr, což způsobí kopii a následně se zavolá close() v destruktoru kopie, což nám ale znefunkční i původní instanci. Takže je potřeba zakázat kopírování (privátní kopírovací konstruktor) a objekt předávat jen referencí. Došel jsem k něčemu takovému, když jsem si hrál s USB HID API:

class HIDDevice {
private:
	hid_device* handle;

	HIDDevice(const HIDDevice& other) : handle(other.handle) {
	}

public:

	HIDDevice(unsigned short vendorId, unsigned short productId, const wchar_t *serialNumber) {
		int initError = hid_init(); // TODO: move to HIDContext class?
		if (initError) throw HIDException(L"Unable to init HID API.");
		handle = hid_open(vendorId, productId, serialNumber);
		if (handle == nullptr) throw HIDException(L"Unable to open HID device. Are you root? Is mouse present?");
	}

	virtual ~HIDDevice() {
		hid_close(handle);
		hid_exit(); // TODO: move to HIDContext class?
	}

	const std::wstring getManufacturerName() const {
		std::array<wchar_t, 200 > buffer;
		int error = hid_get_manufacturer_string(handle, buffer.data(), buffer.size());
		if (error) throw HIDException(L"Unable to get manufacturer name.");
		return buffer.data();
	}

	const std::wstring getProductName() const {
		std::array<wchar_t, 200 > buffer;
		int error = hid_get_product_string(handle, buffer.data(), buffer.size());
		if (error) throw HIDException(L"Unable to get product name.");
		return buffer.data();
	}

	void sendFeatureReport(std::vector<unsigned char> data) {
		int written = hid_send_feature_report(handle, data.data(), data.size());
		if (written < 0) throw HIDException(L"Unable to send feature report.");
	}

};

Je to takhle správně? Jaké jsou další možnosti?

Když si vystačím s předáváním referencí, tak mi to přijde funkční. Ale co když chci ten objekt předat někam dál a nechat ho tam žít, i když původní metoda skončí (a tím zanikne i ta původní proměnná)? Je potřeba to předávat obalené v chytrém ukazateli? To by fungovalo, ale přijde mi to trochu ošklivé, znepřehledňuje to kód. Víc by se mi líbilo, kdyby se předávala kopie a ten chytrý ukazatel si udržovala uvnitř. Znamená to tedy nutnost si udělat další třídu, která se bude spravovat v tom vnitřním chytrém ukazateli a bude držet jen to hid_device a ve svém destruktoru ho zavírat? Jak byste tohle řešili? V zásadě bych chtěl, aby se HIDDevice chovalo jako chytrý ukazatel a rád bych to implementoval nějak elegantně s minimem kódu.