About the way of inheritance

[Z-joe0]

Why choose to use pointers for inheritance?

[felker]

Can you elaborate and point to examples?

[Z-joe0]

Thank you for your reply!

I am trying to learn your code so that I can use it to solve my problem. As the “User's Guide” says, I need to “read the Programmer Guide in order to understand the data structures in Athena++ well enough to write a new problem generator”. So I read “Object Structures” in “Code Structures”. I saw that you wrote that A points to B means that A is an instance of B.

I think that this is a kind of inheritance, i.e., A retains B's variables and functions while having some of its own. I looked at the implementation in the code, using the ParameterInput class as an example, where there is a pointer InputBlock* pfirst_block that corresponds to the relationship between ParameterInput and InputBlock. There are many similar examples in the code.

class ParameterInput {
 public:

  ParameterInput();
  ~ParameterInput();

 InputBlock* pfirst_block; 
  ...
}

However, C++ actually provides a way to implement inheritance, here is an example.

class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      int area()
      {
         cout << "Parent class area :" <<endl;
         return 0;
      }
};
class Rectangle: public Shape{
   public:
      Rectangle( int a=0, int b=0):Shape(a, b) { }
      int area ()
      { 
         cout << "Rectangle class area :" <<endl;
         return (width * height); 
      }
};
class Triangle: public Shape{
   public:
      Triangle( int a=0, int b=0):Shape(a, b) { }
      int area ()
      { 
         cout << "Triangle class area :" <<endl;
         return (width * height / 2); 
      }
};

I want to know if my understanding about the relationship between classes in the code is correct, because there are so many pointers in the code that I can't sort them out.

Looking forward to reply.

[c-white]

The code has some inheritance in the object-oriented sense, but most of the pointers you see aren't really serving the same purpose. Rather, they are nested containers, where one container might hold multiple things, and if a subcontainer wants to change some parameter in its parent, it should do so in a way that propagates to all other subcontainers.

Consider the MeshBlock class in src/mesh/mesh.hpp. Each MeshBlock object stores all the information for a chunk of the domain. This includes coordinates and their associated routines (encapsulated in a Coordinates object), hydrodynamical variables and their associated routines (encapsulated in a Hydro object), electromagnetic fields and their associated routines (encapsulated in a Field object), etc. Thus

class MeshBlock {
  Coordinates *pcoord;
  Hydro *phydro;
  Field *pfield;
  ...
}

When a subcontainer needs the loop limits is, ie, etc., it can follow its MeshBlock *pmy_block pointer up to its container to find them; this way each subcontainer doesn't duplicate all the bookkeeping metadata. This is especially important for mutable metadata. As AMR changes the grid, the number of MeshBlocks evolves, and the Mesh object stores this count as nbtotal, with an appropriately sized integer array ranklist specifying the MPI rank on which each MeshBlock lives. All sorts of subroutines might need to know this information, so any change to nbtotal or ranklist would, if more C++-style inheritance were used, need to be propagated manually from Mesh to TurbulenceDriver, FFTDriver, MeshBlock, etc., and then from MeshBlock to its subcontainers, and so on.

Put another way, most subcontainers in the code are not, conceptually, more specific forms of their parent containers. They are compartmentalized pieces of physics used to isolate certain variables and equations.

[felker]

@c-white's answer is great. "containership" is not the same as "inheritance" in OOP. This is a pretty good article about it in C++ https://www.geeksforgeeks.org/difference-between-containership-and-inheritance-in-c/

We do use class inheritance all throughout the codebase. You can check yourself via:

> grep -nri ": public" ./
...

All class inheritance examples are in Outputs, Boundary Values, Task List, Chemistry, Radiation, Gravity, and Coordinates modules (although this last example will soon no longer be true; see #600)

My memory is failing me as to explaining why we use dynamically pointer members for the above containership relationship, versus fully-fledged object members with automatic storage duration, and then passing references to them to functions, e.g.

class MeshBlock {
  Coordinates coord;
  Hydro hydro;
  Field field;
  ...
}

Any memory of this decision @c-white? Obviously we would still need to keep MeshBlock *pmy_block in the subcontainer classes.

And for things like the InputBlock* pfirst_block;, I know I was in favor of eliminating the several hand-written linked list implementations and their associated pointer usage like this. Could be replaced with a STL container object https://cplusplus.com/reference/list/list/

[Z-joe0]

Thank you all! I'll check the code again.