Фортрановый конструктор абстрактного класса, инициализирующий частные переменные

Question

Я начинаю с Fortran и хотел попробовать довольно простой пример - один абстрактный класс Connection, затем его производный класс IntervalConnection, в то время как класс Connection будет иметь определенный конструктор, а IntervalConnection наследует этот конструктор.

В этом конструкторе у меня есть несколько личных переменных, которые мне нужно инициализировать.

Проблема в том, что я получаю следующую ошибку при попытке создать новый объект: Connection.f08:152:10:

    con = IntervalConnection(n1_p, n2_p, 5.0)
          1
Error: Component ‘input_neuron’ at (1) is a PRIVATE component of ‘connection’

Я полагаю, я не определяю конструктор new_connection правильно. Подскажите, пожалуйста, как мне лучше это реализовать?

---

Мой код

module Connection_mod
    implicit none

    public

    ! TODO smazat
    type :: Neuron
        real, private :: state

        contains
            procedure :: get_state => get_state_impl
            procedure :: set_state => set_state_impl
    end type Neuron

    !------------------!------------------------------------------------------------------------
    ! Type definitions !
    !------------------!
    type, abstract :: Connection
        class(Neuron), pointer, private :: input_neuron
        class(Neuron), pointer, private :: output_neuron
        real, private                   :: weight

        contains

            procedure :: adjust_weight     => adjust_weight_impl

            ! Getters and setters    
            procedure :: get_input_neuron  => get_input_neuron_impl
            procedure :: get_output_neuron => get_output_neuron_impl
            procedure :: get_weight        => get_weight_impl

    end type Connection

    type, extends(Connection) :: IntervalConnection
       contains
          procedure :: pass_signal => pass_signal_impl
    end type IntervalConnection

    !------------!------------------------------------------------------------------------------
    ! Interfaces !
    !------------!
    interface Connection
        module procedure new_connection
    end interface Connection

    contains
    !------------------------!------------------------------------------------------------------
    ! Method implementations !
    ! -----------------------!

        !--------------!
        ! class Neuron !
        !--------------!
        ! TODO smazat
        function get_state_impl(this) result(state)
            class(Neuron), intent(in) :: this
            real                      :: state

            state = this%state
        end function get_state_impl

        ! TODO smazat
        function set_state_impl(this, new_state) result(ret_this)
            class(Neuron), target  :: this
            real, intent(in)       :: new_state
            class(Neuron), pointer :: ret_this

            ret_this   => this
            this%state = new_state
        end function set_state_impl

        !------------------!
        ! class Connection !
        !------------------!
        subroutine adjust_weight_impl(this, added_value)
            class(Connection), intent(inout) :: this
            real, intent(in)                 :: added_value

            this%weight = this%weight + added_value
        end subroutine adjust_weight_impl

        !--------------------------!
        ! class IntervalConnection !
        !--------------------------!
        subroutine pass_signal_impl(this)
            ! TODO dokoncit
            class(IntervalConnection), intent(in) :: this
            real :: a
            class(Neuron), pointer :: dummy

            a=this%weight * this%input_neuron%get_state()

            dummy => this%output_neuron%set_state(5.0)

            !this%output_neuron%set_state(this%weight * this%input_neuron%get_state())
        end subroutine pass_signal_impl

        !--------------!------------------------------------------------------------------------
        ! Constructors !
        !--------------!
        function new_connection(this, input_neuron, output_neuron, weight) result(ret_this)
            class(Connection), target  :: this
            class(Connection), pointer :: ret_this
            class(Neuron), pointer     :: input_neuron
            class(Neuron), pointer     :: output_neuron
            real, intent(in)           :: weight

            ret_this           => this
            this%input_neuron  => input_neuron
            this%output_neuron => output_neuron
            this%weight        = weight
        end function new_connection

        !-------------------!-------------------------------------------------------------------
        ! Getters & Setters !
        !-------------------!
        function get_input_neuron_impl(this) result (input_neuron)
            class(Connection), target, intent(in) :: this
            class(Neuron), pointer                :: input_neuron

            input_neuron => this%input_neuron
        end function get_input_neuron_impl

        function get_output_neuron_impl(this) result (output_neuron)
            class(Connection), target, intent(in) :: this
            class(Neuron), pointer                :: output_neuron

            output_neuron => this%output_neuron
        end function get_output_neuron_impl

        function get_weight_impl(this) result (weight)
            class(Connection), intent(in) :: this
            real                          :: weight

            weight = this%weight
        end function get_weight_impl
end module Connection_mod

program a
    use Connection_mod

    type(Neuron), target :: n1
    type(Neuron), target :: n2

    type(Neuron), pointer :: n1_p
    type(Neuron), pointer :: n2_p

    type(IntervalConnection) :: con

    n1_p => n1
    n2_p => n2
    con = IntervalConnection(n1_p, n2_p, 5.0)

end program a

Answer 1

Функция, которую вы создали как конструктор, принимает четыре аргумента

function new_connection(this, input_neuron, output_neuron, weight)

но вы называете это с тремя аргументами

class(IntervalConnection) :: con

con = IntervalConnection(n1_p, n2_p, 5.0)

Я перенес это задание наружу. Это не строго необходимо.

---

Поэтому универсальное разрешение (TKR) не может быть успешным, и будет использован конструктор по умолчанию.

И вы также перегружены конструктор или Connectionно потом звонишь IntervalConection(), Это разные!

Вы, вероятно, неправильно поняли, как конструктор работает с аргументами и возвращаемыми значениями. Там нет места для любого this аргумент. Конструктор НЕ является процедурой с привязкой к типу. Это не наследуется. Но дочернее соединение может вызвать родительский конструктор, если это необходимо. Иногда ты этого хочешь, иногда нет. Обратите внимание, возвращаемое значение typeне class!

function new_interval_connection(input_neuron, output_neuron, weight) result(ret)
        type(IntervalConnection) :: ret
        class(Neuron), pointer     :: input_neuron
        class(Neuron), pointer     :: output_neuron
        real, intent(in)           :: weight

        ret%input_neuron  => input_neuron
        ret%output_neuron => output_neuron
        ret%weight        = weight
end function new_interval_connection

---

Вы хотите создать экземпляр конструктора make для IntervalConnection, а не для Connection, как вы пытались

interface IntervalConnection
    module procedure new_interval_connection
end interface Connection

con = IntervalConnection(n1, n2, 5.0)