class A{
  public:
    double p1, p2;
    virtual double fun(p1,p2) = 0;
}

class B{
  public:
    double p1,p2;
    double fun(p1,p2) {...};
}

class C{
  public:
    double p1,p2;
    double fun(p1,p2) {...};
}

void proc(A* a) {
  ...
}

int main() {
  B b;
  C c;
  A* a[2];
  a[0]=&b;
  a[1]=&c;

  proc(a);
}

class A {
  public:
    double p1, p2;
    virtual double fun(p1,p2) = 0;
};

class B: public A {
  public:
    double fun(p1,p2) {...};
};

class C: public A {
  public:
    double fun(p1,p2) {...};
};

void proc(A** a) {
}

class A { ... };
class B : public A { ... };
class C : public A { ... };

void proc(vector<shared_ptr<A>> & a) {
 ...
}

int main() {
  vector<shared_ptr<A>> a;
  a.push_back(shared_ptr<A>(new B()));
  a.push_back(shared_ptr<A>(new C()));

  proc(a);
  return 0;
}

template <typename T>
void p(T &arg)
{
  for_each(arg.begin(), arg.end(), [] (shared_ptr <A> &a) {
    a->foo();
  });
}

int main()
{
  list <shared_ptr <A> > a;
  a.push_back(make_shared <B> ());
  a.push_back(make_shared <C> ());
  p(a);
}

prog.cpp:6:24: error: ‘p1’ is not a type
prog.cpp:6:27: error: ‘p2’ is not a type
prog.cpp:11:16: error: ‘p1’ is not a type
prog.cpp:11:19: error: ‘p2’ is not a type
prog.cpp: In member function ‘virtual double B::fun(int, int)’:
prog.cpp:12:6: error: ‘cout’ was not declared in this scope
prog.cpp:13:2: warning: no return statement in function returning non-void [-Wreturn-type]
prog.cpp: At global scope:
prog.cpp:18:16: error: ‘p1’ is not a type
prog.cpp:18:19: error: ‘p2’ is not a type
prog.cpp: In member function ‘virtual double C::fun(int, int)’:
prog.cpp:19:3: error: ‘cout’ was not declared in this scope
prog.cpp:20:2: warning: no return statement in function returning non-void [-Wreturn-type]
prog.cpp: In function ‘void proc(A**)’:
prog.cpp:24:12: error: no matching function for call to ‘A::fun()’
prog.cpp:24:12: note: candidate is:
prog.cpp:6:20: note: virtual double A::fun(int, int)
prog.cpp:6:20: note:   candidate expects 2 arguments, 0 provided

struct A
{
    virtual ~A() {}
};

struct B : A
{
    virtual ~B() {}
};

#include <iostream>
using namespace std;
 
class A {
public:
    double p1, p2;
    virtual double fun(double p1,double p2) = 0;
    virtual ~A() {}
};
 
class B: public A {
public:
    double fun(double p1,double p2) {
        cout << p1+p2 << endl;
    };
};
 
class C: public A {
public:
    double fun(double p1,double p2) {
        cout << p1-p2 << endl;;
    };
};
 
void proc(A** a,double p1,double p2) {
    for (int i = 0; i < 2; ++i)
        a[i]->fun(p1,p2);
}
 
int main() {
    double p1, p2;
    p1 = 1.0;
    p2 = 2.0;
    B b;
    C c;
    A* a[2];
    a[0]=&b;
    a[1]=&c;
 
    proc(a,p1,p2);
}

class A {
public:
    virtual double fun(double p1,double p2) = 0;
    virtual ~A() {}
};

#include <iostream>
#include <vector>
using namespace std;

struct A // struct - экономия места
{
    virtual ~A() {}
    virtual void fn(double a, double b) = 0;
};

struct B : A
{
    virtual ~B() {} // в потомках тоже надо указывать
    virtual void fn(double a, double b) // разрешить переопределение в потомках
    { cout << a + b << endl; }
};

struct C : A
{
    virtual ~C() {}
    void fn(double a, double b)
    { cout << a - b << endl; }
};

template<class Iter, class T>
void proc(Iter beg, Iter end, T a, T b)
{ for(;beg != end; ++beg) (*beg)->fn(a, b); }

int main()
{
    B b1, b2;
    C c1, c2;
    A *arr[] = { &b1, &c2, &b2, &c1 }
    , **arr_end = arr + sizeof(arr) / sizeof(arr[0]);
    proc(arr, arr_end, 321, 123);
    
    vector<A *> vec(arr, arr_end);
    proc(vec.begin(), vec.end(), 123, 321);

    return 0; // программа должна вернуть значение
}

numas@gnunix:~$ g++ -O2 -std=c++98 -Wall -o app app.cpp
numas@gnunix:~$ ./app 
444
198
444
198
444
-198
444
-198
numas@gnunix:~$ 

#include <iostream>
using namespace std;
 
class A {
public:
    double p1, p2;
    virtual void fun() = 0;
    virtual ~A() {}
};
 
class B: public A {
public:
    void fun() {cout << p1+p2 << endl;}
    virtual ~B() {}
};
 
class C: public A {
public:
    void fun() {cout << p1-p2 << endl;}
    virtual ~C() {}
};
 
void proc(A** a) {
    for (int i = 0; i < 2; ++i)
        a[i]->fun();
}
 
int main() {
    B b;
    C c;
    b.p1 = 2.0;
    b.p2 = 1.5;
    c.p1 = 3.0;
    c.p2 = -0.5;
    A* a[2];
    a[0]=&b;
    a[1]=&c;
 
    proc(a);

return 0;
}

, **arr_end = arr + sizeof(arr) / sizeof(arr[0]);
proc(arr, arr_end, 321, 123);
    
vector<A *> vec(arr, arr_end);

, **arr_end = arr + sizeof(arr) / sizeof(arr[0])

proc(arr, arr_end, 321, 123);

vector<A *> vec(arr, arr_end);

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;
 
struct A {
    double p1, p2;
    virtual void fun() = 0;
    virtual ~A() {}
};
 
struct B: A {
    void fun() {cout << p1+p2 << endl;}
};
 
struct C: A {
    void fun() {cout << p1-p2 << endl;}
};
 
void proc(vector<A*>& a) {
    for_each(a.begin(),a.end(),mem_fun(&A::fun));
}
 
int main() {
    B b;
    C c;
    b.p1 = 2.0;
    b.p2 = 1.5;
    c.p1 = 2.0;
    c.p2 = 1.5;

    vector<A*> a(2);
    a.at(0) = &b;
    a.at(1) = &c;
 
    proc(a);

    return 0;
}

vector<A*> a(2);
a.at(0) = &b;
a.at(1) = &c;

vector<A*> a;
a.push_back(&b);
a.push_back(&c);

typedef struct {
  uint8_t id;
  uint64_t a, b, c;
} m_id0_t;

typedef struct {
  uint8_t id;
  uint64_t a, b;
} m_id1_t;

typedef void *(*id_headler_t)(void *);

void * id0_headler(void * ptr) {
  m_id0_t * my_data = ptr;
  fprintf(stderr, "id = %u, a = %lu, b = %lu, c = %lu\n", my_data->id, my_data->a, my_data->b, my_data->c);    
  return ++my_data;
}

void * id1_headler(void * ptr) {
  m_id1_t * my_data = ptr;
  fprintf(stderr, "id = %u, a = %lu, b = %lu\n", my_data->id, my_data->a, my_data->b);    
  return ++my_data;
}

id_headler_t id_headles[] = {
  id0_headler,
  id1_headler
};

#define END 0xff
inline void call_headers(void * ptr) {
  do {
    ptr = id_headles[*(uint8_t*)ptr](ptr);
  } while(*(uint8_t*)ptr != END);
}

inline m_id0_t * create_id0(m_id0_t * ptr, uint64_t a, uint64_t b, uint64_t c) {
  ptr->id = 0,ptr->a = a, ptr->b = b, ptr->c = c;
  return ++ptr;
}
inline m_id1_t * create_id1(m_id1_t * ptr, uint64_t a, uint64_t b) {
  ptr->id = 1, ptr->a = a, ptr->b = b;
  return ++ptr;
}
inline void * set_end(uint8_t * ptr) {
  *ptr = END;
  return ++ptr;
}

int main(void) {
  void * pull = malloc(100500), * begin = pull;
  pull = create_id0(pull, 100123, 100223, 100323);
  pull = create_id1(pull, 200123, 200223);
  pull = set_end(pull); 
  call_headers(begin);
}