ChatGPT může vidět, slyšet a mluvit.
Upscaler je open source nástroj pro zvýšení rozlišení a vylepšení obrázků pomocí AI. Vývoj probíhá na GitLabu. Instalovat lze také z Flathubu. Stejně jako Upscayl je Upscaler postaven nad Real-ESRGAN.
GNUnet (Wikipedie) byl vydán v nové major verzi 0.20.0. Jedná se o framework pro decentralizované peer-to-peer síťování, na kterém je postavena řada aplikací.
V Dublinu o víkendu proběhla dvanáctá iterace multimediální konference Video Dev Days, kterou pravidelně pořádá nezisková organizace VideoLAN. Záznamy přednášek z prvního a druhého dne jsou dostupné na YouTube.
LibrePCB, tj. svobodný multiplatformní softwarový nástroj pro návrh desek plošných spojů (PCB), dospěl po pěti letech vývoje do verze 1.0.0. Přehled novinek v příspěvku na blogu a v aktualizované dokumentaci. Zdrojové kódy jsou k dispozici na GitHubu pod licencí GPLv3.
Facebook má nové logo. Poznáte rozdíl?
Byla vydána nová verze 7.2 v Javě napsané aplikace pro komplexní návrh rozmístění nábytku a dalšího vybavení v interiérech Sweet Home 3D. Vyzkoušet lze online verzi. Před dvěma týdny vyšla placená verze pro chytré telefony a tablety (App Store, Google Play).
Zítra 23. září proběhne Maker Faire Mladá Boleslav, festival plný workshopů, interaktivních činností a především nadšených a zvídavých lidí.
Byla vydána beta verze Ubuntu 23.10 s kódovým názvem Mantic Minotaur. Přehled novinek v poznámkách k vydání. Dle plánu by Ubuntu 23.10 mělo vyjít 12. října 2023.
Josef Průša informuje o nových verzích firmwarů pro tiskárny Original Prusa, 5.0.0 pro MK4 a MK3.9 a 5.1.0-alpha1 pro MINI, díky kterým jsou tiskárny mnohem rychlejší.
#include <string> #include <iostream> class Base { public: std::string x; int y; Base(std::string x_, int y_): x(x_), y(y_) {} Base(Base &&b): x(std::move(b.x)), y(b.y) {} virtual ~Base() {} virtual void do_something() = 0; virtual void turn_to_a() {} }; class B; class A: public Base { public: A(B &&b); A(std::string x_, int y_): Base(x_, y_) {} void do_something() override { std::cout << "I am 'A'. x = " << x << ", y = " << y << "\n"; } }; class B: public Base { public: B(std::string x_, int y_): Base(x_, y_) {} void do_something() override { std::cout << "I am 'B'. x = " << x << ", y = " << y << "\n"; } void turn_to_a() override { static_assert(sizeof(A) == sizeof(B), "must be the same size"); B tmp(std::move(*this)); this->B::~B(); new (this) A(std::move(tmp)); } }; A::A(B &&b): Base(std::move(b)) {} int main() { Base *b = new B("life, universe and everything", 42); b->do_something(); b->turn_to_a(); b->do_something(); delete b; }
Řešení dotazu:
union
?
bool is_a;
. A potom v kazdy metode testoval jestli je flag nastaveny, ale prijde me ze mit to oddeleny je o neco cistsi.
Dejme tomu ze mam 2 tridy - A a B. Obe dedi z tridy Base. Nepridavaji zadne promenne, jen predefinuji virtualni funkce. Program nacita data a vetsinou z nich chce vytvorit tridu B. Obcas ale A a problem je ze tuto informaci se dozvi az pozdeji. Kdyz se dozvi ze vlastne potrebuje A tak nechci aby musel alokovat novou pamet, ani aby musel zpetne menit pointery ktere uz ukazuji na B.Začalo to hezky, skoro jako v pohádce: Žily byly dvě sestry, jedna staříkova, druhá stařenčina ... ... ale zápletka na sebe nenechala dlouho čekat. Pokud program chce "většinou" vytvořit třídu B, ale někdy později ji chce vyměnit za A, tak najednou se po nás chce zajistit dynamické chování ve statickém světě dědičnosti tříd. Prostě z jezevčíka mávnutím kouzelné hůlky udělat dobrmana. Vždyť je to přeci také pes. Použití operátoru new s umístěním je ale stejné jako nahánění jezevčíka s chirurgickým skalpelem v ruce. Když se na to podívám z druhé strany, tak vlastně nepotřebuji předělávat jezevčíka na dobrmana, ale chci jen naučit psa kousat jako dobrman, aby mi nikdo nechodil po dvorku. Pokud nejsem psí zubař, tak mohu tedy skalpel s klidem zahodit
#include <iostream> enum StrategyType { A, B }; class Strategy { protected: std::string* x; int* y; public: void setOptions(std::string* _x, int* _y) { x = _x; y = _y; } virtual void doSomething() = 0; }; class StrategyA : public Strategy { virtual void doSomething() { std::cout << "I am 'A'. x = " << *x << ", y = " << *y << std::endl; } }; class StrategyB : public Strategy { virtual void doSomething() { std::cout << "I am 'B'. x = " << *x << ", y = " << *y << std::endl; } }; class Base { private: std::string x; int y; Strategy* strategy; public: Base(std::string x_, int y_): x(x_), y(y_), strategy(NULL) {} ~Base() { delete strategy; } void doSomething() { strategy->doSomething(); } void setStrategy(StrategyType type) { if (strategy) delete strategy; if (type == A) strategy = new StrategyA(); else if (type == B) strategy = new StrategyB(); strategy->setOptions(&x, &y); } }; int main() { Base base("life, universe and everything", 42); base.setStrategy(B); base.doSomething(); // ... base.setStrategy(A); base.doSomething(); return 0; }Oproti zadání je možné měnit strategie nejen z B na A, ale i zpět a navíc opakovaně.
template<typename T> class Wrap { public: T* new_() { return new(this) T();} void delete_() { ((T*)this)->~T(); } unsigned char data[sizeof(T)]; }; class Base { public: Base() {} virtual ~Base() {} virtual int getType() const = 0; int a; int b; }; class A : public Base { public: A() {} virtual ~A() {} virtual int getType() const { return 1; } }; class B : public Base { public: B() {} virtual ~B() {} virtual int getType() const { return 2; } }; union Union { template<typename T> T* as() { return (T*)this; } Wrap<A> a; Wrap<B> b; }; int main(int argc, char* argv[]) { Union u; u.a.new_(); printf("%d\n", u.as<Base>()->getType()); u.a.delete_(); u.b.new_(); printf("%d\n", u.as<Base>()->getType()); u.b.delete_(); return 0; }
Tiskni
Sdílej: