c ++多态性和非虚函数

Question

I have a question: How can I implement a non_virtual function in class that derived from abstract class? For example:

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

class B : public A{
    public:
        virtual void foo() {
            /* some code */
        }
        //B function
        void Bfoo(){
            /* some code */
        }
};

int main(){
    A* a = new B;
    a -> foo();
    a -> Bfoo();
    return 0;
}

g++ gets:

error: ‘class A’ has no member named ‘Bfoo’ 
a -> Bfoo();

Is there a way to use polymorphism and use non-virtual functions?

EDIT

I know that A hasn't got Bfoo() function so I get the error. I asked this question because I didn't understand when is useful use polymorphism.

My answer could be:

I use polymorphism when my derived classes have all the same function and derived from one common base class.

But if a class has an other function the polymorphism drops?

Answer 1

If you want to use function Bfoo() with pointer a , you have to add the function Bfoo() to class A as virtual .

I mean

class A {
    public:
    virtual void foo() = 0;
    virtual void Bfoo() {} //this line is necessary
};

---

EDIT (after question changed)

The knowledge of definitions is necessary. Here is the definition of Virtual Members from cplusplus.com

Virtual members
A virtual member is a member function that can be redefined in a derived class, while preserving its calling properties through references. The syntax for a function to become virtual is to precede its declaration with the virtual keyword.

See the resource for definitions of Polymorphism and Virtual Functions/Members .

Answer 2

A derived class can have additional non-virtual functions, but they must be called from a pointer or reference to the derived class .

The point of polymorphism is for the calling code to not have to care about what concrete class the variable it's acting on is.

Usually such methods would be part of a class's private implementation, and not part of the public interface. Any non-virtual public facing methods in a derived class implicitly force the calling code to be aware of the concrete type of the class.

You could of course cast your A* to a B* but this kind of defeats the point of polymorphism. It's hard to give more specific advice without a concrete example of what you're trying to do.