Учебный пример ООП

#include <vector>
#include <iostream>
#include <chrono>
 
#define DEFAULT_COUNT 10000000
 
class A{
public:
    virtual int call(int _i, int _k)
    {
        return _i * _k;
    }
};
 
class B {
public:
    int call(int _i, int _k)
    {
        return _i * _k;
    }
};
 
template<typename Func, typename T, size_t N = DEFAULT_COUNT>
std::pair<double, std::vector<int>> test(T& a, Func _f)
{
    std::vector<int> vdata(N, 1);
 
    auto vstart = std::chrono::high_resolution_clock::now();
    for (auto& i : vdata)
    {
        i = _f(a, i, 2);
    }
    auto vend = std::chrono::high_resolution_clock::now();
 
    std::chrono::duration<double> vdelta = vend - vstart;
    return std::make_pair(vdelta.count(), std::move(vdata));
}
 
int main()
{
    A a;
    B b;
 
    auto ra = test(a, [](auto& a, int i, int k) { return a.call(i, k); });
    auto rb = test(b, [](auto& a, int i, int k) { return a.call(i, k); });
    auto rd = test(a, [](auto& a, int i, int k) { return i * k; });
    
    std::cout << "a" << ra.first << std::endl;
    std::cout << "b" << rb.first << std::endl;
    std::cout << "d" << rd.first << std::endl;
    std::cout << "a/b == " << ra.first / rb.first << std::endl;
    std::cout << "a/d == " << ra.first / rb.first << std::endl;
    std::cout << "b/d == " << rd.first / rd.first << std::endl;
 
    auto iterA = ra.second.begin();
    auto iterB = rb.second.begin();
    auto iterD = rd.second.begin();
 
    bool eq = true;
    for (; iterA != ra.second.end(); ++iterA, ++iterB, ++iterD)
    {
        if (*iterA != *iterB)
        {
            eq = false;
            break;
        }
        if (*iterA != *iterD)
        {
            eq = false;
            break;
        }
    }
 
    std::cout << "eq == " << eq << std::endl;
    
    return 0;
}
/*Output:
a0.0323317
b0.015641
d0.0150073
a/b == 2.06711
a/d == 2.06711
b/d == 1
eq == 1
*/

#include <vector>
#include <iostream>
#include <chrono>
#include <cmath>
 
#define DEFAULT_COUNT 10 * 1000 * 1000
 
inline float Calc( int a, int b )
{
    return atan2((float) a + 0.5f, (float) b);
//  return a * b;
}
 
class A{
public:
    virtual int call(int _i, int _k)
    {
        return Calc(_i, _k);
    }
};
 
class B {
public:
    int call(int _i, int _k)
    {
        return Calc(_i, _k);
    }
};
 
template<typename Func, typename T, size_t N = DEFAULT_COUNT>
std::pair<double, std::vector<int>> test(T& a, Func _f)
{
    std::vector<int> vdata(N, 1);
 
    auto vstart = std::chrono::high_resolution_clock::now();
    for (auto& i : vdata)
    {
        i = _f(a, i, 2);
    }
    auto vend = std::chrono::high_resolution_clock::now();
 
    std::chrono::duration<double> vdelta = vend - vstart;
    return std::make_pair(vdelta.count(), std::move(vdata));
}
 
int main()
{
    A a;
    B b;
 
    auto ra = test(a, [](A & a, int i, int k) { return a.call(i, k); });
    auto rb = test(b, [](B & a, int i, int k) { return a.call(i, k); });
    auto rd = test(a, [](A & a, int i, int k) { return Calc(i, k); });
    
    std::cout << "a" << ra.first << std::endl;
    std::cout << "b" << rb.first << std::endl;
    std::cout << "d" << rd.first << std::endl;
    std::cout << "a/b == " << ra.first / rb.first << std::endl;
    std::cout << "a/d == " << ra.first / rb.first << std::endl;
    std::cout << "b/d == " << rd.first / rd.first << std::endl;
 
    auto iterA = ra.second.begin();
    auto iterB = rb.second.begin();
    auto iterD = rd.second.begin();
 
    bool eq = true;
    for (; iterA != ra.second.end(); ++iterA, ++iterB, ++iterD)
    {
        if (*iterA != *iterB)
        {
            eq = false;
            break;
        }
        if (*iterA != *iterD)
        {
            eq = false;
            break;
        }
    }
 
    std::cout << "eq == " << eq << std::endl;
    
    return 0;
}

#include <vector>
#include <iostream>
#include <chrono>
 
#define DEFAULT_COUNT 10000000
 
class A{
public:
    virtual int call(int _i, int _k)
    {
        return get(_i) * get(_k);
    }
    virtual int get(int _x)
    {
        return _x;
    }
};
 
class B {
public:
    int call(int _i, int _k)
    {
        return get(_i) * get(_k);
    }
    int get(int _x)
    {
        return _x;
    }
};
 
template<typename Func, typename T, size_t N = DEFAULT_COUNT>
std::pair<double, std::vector<int>> test(T& a, Func _f)
{
    std::vector<int> vdata(N, 1);
 
    auto vstart = std::chrono::high_resolution_clock::now();
    for (auto& i : vdata)
    {
        i = _f(a, i, 2);
    }
    auto vend = std::chrono::high_resolution_clock::now();
 
    std::chrono::duration<double> vdelta = vend - vstart;
    return std::make_pair(vdelta.count(), std::move(vdata));
}
 
int main()
{
    A a;
    B b;
 
    auto ra = test(a, [](auto& a, int i, int k) { return a.call(i, k); });
    auto rb = test(b, [](auto& a, int i, int k) { return a.call(i, k); });
    auto rd = test(a, [](auto& a, int i, int k) { return i * k; });
    
    std::cout << "a" << ra.first << std::endl;
    std::cout << "b" << rb.first << std::endl;
    std::cout << "d" << rd.first << std::endl;
    std::cout << "a/b == " << ra.first / rb.first << std::endl;
    std::cout << "a/d == " << ra.first / rd.first << std::endl;
    std::cout << "b/d == " << rb.first / rd.first << std::endl;
 
    auto iterA = ra.second.begin();
    auto iterB = rb.second.begin();
    auto iterD = rd.second.begin();
 
    bool eq = true;
    for (; iterA != ra.second.end(); ++iterA, ++iterB, ++iterD)
    {
        if (*iterA != *iterB)
        {
            eq = false;
            break;
        }
        if (*iterA != *iterD)
        {
            eq = false;
            break;
        }
    }
 
    std::cout << "eq == " << eq << std::endl;
    
    return 0;
}
/*Output:
a0.0806079
b0.0165149
d0.0144553
a/b == 4.88092
a/d == 5.57634
b/d == 1.14248
eq == 1
*/