Перейти к публикации
Форум - ComputerCraft
Ktlo

Другой способ реализации Объектно-Ориентированного Программирования

Рекомендованные сообщения

Я видел статью про ООП (Объектно-Ориентированного Программирования), написанную на этом форуме, и вот, что могу сказать, он может быть немного непонятен новичкам в Lua. Я всегда пользовался другим способом создания "классов".

Сначала следует разобраться со значениями. Класс - это набор методов (в нашем случае функций), процедур и переменных которые дальше будут наследоваться объектом или другим классом. Объектами называют сущности, обладающие набором свойств и операций над ними. Объект - это производное класса.

 

В Lua классов как таковых нет, но если пофантазировать, то можно представить функцию как класс, а объект как таблицу.

 

Создание простого псевдо-класса

 

 

1. И так создаем новую функцию и называем её к примеру class.

function class() --Объявление класса
	--Тело класса
end --Конец класса

Пока это просто пустая функция.

 

2.Теперь пропишем в теле класса следующее:

function class() --Объявление класса
	local Me = { } --Создание объекта
	return Me --Возвращение объекта (производного класса)
end --Конец класса

Теперь мы создали пустую таблицу и заставили функцию вернуть её. Для создания полноценного объекта нам не хватает заполнить его свойствами и методами. Таблица будущего объекта должна быть локальной.

 

3.Создадим свойства и методы к нему:

function class() --Объявление класса
	local Me = {  --Таблица для методов и переменных
		["Var"] = "HelloWorld"; --Публичная переменная
	}
	local Secret = "Cake = Lie"  --Скрытая переменная
	function Me.PrintVar()
		print(Me.Var)
	end
	function Me.PrintSecret()
		print(Secret)
	end
	return Me --Возвращение объекта (производного класса)
end --Конец класса

Мы создали два свойства одно скрытое (Secret), а второе публичное (Me.Var) и два метода один для вывода на экран свойства Me.Var, а второй для вывода свойства Secret. Скрытые свойства обязательно должны быть локальными, а публичные находиться в таблице объекта. Также вы можете создать локальную функцию, которую смогут использовать только методы этого объекта.

 

5.Вы можете хранить этот класс в отдельном файле и вызывать его с помощью функции require(), таким образом, чувствовать себя программистом на C, где обычно каждый класс находится в отдельном файле ;) . Выглядит это примерно так:

local class = require("имя_библиотеки").class -- загрузили класс из другого файла (если его нет в этом)
local Object = class() -- Создание объекта на основе класса
Object.PrintVar() --Вызов первого метода
--> HelloWorld

Object.PrintSecret() --Вызов второго метода
--> Cake = Lie

Object.Var = "BuyWorld" --Изменение значения свойства Var
Object.PrintVar() --Вызов первого метода
--> BuyWorld

Здесь же я вызвал все методы объекта, поменял значение свойства Var и снова вызвал. Попробуйте сами, всё должно работать и с несколькими объектами тоже.

 

 


 

Наследование

 

 

Сначала необходимо познакомиться с самим термином. Наследование - это перенимание всех свойств и методов одного класса другим.

 

Давайте напишем новый класс и назовём его parent.

function parent() --Класс предок для будущего класса наследника
	local Me = { }
        local private = {
            ["Secret"] = 42
        }
	Me.Var = "HelloWorld"
	function Me.PrintVar()
		print(Me.Var)
	end
	return Me
end 

В этом классе есть свойство Var и метод PrintVar(), а также скрытое свойство в таблице private.

 

Теперь пишем класс наследник:

function class()
	local Me = parent() --Перенимаем таблицу объекта из класса parent(), то есть наследуем.
	return Me
end 

Всё! Поздравляю, вы наследовали класс! :D  Но на самом деле не полностью, т. к. остаётся наше скрытое свойство. Я не просто так засунул его в таблицу. Мы можем передать эту таблицу как и сам объект, но отдельно.

function parent()--Класс предок
	local Me = {
		["Var"] = "HelloWorld" --Публичное свойство
	}
	local private = {
		["Secret"] = 42 --Скрытое свойство
	}
	function Me.PrintVar() --Метод
		print(Me.Var)
	end
	return Me, private --Возвращение объекта, а затем таблицы со скрытыми переменными
end
function class() --Класс наследник
	local Me, private = parent() --Наследование
	function Me.getVar() --Функция, возвращающая свойство Var из класса parent
		return Me.Var
	end
	function Me.getSecret()
		return private.Secret --Функция, возвращающая скрытое свойство Secret класса parent
	end
	return Me, private --Этот класс можно наследовать тоже, таким образом, получится двойное наследование
end 

Теперь тестим:

local class = require("filename").class --Нужно, если вы разместили класс в другом файле
--[[
Если вы разместили классы в разных файлах, то следует загружать каждый отдельно, но так как они у меня в одном файле, я вызову только наследника, и это всё равно будет работать.
]]

local object = class() --Создаём объект
object.PrintVar() --Тестим метод из класса предка
--> HelloWorld

print(object.getVar()) --Тестим метод класса class, работающий с Var
--> HelloWorld

print(Me.getSecret()) --Получаем значение скрытого свойства
--> 42

Как видите, всё должно работать. Вы можете сами попробовать построить этот класс и вызывать его методы.

В принципе тут больше нечего объяснять, я думаю. Если что-то не понятно, спрашивайте, отвечу.

 

 


 

Экономия оперативной памяти

 

 

Представим класс:

function class()
    return {
        ["foo"] = function()
            --Здесь очень много кода, вычислений, инструкций и т.д.
        end;
        ["var"] = "какая-то переменная, для примера"
    }
    --Оформил тело объекта так, для разнообразия
end 

Главный минус таких "классов" в том, что они тратят оперативную память, бессмысленно создавая идентичные функции, которые сохраняются отдельно. Но этого можно избежать почти полностью. Почему почти, вы сейчас уведите.

Представим класс в несколько ином виде, как блок do <тело класса> end.

do --Начало класса
    local function class_foo(self) --Наша "тяжёлая" функция
        --Здесь очень много кода, вычислений, инструкций и т.д.
    end
    function class() --Функция для вызова класса
    return {
        ["foo"] = function()
            return class_foo(self) --Ссылаемся на локальную функцию
        end;
        ["var"] = "какая-то переменная, для примера"
    }

    end end --Конец класса 

Вот и всё! Сложная функция записывается только один раз, а методы ссылаются на неё. Также вы можете не использовать блок do, но тогда функции будут доступны вне класса.

 

 


 

Только читаемые свойства

 

 

Это последнее, о чём стоит написать в этой теме. Только читаемые свойства могут понадобится для возвращения результатов объекта не используя функции, и при этом, не предоставляя возможность редактировать эти самые свойства. Это можно сделать используя магию метатаблиц. Не знаете, что это? Тогда бегом читать! Хотя сейчас можно обойтись и без этого  ;). Объяснить на словах, как это сделать, трудно, так что просто смотрите код:

function class()
    local private = { } --Таблица со скрытыми свойствами
    private.__index = { --Таблица внутри таблицы скрытых свойств с читаемыми переменными. !!!Важно! Таблица должна сохраняться под ключом __index!!!
        ReadOnly = true; --Читаемое свойство
        Set = function( var ) --Читаемый метод, который изменяет значение читаемого свойства
            private.__index.ReadOnly = var
        end;
    }
    private.secret = 42823 --Скрытое свойство
    private.__newindex = function() end --Метаметод, непозволяющий менять значение таблицы объекта, если приравняете не к функции, а к таблице будет выводить в неё все попытки замены свойств.
    local Me = { } --Сам объект, да он пуст
    setmetatable( Me, private ) --Магия метатаблиц: устанавливает метатаблицу private для объекта
    return Me, private --Зачем я возвращаю таблицу со скрытыми свойствами, смотрите в наследовании
end 

Надеюсь комментарии к коду выше вполне понятны и всё объясняют. Так что мы можем перейти к тестированию.

Тестируем:

local class = require 'class'.class --Загрузка класса, если он в другом файле.

local object = class() --Получаем объект на основе нашего класса
object.Set( "test" ) --Устанавливаем значение для читаемого свойства читаемой функцией. Напрямую мы это сделать не сможем.
print(object.ReadOnly) --Выводим значение ReadOnly
--> test

object.ReadOnly = "He he!"
--Изменяем значение, надеясь, что это сработает

print(object.ReadOnly) --Но он выводит старое значение
--> test

На этом всё. Теперь вы можете использовать читаемые свойства для того, чтобы не создавать специальные для этого методы.

 

 

 

Вывод. Этот способ реализации ООП в Lua будет работать и в OC и в СС. "Классы" очень похожи на классы из других языков программирования. В моём варианте нет двоеточия, которое приносит странную возможность обработки одного объекта методом другого. Использовать ООП в игре можно для удобной разметки интерфейса в вашей программе (например для создания кнопок), и для экономии системных ресурсов в вашем компьютере внутри компьютера.

Изменено пользователем Ktlo
  • Like 6

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

Обычно натыкаюсь на реализацию классов в виде таблиц. Теперь наконец-то смогу избавиться от двоеточия при вызове функций.

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

И зачем так сложно? Не проще либу стандартную написать? и вызывать также require("liba")

local API = {}

 

function API.hello()

 print("Hello!")

end

 

API.var1 = 12345324

API.var2 = true

API.var3 = "aasdp"

...

...

...

return API

Изменено пользователем artem211

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах
И зачем так сложно? Не проще либу стандартную написать? и вызывать также require("liba")

local API = {}

 

function API.hello()

 print("Hello!")

end

 

API.var1 = 12345324

API.var2 = true

API.var3 = "aasdp"

...

...

...

return API

Понты, понты.

  • Like 1

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

Ну вот, другое дело. Вот это уже "правильный" "ооп" на луа. good.gif

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

И зачем так сложно? Не проще либу стандартную написать? и вызывать также require("liba")

local API = {}

 

function API.hello()

 print("Hello!")

end

 

API.var1 = 12345324

API.var2 = true

API.var3 = "aasdp"

...

...

...

return API

В твоем случае либа всегда будет возвращать указатель на один и тот же объект

Obj1=require("liba")
Obj2=require("liba")

Obj1.var1=54321
print(Obj2.var1)
-->54321

т.е. при изменении поля одного объекта изменятся соответствующие поля других объектов этого же класса.

В случае же, который предложил Ktlo, создаются новые переменные для полей нового объекта и новые функции для методов.

 

 

Я видел статью про ООП (Объектно-Ориентированного Программирования), написанную на этом форуме, и вот, что могу сказать, он может быть немного непонятен новичкам в Lua. Я всегда пользовался другим способом создания "классов".

Я тоже начинал рассмотрение ООП в Луа именно с такого способа, но мне не понравилось в нем то, что для каждого экземпляра объекта создаются свои экземпляры функций-методов. Т.е сколько ты объектов создашь, столько идентичных функций будет храниться в памяти компьютера.

В случае реализации ООП через двоеточие, все объекты одного типа и их наследники используют один и тот же экземпляр функции.

С нетерпением жду описания наследования.

 

PS: далось вам это двоеточие. Вы гоняетесь за внешней похожестью, а ООП на самом деле это не синтаксис компилятора, а уровень мышления программиста.

Изменено пользователем Zer0Galaxy

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах
94НН03 С006Щ3НN3 П0К4ЗЫ8437, К4КN3 У9N8N73ЛЬНЫ3 83ЩN М0Ж37 93Л47Ь Н4Ш Р4ЗУМ! 8П3Ч47ЛЯЮЩN3 83ЩN! СН4Ч4Л4 Э70 6ЫЛ0 7РУ9Н0, Н0 С3ЙЧ4С Н4 Э70Й С7Р0К3 84Ш Р4ЗУМ ЧN7437 Э70 4870М47NЧ3СКN, Н3 З49УМЫ84ЯСЬ 06 Э70М. Г0Р9NСЬ. ЛNШЬ 0ПР393Л3ННЫ3 ЛЮ9N М0ГУ7 ПР0ЧN747Ь Э70.

Любой программист это прочитает.

  • Like 3

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

В твоем случае либа всегда будет возвращать указатель на один и тот же объект

Obj1=require("liba")
Obj2=require("liba")

Obj1.var1=54321
print(Obj2.var1)
-->54321

т.е. при изменении поля одного объекта изменятся соответствующие поля других объектов этого же класса.

В случае же, который предложил Ktlo, создаются новые переменные для полей нового объекта и новые функции для методов.

 

 

Я тоже начинал рассмотрение ООП в Луа именно с такого способа, но мне не понравилось в нем то, что для каждого экземпляра объекта создаются свои экземпляры функций-методов. Т.е сколько ты объектов создашь, столько идентичных функций будет храниться в памяти компьютера.

В случае реализации ООП через двоеточие, все объекты одного типа и их наследники используют один и тот же экземпляр функции.

С нетерпением жду описания наследования.

 

PS: далось вам это двоеточие. Вы гоняетесь за внешней похожестью, а ООП на самом деле это не синтаксис компилятора, а уровень мышления программиста.

а почему бы не вызвать функцию прямо из класса? или после инициализции удалять объект импортированной функции...

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

а почему бы не вызвать функцию прямо из класса? или после инициализции удалять объект импортированной функции...

Приведи пример, пожалуйста. А то не понятно какую функцию из какого класса? Зачем удалять какой объект?

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

 

 

Приведи пример, пожалуйста. А то не понятно какую функцию из какого класса? Зачем удалять какой объект?
 

 

local class = require("имя_библиотеки").class

Эту переменную надо очистить после создания всех экземпляров класса

Либо, дергать так:

require("имя_библиотеки").class()

Изменено пользователем SergOmarov

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

Нет. Ты не путай функцию библиотеки и функцию класса.

local class = require("имя_библиотеки").class

В данном случае переменная class будет содержать указатель на уже существующую функцию и занимать в памяти аж восемь байт. Но это, к сожалению, не имеет никакого отношения к ООП поскольку класс это не тоже самое, что и библиотека.

Способ же, который упомянул топикстартер, действительно создает объект. Но для каждого экземпляра объекта такой способ создает новые экземпляры функций-методов, а функции могут занимать в памяти килобайты.

  • Like 1

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

Если нужно наследование, можно сделать простейший класс, но с двоеточием (не знаю что вы его пугаетесь (?)):

local class = {a,b}   -- классом может послужить обычная таблица
function class:method(a,b) -- это метод класса, например, пусть меняет значения 
   self.a = a.            -- self указывает на нашу таблицу "class", это синтаксический сахар из-за двоеточия.  
   self.b = b
end
function class:new() -- этим методом мы будем создавать новый объект. Вот тут и начинается магия наследования. 
   local answ = {}  -- таблица которую в конце функции мы возвратим.
   self.__index = self -- теперь при обращении к методом класса будут обращаться именно к его методам. (Сам не до конца понял)
   setmetatable(answ, self) --  магия, указываем метатаблицу answ к классу class 
   return answ  -- возвращаем результат.
end
Сдалось вам это двоеточие. Изменено пользователем LeshaInc

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

 

 

Если нужно наследование, можно сделать простейший класс, но с двоеточием (не знаю что вы его пугаетесь (?)):
Хм. Тема называется "ДРУГОЙ способ реализации ...". То о чем пишешь ты это, надо полагать, способ первый.

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

Нет. Ты не путай функцию библиотеки и функцию класса.

local class = require("имя_библиотеки").class

В данном случае переменная class будет содержать указатель на уже существующую функцию и занимать в памяти аж восемь байт. Но это, к сожалению, не имеет никакого отношения к ООП поскольку класс это не тоже самое, что и библиотека.

Способ же, который упомянул топикстартер, действительно создает объект. Но для каждого экземпляра объекта такой способ создает новые экземпляры функций-методов, а функции могут занимать в памяти килобайты.

А, вот ты о чем, а я не понял) Да, на счет этого ты прав, но ведь функции можно хранить и внешним образом, просто вне объекта Me. А ссылаться так как показано в "сложном способе" ооп.

Изменено пользователем SergOmarov

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

Всё я закончил с ООП, если есть вопросы, спрашивайте.

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

 

 

В моём варианте нет двоеточия, которое приносит странную возможность обработки одного объекта методом другого.
Это как? Так что ли?
Obj1:Metod1()     --Вызов метода объекта 1 (нормальный)
Obj2:Metod2()     --Вызов метода объекта 2 (нормальный)
Obj1.Metod1(Obj2) --Вызов метода объекта 1 для объекта 2 (странный) 

Был несколько разочарован реализацией readonly-полей. Я надеялся на:

print(Obj.ReadOnlyVar)  -- читаем поле
--> 123
Obj.ReadOnlyVar=456     -- пытаемся изменить
print(Obj.ReadOnlyVar)  -- повторно читаем поле
--> 123

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

Это как? Так что ли?

Obj1:Metod1()     --Вызов метода объекта 1 (нормальный)
Obj2:Metod2()     --Вызов метода объекта 2 (нормальный)
Obj1.Metod1(Obj2) --Вызов метода объекта 1 для объекта 2 (странный) 

Да, так.

 

Был несколько разочарован реализацией readonly-полей. Я надеялся на:

print(Obj.ReadOnlyVar)  -- читаем поле
--> 123
Obj.ReadOnlyVar=456     -- пытаемся изменить
print(Obj.ReadOnlyVar)  -- повторно читаем поле
--> 123

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

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

Можно)


переопределить оператор присваивания

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

Можно)

переопределить оператор присваивания

Как?

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

Приз - компьютер или робот любой комплектации (кроме креатива) тому, кто реализует readonly-поле объекта через переопределение оператора присваивания.

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

Метатаблицы Карл...

 

Как ты это сделаешь для "примитивных" типов?

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

Приз - компьютер или робот любой комплектации (кроме креатива) тому, кто реализует readonly-поле объекта через переопределение оператора присваивания.

Всё уже реализовано. Вот тут например вообще можно устанавливать свои функции для get и set переменной.

 

Как ты это сделаешь для "примитивных" типов?

Можно можно. Даже цифры, и даже нил. 

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

Можно можно. Даже цифры, и даже нил. 

Узнаю Луа.

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

Можно)

переопределить оператор присваивания

 

Метатаблицы Карл...

Я почитал про метатаблицы поподробнее и всё исправил. Оказывается запретить изменение ключей можно.

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

ro = {a=1, b=2}
obj = {b=3, c=4}
setmetatable(obj,{__index=ro,__newindex=function(_,_,_)end})

