class A
{
public:
    virtual void VFunc() = 0;
};

class B: public A
{
public:
    void VFunc()
    {
        printf("class B\n");
    }
};

class C: public A
{
public:
    void VFunc()
    {
        printf("class C\n");
    }
};

// здесь можно что-то упростить?
B b = B();
C c = C();

static A *a[] = {&b, &c, 0 /*маркер конца списка*/};
static A *aa[] = {&B(), &C(), 0 /*маркер конца списка*/};
static A aaa[] = {B(), C()};

int _tmain(int argc, _TCHAR* argv[])
{
    // пока работает
    a[0]->VFunc();
    a[1]->VFunc();

    // коварно вылетает
    aa[0]->VFunc();
    aa[1]->VFunc();

    // даже не линкуется
    // в реальной проге линкуется, но идет вызов pure virtual
    aaa[0].VFunc();
    aaa[1].VFunc();

    return 0;
}

class A
CC>{
CC>public:
CC>    virtual void VFunc() = 0;
CC>};

CC>// здесь можно что-то упростить?
CC>B b = B();
CC>C c = C();

B b;
C c;

std::vector< boost::shared_ptr<A> > arr;
arr.push_back(boost::shared_ptr<A>(new B()));
arr.push_back(boost::shared_ptr<A>(new C()));

B b; C c;
A* arr1[] = { &b, &c, 0 }; // объекты отдельно, указатели отдельно, всё правильно
A* arr2[] = { &B(), &C(), 0 }; // указатели на временные объекты (которые были разрушены сразу после создания массива)
A  arr3[] = { B(), C() }; // срезка объектов типа B и C до типа A (копирование)

Итак, использование ссылок оправдано,

• когда доподлинно известно, что объект ссылки существует,
  
• когда нет необходимости изменять значение ссылки и
  
• при реализации операторов, в которых применение указателей нежелательно из-за синтаксических требований.

Во всех других случаях используйте указатели.

boost::ptr_vector<A> a;

a.push_back(new B());
a.push_back(new C());

a[0].VFunc();
a[1].VFunc();