Na čem aktuálně pracují vývojáři GNOME a KDE Plasma? Pravidelný přehled novinek v Týden v GNOME a Týden v KDE Plasma. Vypíchnout lze, že v Plasmě byl implementován 22letý požadavek. Historie schránky nově umožňuje ohvězdičkovat vybrané položky a mít k ním trvalý a snadný přístup.
Wayfire, kompozitní správce oken běžící nad Waylandem a využívající wlroots, byl vydán ve verzi 0.10.0. Zdrojové kódy jsou k dispozici na GitHubu. Videoukázky na YouTube.
Před necelými čtyřmi měsíci byl Steven Deobald jmenován novým výkonným ředitelem GNOME Foundation. Včera skončil, protože "nebyl pro tuto roli v tento čas ten pravý".
Nové číslo časopisu Raspberry Pi zdarma ke čtení: Raspberry Pi Official Magazine 156 (pdf).
Armbian, tj. linuxová distribuce založená na Debianu a Ubuntu optimalizovaná pro jednodeskové počítače na platformě ARM a RISC-V, ke stažení ale také pro Intel a AMD, byl vydán ve verzi 25.8.1. Přehled novinek v Changelogu.
Včera večer měl na YouTube premiéru dokumentární film Python: The Documentary | An origin story.
Společnost comma.ai po třech letech od vydání verze 0.9 vydala novou verzi 0.10 open source pokročilého asistenčního systému pro řidiče openpilot (Wikipedie). Zdrojové kódy jsou k dispozici na GitHubu.
Ubuntu nově pro testování nových verzí vydává měsíční snapshoty. Dnes vyšel 4. snapshot Ubuntu 25.10 (Questing Quokka).
Řada vestavěných počítačových desek a vývojových platforem NVIDIA Jetson se rozrostla o NVIDIA Jetson Thor. Ve srovnání se svým předchůdcem NVIDIA Jetson Orin nabízí 7,5krát vyšší výpočetní výkon umělé inteligence a 3,5krát vyšší energetickou účinnost. Softwarový stack NVIDIA JetPack 7 je založen na Ubuntu 24.04 LTS.
Národní úřad pro kybernetickou a informační bezpečnost (NÚKIB) spolu s NSA a dalšími americkými úřady upozorňuje (en) na čínského aktéra Salt Typhoon, který kompromituje sítě po celém světě.
Snazim se v jednom Qt projektu vylepsit system callbacku. Callback v sobe ma pointer na objekt, na kterym se ma provest a nazev funkce, ktera se ma spustit. Pouzivam QMetaObject::invokeMethod a tim padem je to zavisle na MOC a funkce musi byt bud slot nebo Q_INVOKABLE.
Dostal jsem napad, jak se toho zbavit.
Kod je zde
#include <typeinfo> #include <typeindex> class functor { public: template <typename A, typename... Ts> inline functor(A *o, void (A::*f)(Ts... args)) { avec.insert(avec.end(), {typeid(Ts)...}); obj = o; func = reinterpret_cast< void (functor::*)() >(f); } template <typename... Ts> inline void operator()(Ts... args) { std::vector<std::type_index> vec; // argumenty volani vec.insert(vec.end(), {typeid(Ts)...}); if(avec == vec) { void (functor::*f)(Ts ...) = reinterpret_cast<void (functor::*)(Ts ...)>(func); (reinterpret_cast<functor*>(obj)->*f)(args ...); } else qDebug() << "functor invoked with bad arguments"; } private: void (functor::*func)(); void *obj; std::vector<std::type_index> avec; // argumenty callbacku };
Pouziti je jednoduchy, viz priklad. Vyhoda oproti jinym podobnym vecem je v tom, ze kontrola typu argumentu se deje v runtime a tim padem muzou mit vsechny callbacky jeden typ (i kdyz volaji funkce s ruznyma argumentama).
base *t = new base(); functor f(t, &base::torture); // vytvorim callback f(); // zavolam ho
Rad bych od vas dostal nazor, jestli je to dobry napad, nebo neni, a proc (pripadne jestli nekde neumiraji kotatka kdyz delam reinterpret_cast).
Tiskni
Sdílej:
A *o
na *functor
, možná to jen nechápu...
struct { size_t a; size_t b; };
Nejspíš by se i našel způsob, jak během compile-time zjistit, jestli ten member func pointer není větší...
operator ()
, protože tam se to castuje na jiný typ, než který byl uložený, a každý může mít jinak velké member pointery.
#ifndef NDEBUG ... #endif
)
at
je hází úmyslně, neházející verze je operator []
.
GCC má debug verzi STL, která asserty obsahuje.
typeid(void(Ts...))
nebo neco podobneho.
template <typename ReturnT, typename... ParamTs> class Callback { protected: struct Iface { virtual ~Iface() {} virtual ReturnT operator ()(ParamTs... params) = 0; }; template <typename Type> struct Impl : public Iface { using Func = ReturnT (Type::*)(ParamTs...); Impl(Type &obj, Func func) : obj(obj) , func(func) {} virtual ~Impl() {} virtual ReturnT operator ()(ParamTs... params) { return std::forward<ReturnT>(obj.*func(std::forward<ParamTs...>(params))); } Type &obj; Func func; }; Iface& iface() { return *reinterpret_cast<Iface*>(buf); } size_t buf[4]; public: template <typename Type> Callback(Type &obj, typename Impl<Type>::Func func) { // Místo static_assert lze upravit, aby to použilo new static_assert(sizeof(Impl<Type>) <= sizeof(buf), "Buffer not large enough to capture callback"); new (buf) Impl<Type>(obj, func); } ~Callback() { iface().~Iface(); } ReturnT operator ()(ParamTs... params) { return std::forward<ReturnT>(iface()(std::forward<ParamTs...>(params))); } }; Callback callback(t, &Type::getValueForInput); int value = callback(input);
std::forward
na návratové hodnoty je zbytečný, navíc nebude fungovat s void
.
virtual ReturnT operator ()(ParamTs... params)
a virtual ~Impl()
v Impl
by bylo lepší označit override
.
Callback
templatová třída, pak se rovnou může použít std::function
, ne?
operator ()
) by šlo zabalit přes reinterpret_cast, protože není polymorfní (takže je to jen pointer na funkci, kde první parametr je this
), ale nebude to ověřovat typy parametrů.
Ten reinterpret_cast v původní implementaci nebude fungovat, pokud bude castovat z polymorfní třídy na nepolymorfní či obráceně, a nejspíš ani pokud bude mezi různými stromy polymorfních tříd, protože u virtuálních metod je to typicky implementováno jako index do vtable, nikoliv pointer.
class functor { protected: struct iface { virtual ~iface(){}; }; template <typename... Ts> struct args : public iface { virtual void call(Ts...) = 0; }; template <typename A, typename... Ts> struct impl : public args<Ts...> { A* obj; void (A::*func)(Ts...); impl(A* o, void (A::*f)(Ts...)) : obj(o), func(f) {} void call(Ts... args) { (obj->*func)(args...); } }; size_t i[4]; public: template<typename A, typename... Ts> functor(A* o, void (A::*f)(Ts...)) { static_assert(sizeof(impl<A, Ts...>) <= sizeof(i), "Buffer not large enough to capture callback"); new (i) impl<A, Ts...>(o,f); } template<typename... Ts> void operator()(Ts... params) { args<Ts...> *a = dynamic_cast<args<Ts...>*>(reinterpret_cast<iface*>(i)); if(a) a->call(params...); else qDebug() << "bad parameters"; } };