Dotaz: C++ Auto proxy class

[hermes]

Ahojte potreboval by som rozšíriť objekt (nie triedu) o pár metód. V dynamickom jazyku by sa to dalo naprasiť cez monkey patching. Staticky typované jazyky zase obsahujú extension metódy prípadne mixiny.

Ale ako podobný problém riešiť v C++? Predstavujem si to tak, že by som urobil wrapper, ktorý by bol potomkom pôvodnej triedy a rozšíril ho o nové metódy. A do jeho vnútra, by som cez konštruktor nainjektoval pôvodný objekt.

Ale potom by som musel wrapnúť aj všetky pôvodné volania metód, metódu po metóde. Ručne sa mi to prepisovať nechce. A keďže C++ podporuje metaprogramovanie myslím, že by sa to dalo nejako uľahčiť. Ale ako? Ako sa takéto problémy riešia v C++?

Odpovědi

[Jardík]

Jakéhosi rozšíření lze docílit přes ADL, ale asi to nebude úplně ono. Řekněme, že máte nějakou třídu s metodou (mysum) a chceš takovou metodu implementovat pro jinou třídu, kterou NEMŮŽEŠ modifikovat (např. 3rdparty knihovna). Zároveň chceš třídu třeba předat jako template parametr.

https://godbolt.org/z/T4f4TThYb

namespace myns
{

struct myclass
{
  int a() const { return 5; }
  int b() const { return 6; }
  int mysum() const { return a() + b(); }
};

// Enable ADL mysum call for myclass
int mysum(const myclass& m)
{
  return m.mysum();
}

}

// -- 3rdparty knihovna --

namespace thirdparty
{

struct thirdpartyclass
{
  int abc() const { return 5; }
  int def() const { return 6; }
};

}

// -- vlastni kod, implementovat mysum pro thirdpartyclass, musi byt ve stejnem namespace jako thirdpartyclass, aby fungovalo ADL

namespace thirdparty
{
int mysum(const thirdpartyclass& t)
{
  return t.abc() + t.def();
}
}

// -- pouziti v template:

namespace totalydifferentnamespace
{
template<class... T>
int getSumOfSums(const T&... t)
{
  return (mysum(t) + ...); // Zde se vyuzije ADL, zavola se metoda mysum z namespace, kde je kazda trida definovana
}
}

int main()
{
  myns::myclass mc;
  thirdparty::thirdpartyclass t;

  return totalydifferentnamespace::getSumOfSums(mc, t); // 11+11=22
}

[Jardík]

DalŠí možností můŽe být třeba nějaký wrapper a specializace. Prostě záleží, co od toho čekáš.

namespace myns
{

struct myclass
{
  int a() const { return 5; }
  int b() const { return 6; }
  int mysum() const { return a() + b(); }
};

}

// -- 3rdparty knihovna --

namespace thirdparty
{

struct thirdpartyclass
{
  int abc() const { return 5; }
  int def() const { return 6; }
};

}

// -- 

namespace totalydifferentnamespace
{
template<class... T>
int getSumOfSums(const T&... t)
{
  return (t.mysum() + ...); // Zde se vyuzije ADL, zavola se metoda mysum z namespace, kde je kazda trida definovana
}
}

template<typename T>
struct mysuminterface // not specialized
{
    int mysum() const { return 0; }
};

// specialzed for myns::myclass
template<>
struct mysuminterface<myns::myclass> : myns::myclass
{
    using myns::myclass::mysum;
};

// specialzed for thirdparty::thirdpartyclass
template<>
struct mysuminterface<thirdparty::thirdpartyclass> : thirdparty::thirdpartyclass
{
    int mysum() const { return abc() + def(); }
};

int main()
{
    mysuminterface<myns::myclass> mc;
    mysuminterface<thirdparty::thirdpartyclass> t;
    return totalydifferentnamespace::getSumOfSums(mc, t); // 11+11=22
}

[hermes]

Diky :)

[Gréta]

proč jakoby nestačí podědit nějakej trait a musí se 'hackovat' hotová instance?? :O :O

[hermes]

Ahojte, ďakujem Vám za odpovede idem si to prelúskať.