Изучаем ядро Ruby — классы и объекты

Привет всем.
Решил изучать исходники моего любимого Руби. Буду периодически делиться с вами своими наблюдениями.

Небольшое предупреждение:
Желательно знать Си. Хотя бы немного. Ладно-ладно, не знаете? Ну, тогда спрашивайте в комментариях, я вам на «яблоках» объясню (и почему я постоянно думаю, что кто-то вообще еще продолжает читать этот рассказ?).

Пожалуйста, не пугайтесь слова «указатель». Это переменная которая указывает на что-то другое (если выражаться очень понятным языком).
Если попытаться привести простую аналогию указателей в руби, то на ум приходит следующая конструкция:

Есть объект стандартного удостоверения личности. А есть человек, имеющий этот документ.

class Document
  attr_accessor :person
 
  # при создании документа указываем его номер а так же объект, которому будет принадлежать сей документ
  def initialize(object, number)
    @document_number = number
    @person = object
  end
end
 
Person = Struct.new(:name)
 
# наш человек имеет имя Олег!
someone = Person.new("Oleg")
 
# теперь создадим документ
# передадим в качестве аргументов функции нашего человека и номер документа
doc = Document.new(someone,23234)
 
# а теперь магия!
puts doc.person.name
# => "Oleg"
doc.person.name = "Natalia"
puts doc.person.name
# => "Natalia"

На самом деле при создании нашего документа мы передали УКАЗАТЕЛЬ на объект Person. Таким образом получили возможность манипулировать этим объектом через класс Document.

В си нет классов, зато есть Структуры. И в руби они тоже есть (если вы не знали, то смотрим внимательно на класс Struct).
Я начну свой рассказ с файла «ruby.h», и не от того, что я уже как пять пальцев знаю всю архитектуру руби, а, наверное, из-за того, что именно этот файл мы инклудим при создании своего расширения на си для руби.

Обратим внимание на самые важные вещи для нас -> класс и объект. Сейчас вы поймёте почему метапрограммирование в руби именно такое, почему можно сделать так и оно будет работать:

class MyClass
  def self.hello
    puts "hello"
  end
end 
 
MyClass.hello
# >> "hello"
 
MyClass.instance_eval {
  def hello
    puts "goodbye"
  end
}
 
MyClass.hello
# >> goodbye

Для себя я выделил 3 структуры, которые будут интересны нам:
RBasic, RObject и RClass.

Вот код этих структур:

struct RBasic {
unsigned long flags;
VALUE klass;
};
 
struct RObject {
struct RBasic basic;
struct st_table *iv_tbl;
};
 
struct RClass {
struct RBasic basic;
struct st_table *iv_tbl;
struct st_table *m_tbl;
VALUE super;
};

Давайте внимательно взглянем на структуры RObject и RClass (Объект и Класс).
Наверное, вы обратили внимание, что обе структуры имеют внутри себя еще одну структуру — RBasic.
Структура RBasic содержит в себе интересную строку — «VALUE klass».  Если узнать, что же такое VALUE, то оказывается, что это переменная типа unsigned long. Эта переменная хранит в себе адрес класса в памяти. Зная адрес класса в памяти мы можем обращаться к нему в любое время!

Объект и класс в руби, обязательно имеют VALUE klass. Понимаете к чему я веду? Класс тоже является объектом!

Да, это странно, и не похоже на некоторые другие языки.
Именно это когда-то вскрыло мне мозги — »О боже, как так? Декларация класса тоже объект? no way!»

Давайте приглядимся к структуре RObject, помимо структуры RBasic она имеет ссылку на iv_tbl.
iv_tbl расшифровывается как instance_variable_table, то есть таблица переменных объекта.

Класс тоже имеет ссылку на таблицу переменных объекта.
Да, да, у класса тоже могут быть свои переменные =) Эти переменные будут преследовать класс на протяжении всего цикла работы программы.

class MyClass; end
MyClass.instance_variable_set("@var", 100)
puts MyClass.instance_variable_get("@var")
# >> 100
obj = MyClass.new()
puts obj.instance_variable_get("@var")
# >> nil

Выведет nil, так как @my_var является переменной объекта MyClass, а не переменной экземпляра класса MyClass. (Надеюсь, я не запутал вас)

Окей, мы попытались разобраться с iv_tbl ( таблица переменных объекта ), теперь попробуем перейти к m_tbl.
Это указатель на таблицу методов (methods_table). Вы, наверное, уже заметили, что объект не имеет в себе указатель на таблицу методов.

Почему? Всё очень просто. Объект имеет внутри себя структуру RBasic, которая содержит в себе адрес своего класса.

Как происходит поиск методов?

Предположим мы написали такой код:

object.my_method()

Интерпретатор обращается к объекту, узнает адрес класса объекта, обращается к классу по этому адресу. Найдя класс, интерпретатор обращается к таблице методов класса и ищет там метод.

Вы уже заметили строку «VALUE super» в структуре RClass?
Здесь содержится адрес родительского класса.

если мы сделаем что-то вроде:

class A; end
class B < A; end

То теперь в поле «VALUE super» класса B будет адрес класса A, так как класс A является родителем класса B.

Таким образом, когда мы вызываем метод объекта, интерпретатор узнает класс объекта, обращается к этому классу, узнает адрес таблицы методов и пытается найти метод в этой таблице. Если метод не был найден, интерпретатор узнает адрес класса-родителя и если такой имеется, то он продолжает поиск метода в таблице методов класса-родителя.
Если метод не найден и в классе-родителе, то поиск продолжается в super классе нашего родителя:

class A
def my_method()
end
end
class B < A; end
class C < B; end
 
c = C.new()
 
c.my_method()

Мы видим, что метод my_method() определен в классе A, таким образом интерпретатор сначала будет искать этот метод в классе C, затем перейдет к классу B, а затем к классу A.
Это интересно, потому как раньше мне казалось, что создавая вот такое наследование:

class User < ActiveRecord::Base
end

мы тянем за собой всю тонну классов ActiveRecord’а. Мне было страшно, что мой скромный класс User «заполняется» методами своего родителя, я переживал за память.
Теперь мне легче. Умнеть иногда полезно =)

Думаю, теперь вы понимаете, что при наследовании руби создает цепочку классов, и каждый класс из этой цепи ссылается на свою таблицу методов.
Руби будет искать метод до тех пор, пока не дойдет до самого высшего класса цепочки.

В следующем выпуске я хотел бы ближе рассмотреть модули, то как они включаются в цепь наследования, а так же получше рассмотреть таблицы методов и переменных объекта.

Спасибо за терпение, жду ваших отзывов.

Tagged as: c, Ruby