prn(obj.a, obj.b, obj.c) -->1 3 4 (значение obj.b=3 установленное до объявления метаметодов перекрывает ro.b=2, и __index=ro не вызывается.
obj.a=5
obj.b=6
obj.c=7
prn(obj.a, obj.b, obj.c) -->1 6 7 (obj.a=5 выполнил function(_,_,_)end ничего не сделав)
 

Эта строка setmetatable(obj, {__index=ro, __newindex=function(_,_,_)end}) говорит следующее:

Для несуществующих индексов таблицы obj, читать значения из ro, а при попытке записи выполнять ничего function(_,_,_)end

 

Или так: setmetatable(obj,{__index=ro,__newindex=function(t,k,v) print('Иди в пень! '..k..' ' - ридонли!')  end})

 

--===--

 

При попытке добавления нового значения (например obj.d=8) выполнится ничего и значение добавлено не будет.

Чтобы мы могли добавлять новые индексы в obj нужно в нашем ничего проверять, есть ли добавляемый индекс в ro, и если такого индекса нет, то добавлять его в obj.

 

Это можно сделать так: setmetatable(obj, {__index=ro,__newindex=function(t,k,v) local _=rawget(ro,k) or rawset(t,k,v) end})

При попытке записи obj.d=8, наше ничего, сделает: если не ro.k то rawset(t,k,v) наплевав на всякие там метаметамета.

 

Теперь мы можем:

ro = {a=1, b=2}
obj = {b=3, c=4}
setmetatable(obj,{__index=ro,__newindex=function(t,k,v) local _=rawget(ro,k) or rawset(t,k,v) end})

prn(obj.a, obj.b, obj.c, obj.d)
obj.a=5
obj.b=6
obj.c=7
obj.d=8
prn(obj.a, obj.b, obj.c, obj.d)
upd:

Прочел следующие посты и понял, как я далек от объектно-ориентированного програмирования )

Изменено пользователем swg2you

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

Уже ближе. Вот пример реализации класса с двумя обычными полями (c,d) и двумя readonly-полями (a,b)

 

 

Class={a=1, b=2, __newindex=function()end}
Class.__index=Class

function Class:new()
    local obj={c=3, d=4}
    setmetatable(obj,self)
    return obj
end

function Class:ShowFields()
  print(self.a, self.b, self.c, self.d)
end

function Class:SetA(Val)
  Class.a=Val
end

function Class:SetB(Val)
  Class.b=Val
end

obj = Class:new()

obj:ShowFields()
obj.a=5
obj.b=6
obj.c=7
obj.d=8
obj:ShowFields()
obj:SetA(5)
obj:SetB(6)
obj:ShowFields()

 

 

RO-поля можно менять при помощи методов класса. Одна проблема - RO-поля общие для всех экземпляров класса

И можно ли будет от такого класса сделать наследника если невозможно добавлять новые поля?

Изменено пользователем Zer0Galaxy

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

И можно ли будет от такого класса сделать наследника если невозможно добавлять новые поля?

Можно:

function newClass()
      local object, private = class()
      setmetatable(object, {}) --Удаляем метатаблицу
      object.foo(...) --Добавляем метод
            --<Что-нибудь>
      end
      setmetatable(object, private) --Возвращаем нашу метатаблицу назад
      return object, private
end

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

 

 

При попытке добавления нового значения (например obj.d=8) выполнится ничего и значение добавлено не будет. Чтобы мы могли добавлять новые индексы в obj нужно в нашем ничего проверять, есть ли добавляемый индекс в ro, и если такого индекса нет, то добавлять его в obj.   Это можно сделать так: setmetatable(obj, {__index=ro,__newindex=function(t,k,v) local _=rawget(ro,k) or rawset(t,k,v) end}) При попытке записи obj.d=8, наше ничего, сделает если не ro.k то rawset(t,k,v) наплевав на всякие там метаметамета.
Так, а как сделать что бы таблица ro была не одна на всех, а своя для каждого экземпляра класса?

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

Так, а как сделать что бы таблица ro была не одна на всех, а своя для каждого экземпляра класса?

Я далек от ООП, но думаю, что как-то так.

setmetatable(obj1, {__index=ro1,__newindex=function(t,k,v) local _=rawget(ro1,k) or rawset(t,k,v) end})

setmetatable(obj2, {__index=ro2,__newindex=function(t,k,v) local _=rawget(ro2,k) or rawset(t,k,v) end})

 

Или по твоему коду:

Class={a=1, b=2}

function Class:new()
  local obj={c=3, d=4}
  local nc={}
  for k,v in pairs(self) do nc[k]=v end
  setmetatable(obj,{__index=nc,__newindex=function(t,k,v) local _=rawget(nc,k) or rawset(t,k,v) end})
  return obj
end

function Class:ShowFields()
  prn(self.a, self.b, self.c, self.d)
end

function Class:SetA(Val)
  rawset(self,'a',Val)
end

function Class:SetB(Val)
  rawset(self,'b',Val)
end

obj = Class:new() 
obj2 = Class:new()

obj:ShowFields()
obj.a=5
obj.b=6
obj.c=7
obj.d=8
obj:ShowFields()
obj:SetA(5)
obj:SetB(6)
obj:ShowFields()
obj2:ShowFields()
Если я правильно понял, что тебе от этого кода нужно. Изменено пользователем swg2you

Поделиться сообщением


Ссылка на сообщение
Поделиться на других сайтах

Создайте аккаунт или войдите в него для комментирования

Вы должны быть пользователем, чтобы оставить комментарий

Создать аккаунт

Зарегистрируйтесь для получения аккаунта. Это просто!

Зарегистрировать аккаунт

Войти

Уже зарегистрированы? Войдите здесь.

Войти сейчас

×