Calling the constructor of an abstract base class in Fortran

This is a good question and I hope someone with more fortran experience can provide a better answer. For your first question, you don't need a pointer, you can instead define the constructor as,

type(Shape) function constructor(xCenter, yCenter)   

    double precision, intent(in) :: xCenter
    double precision, intent(in) :: yCenter

    print *, "constructing base shape"
    constructor%centerPoint = [xCenter, yCenter]
end function constructor

      

        
        
        
      

    

For your second question, the answer should be to call the parent in the rectangle constructor with a line constructor%Shape = Shape(xCenter, yCenter)

in the rectangle constructor function.

type(Rectangle) function constructor(length, width, xCenter, yCenter)

    type(Rectangle), pointer :: this
    double precision, intent(in) :: xCenter
    double precision, intent(in) :: yCenter
    double precision, intent(in) :: length
    double precision, intent(in) :: width

    print *, "Constructing rectangle"

    !invoke the base class constructor here
    constructor%Shape_ = Shape(xCenter, yCenter)
    constructor%length = length
    constructor%width = width

end function constructor

      

        
        
        
      

    

I cannot get this to work with the Intel v13.0.1 compiler. It returns an error: If the rightmost part-name is of abstract type, data-ref shall be polymorphic

. As I understand it, the fortran 2008 standard should allow you to call the constructor of an abstract type if it is the parent of the current type. This may work in later compilers, check this answer (and try for your case).

If not, then as a minimal working solution to what you want, the solution I ended up using was to have an abstract form class that defines an interface, and then define a constructor on the first object that inherits that. here a shape

(similar to section 11.3.2 this one for example). The solution is as follows:

module shape_mod

    type, abstract :: abstractshape
            integer :: color
            logical :: filled
            integer :: x
            integer :: y
    end type abstractshape

   interface abstractshape
        module procedure initShape
    end interface abstractshape

    type, EXTENDS (abstractshape) :: shape
    end type shape

    type, EXTENDS (shape) :: rectangle
            integer :: length
            integer :: width
    end type rectangle

    interface rectangle
        module procedure initRectangle
    end interface rectangle


contains

    ! initialize shape objects
    subroutine initShape(this, color, filled, x, y)

        class(shape) :: this
        integer :: color
        logical :: filled
        integer :: x
        integer :: y

        this%color = color
        this%filled = filled
        this%x = x
        this%y = y

    end subroutine initShape

    ! initialize rectangle objects
    subroutine initRectangle(this, color, filled, x, y, length, width)

        class(rectangle) :: this
        integer :: color
        logical :: filled
        integer :: x
        integer :: y
        integer, optional :: length  
        integer, optional :: width   

        this%shape = shape(color, filled, x, y)

        if (present(length)) then
           this%length = length
        else
           this%length = 0
        endif
        if (present(width)) then 
            this%width = width
        else
             this%width = 0
        endif
    end subroutine initRectangle

end module shape_mod

program test_oop
    use shape_mod 
    implicit none

    ! declare an instance of rectangle
    type(rectangle) :: rect 

    ! calls initRectangle 
    rect = rectangle(2, .false., 100, 200, 11, 22)  

    print*, rect%color, rect%filled, rect%x, rect%y, rect%length, rect%width 

end program test_oop

      

        
        
        
      

    

Sorry the notation is slightly different from your example, but hopefully this helps ...