You need to use the virtual copy pattern: provide a virtual function in the interface that does the copy and then implement it across the hierarchy: struct base { virtual ~base() {} // Remember to provide a virtual destructor virtual base* clone() const = 0; }; struct derived : base { virtual derived* clone() const … Read more
Before I dig into multi table inheritance I want to lose a few words about single table inheritance. Single table inheritance is the more easy way when it comes to inheritance with db models. You have multiple models bound to the same table and a type column to distinguish between the different model classes. However … Read more
It looks like you want to do virtual inheritance. Whether that turns out to actually be a good idea is another question, but here’s how you do it: class AbsBase {…}; class AbsInit: public virtual AbsBase {…}; class AbsWork: public virtual AbsBase {…}; class NotAbsTotal: public AbsInit, public AbsWork {…}; Basically, the default, non-virtual multiple … Read more
He perhaps meant to try and override the value used to initialize the variable. For example, Instead of this (which is illegal) public abstract class A { String help = “**no help defined — somebody should change that***”; // … } // … public class B extends A { // ILLEGAL @Override String help = … Read more
When I just override the Dispose(bool disposing) call, it feels really strange stating that I implement IDisposable without having an explicit Dispose() function (just utilizing the inherited one), but having everything else. This is something you shouldn’t be concerned with. When you subclass an IDisposable class, all of the “Dispose pattern” plumbing is already being … Read more
You can re-declare (new), but you can’t re-declare and override at the same time (with the same name). One option is to use a protected method to hide the detail – this allows both polymorphism and hiding at the same time: public class Father { public Father SomePropertyName { get { return SomePropertyImpl(); } } … Read more
Why are we forced to call super.method()? The classes that make up the Android SDK can be incredibly complex. For instance, both activities and fragments must perform a number of operations in order to function properly (i.e. managing life cycle, optimizing memory usage, drawing the layout to the screen, etc.). Requiring the client to make … Read more
Since B is publicly inherited from A, A’s protected member(s) become B’s protected member(s), so B can access its protected members as usual from its member function(s). That is, the objects of B can access the protected members of B from its member functions. But A’s protected members cannot be accessed outside the class, using … Read more
You can always(*) refer to a base class’s function by using a qualified-id: #include <iostream> class Base{ public: void foo(){std::cout<<“base”;} }; class Derived : public Base { public: void foo(){std::cout<<“derived”;} }; int main() { Derived bar; //call Base::foo() from bar here? bar.Base::foo(); // using a qualified-id return 0; } [Also fixed some typos of the … Read more
Here is my best solution, I would be happy to hear from somebody that had a thought about it. public abstract class A implements Parcelable { private int a; protected A(int a) { this.a = a; } public void writeToParcel(Parcel out, int flags) { out.writeInt(a); } protected A(Parcel in) { a = in.readInt(); } } … Read more