Is this c++ inheritance structure possible?

I have not programmed in c++ in a long time and want some simple behavior that no amount of virtual keywords has yet to produce:

class Base {
  public:
    int both() { return a(); }
};

class Derived : public Base {
  protected:
    int a();
};

class Problem : public Derived {
};

Problem* 开发者_StackOverflowp = new Problem();
p.both();

Which gives me a compile-time error. Is this sort of behavior possible with c++? Do I just need forward declaration? Virtual keywords on everything?

---

No. You will have to use a pure virtual a in base.

class Base {
    virtual int a() = 0;
    int both() {
        return a();
    }
};

---

You should declare the a() function as a pure virtual method in the Base class.

class Base {
    int both() {
        return a();
    }

    virtual int a()=0;
};

Then implement the a() method in the Derived class

class Derived : public Base {
    int a(){/*some code here*/}
};

And finally, Problem class doesn't see the both() method, since its private in Base. Make it public.

class Base {
public:
    int both() {
        return a();
    }
};

---

Your function both() is private by default. Try:

class Base {
public:
    int both() {
        // ...

^{(In the future, it would be helpful if you tell us what the actual error message was.)}

---

You need a() to be declared in class Base, otherwise the compiler doesn't know what to do with it.

Also, both() is currently a private method (that's the default for classes), and should be made public in order to call it from main.

---

You have multiple problems in your code :

• unless you declare them public or protected, elements of a class are private as a default.
• you need a virtual keyword to define a virtual function that would be callable in a parent.
• new returns a pointer to Problem.

Here's a complete working code based on your test :

class Base { 
protected:
virtual int a()=0;
public:
    int both() { 
        return a(); 
    } 
}; 

class Derived : public Base { 
private :
int a()
{
printf("passing through a!");
return 0;
}


}; 

class Problem : public Derived { 
}; 

int main(void)
{
  Problem* p = new Problem(); 
  p->both();
}

tested on CodePad.

---

As others point out, you need to declare a() as pure virtual method of Base and change access to public to make your snippet work.

Here is another approach possible in c++: instead of virtual functions, you can use static polymorphism via the Curiously recurring template pattern:

template <class D>
class Base : public D
{
public: 
    int both() { return D::a(); }
};

class Derived : public Base<Derived> 
{
public:
    int a();
};

I'm posting this approach since you're asking what is possible in c++. In practice, virtual methods are most often a better choice because of their flexibility.