#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
#include <iterator>
#include <sstream>
using namespace std;
struct BaseGoDeeper {
virtual void operator()(int i) = 0;
~BaseGoDeeper() {};
};
struct A : BaseGoDeeper {
void operator()(int /*i*/) { cout << "A" << endl; }
};
struct B : BaseGoDeeper {
void operator()(int /*i*/) { cout << "B" << endl; }
};
struct SubAlgorithm {
BaseGoDeeper& a_;
SubAlgorithm (BaseGoDeeper& a) : a_(a) {}
void operator()(int i) {
// do some stuff and then do
a_(i);
}
};
template<typename SubAlgorithm, typename Collection>
void Alrogirthm(SubAlgorithm& f, Collection& stuff) {
// In my code f is invoked ~ 1e9 times (it's a loop that is executed
// ~ 1e6 times, and stuff.size() is ~1000). The application spends ~90% of
// it's time in this function. But for the sake of example:
for_each(stuff.begin(), stuff.end(), f);
}
BaseGoDeeper* CreateGoDeeper(bool runtime_flag) {
if (runtime_flag) {
return new A();
}
return new B();
}
int main(int , char**) {
stringstream ss;
ss << true << " " << false;
vector<int> stuff;
stuff.push_back(1);
while (ss.good()) {
bool runtime_flag;
ss >> runtime_flag;
BaseGoDeeper* go_deeper_algorithm = CreateGoDeeper(runtime_flag);
SubAlgorithm sub_algorithm(*go_deeper_algorithm);
Alrogirthm(sub_algorithm, stuff);
delete go_deeper_algorithm;
}
return 0;
}
I2luY2x1ZGUgPGlvc3RyZWFtPgojaW5jbHVkZSA8dmVjdG9yPgojaW5jbHVkZSA8ZnVuY3Rpb25hbD4KI2luY2x1ZGUgPGFsZ29yaXRobT4KI2luY2x1ZGUgPGl0ZXJhdG9yPgojaW5jbHVkZSA8c3N0cmVhbT4KCnVzaW5nIG5hbWVzcGFjZSBzdGQ7CgpzdHJ1Y3QgQmFzZUdvRGVlcGVyIHsgCiAgdmlydHVhbCB2b2lkIG9wZXJhdG9yKCkoaW50IGkpID0gMDsKICB+QmFzZUdvRGVlcGVyKCkge307Cn07CgpzdHJ1Y3QgQSA6IEJhc2VHb0RlZXBlciB7IAogIHZvaWQgb3BlcmF0b3IoKShpbnQgLyppKi8pIHsgY291dCA8PCAiQSIgPDwgZW5kbDsgfSAKfTsKCnN0cnVjdCBCIDogQmFzZUdvRGVlcGVyIHsgCiAgdm9pZCBvcGVyYXRvcigpKGludCAvKmkqLykgeyBjb3V0IDw8ICJCIiA8PCBlbmRsOyB9IAp9OwoKc3RydWN0IFN1YkFsZ29yaXRobSB7CiAgQmFzZUdvRGVlcGVyJiBhXzsKICBTdWJBbGdvcml0aG0gKEJhc2VHb0RlZXBlciYgYSkgOiBhXyhhKSB7fQogIHZvaWQgb3BlcmF0b3IoKShpbnQgaSkgeyAKICAgIC8vIGRvIHNvbWUgc3R1ZmYgYW5kIHRoZW4gZG8KICAgIGFfKGkpOwogIH0KfTsKCnRlbXBsYXRlPHR5cGVuYW1lIFN1YkFsZ29yaXRobSwgdHlwZW5hbWUgQ29sbGVjdGlvbj4Kdm9pZCBBbHJvZ2lydGhtKFN1YkFsZ29yaXRobSYgZiwgQ29sbGVjdGlvbiYgc3R1ZmYpIHsKICAvLyBJbiBteSBjb2RlIGYgaXMgaW52b2tlZCB+IDFlOSB0aW1lcyAoaXQncyBhIGxvb3AgdGhhdCBpcyBleGVjdXRlZAogIC8vIH4gMWU2IHRpbWVzLCBhbmQgc3R1ZmYuc2l6ZSgpIGlzIH4xMDAwKS4gVGhlIGFwcGxpY2F0aW9uIHNwZW5kcyB+OTAlIG9mCiAgLy8gaXQncyB0aW1lIGluIHRoaXMgZnVuY3Rpb24uIEJ1dCBmb3IgdGhlIHNha2Ugb2YgZXhhbXBsZToKICBmb3JfZWFjaChzdHVmZi5iZWdpbigpLCBzdHVmZi5lbmQoKSwgZik7Cn0KCkJhc2VHb0RlZXBlciogQ3JlYXRlR29EZWVwZXIoYm9vbCBydW50aW1lX2ZsYWcpIHsKICBpZiAocnVudGltZV9mbGFnKSB7CiAgICByZXR1cm4gbmV3IEEoKTsKICB9CiAgcmV0dXJuIG5ldyBCKCk7Cn0KCmludCBtYWluKGludCAsIGNoYXIqKikgewogIHN0cmluZ3N0cmVhbSBzczsKICBzcyA8PCB0cnVlIDw8ICIgIiA8PCBmYWxzZTsKCiAgdmVjdG9yPGludD4gc3R1ZmY7CiAgc3R1ZmYucHVzaF9iYWNrKDEpOwoKICB3aGlsZSAoc3MuZ29vZCgpKSB7CiAgICBib29sIHJ1bnRpbWVfZmxhZzsKICAgIHNzID4+IHJ1bnRpbWVfZmxhZzsKCiAgICBCYXNlR29EZWVwZXIqIGdvX2RlZXBlcl9hbGdvcml0aG0gPSBDcmVhdGVHb0RlZXBlcihydW50aW1lX2ZsYWcpOwogICAgU3ViQWxnb3JpdGhtIHN1Yl9hbGdvcml0aG0oKmdvX2RlZXBlcl9hbGdvcml0aG0pOwogICAgQWxyb2dpcnRobShzdWJfYWxnb3JpdGhtLCBzdHVmZik7CiAgICBkZWxldGUgZ29fZGVlcGVyX2FsZ29yaXRobTsKICB9CiAgcmV0dXJuIDA7Cn0=