[Lua5.4.4源码].元表

static const luaL_Reg base_funcs[] = {
  {"getmetatable", luaB_getmetatable},
  {"setmetatable", luaB_setmetatable},
};

/// @brief 
// lua_getmetatable：如果该索引处的值有元表,则将其元表压栈,返回 1 。 否则不会将任何东西入栈,返回 0 。
// luaL_getmetafield：将索引 obj 处对象的元表中 __metatable 域的值压栈。
// 如果该对象没有元表,或是该元表没有相关域, 此函数什么也不会压栈并返回 LUA_TNIL。
/// @param L 
/// @return 
static int luaB_getmetatable (lua_State *L) {
  luaL_checkany(L, 1);
  if (!lua_getmetatable(L, 1)) {
    lua_pushnil(L);
    return 1;  /* no metatable */
  }
  luaL_getmetafield(L, 1, "__metatable");
  return 1;  /* returns either __metatable field (if present) or metatable */
}

// LUA_TNIL定义在lua.h中 是0
// lua_setmetatable：把一张表弹出栈,并将其设为给定索引处的值的元表。
// a = {}
// setmetatable(a,{__metatable = "hello"})
// setmetatable(a,{__metatable = "world"})
// 这种情况就会报错
// 也就是说 __metatable这个是保护元表,不可读写
static int luaB_setmetatable (lua_State *L) {
  int t = lua_type(L, 2);
  luaL_checktype(L, 1, LUA_TTABLE);
  luaL_argexpected(L, t == LUA_TNIL || t == LUA_TTABLE, 2, "nil or table");
  if (l_unlikely(luaL_getmetafield(L, 1, "__metatable") != LUA_TNIL))
    return luaL_error(L, "cannot change a protected metatable");
  lua_settop(L, 2);
  lua_setmetatable(L, 1);
  return 1;
}

//c文件 
//#include <string.h>  

extern "C" {
	#include "lua.h"  
	#include "lauxlib.h"  
	#include "lualib.h"  
}

#include <iostream>  
using namespace std;

static struct StudentTag
{
	char* strName; // 学生姓名
}T;

static int CFunStudent(lua_State* L)
{
	size_t iBytes = sizeof(struct StudentTag);
	struct StudentTag* pStudent;
	pStudent = (struct StudentTag*)lua_newuserdata(L, iBytes);
	//设置元表
	luaL_getmetatable(L, "StudentMetatable");
	lua_setmetatable(L, -2);

	return 1; 
}

static int GetName(lua_State* L)
{
	struct StudentTag* pStudent = (struct StudentTag*)luaL_checkudata(L, 1, "StudentMetatable");
	lua_pushstring(L, pStudent->strName);
	return 1;
}

static int SetName(lua_State* L)
{
	// 第一个参数是userdata
	struct StudentTag* pStudent = (struct StudentTag*)luaL_checkudata(L, 1, "StudentMetatable");

	// 第二个参数是一个字符串
	const char* pName = luaL_checkstring(L, 2);
	luaL_argcheck(L, pName != NULL && pName != "", 2, "Wrong Parameter");

	pStudent->strName = (char*)pName;
	return 0;
}
static  luaL_Reg arrayFunc_meta[] =
{
	{ "getName", GetName },
	{ "setName", SetName },
	{ NULL, NULL }
};

static luaL_Reg arrayFunc[] =
{
	{ "new", Student},
	{ NULL, NULL }
};

extern "C"  _declspec(dllexport) int luaopen_mytestlib(lua_State *L)
{
// 创建一个新的元表
	luaL_newmetatable(L, "StudentMetatable");
	// 元表.__index = 元表
	lua_pushvalue(L, -1);
	lua_setfield(L, -2, "__index");
	luaL_setfuncs(L, arrayFunc_meta, 0);
	luaL_newlib(L, arrayFunc);
	lua_pushvalue(L, -1);
	lua_setglobal(L, "StudentModule");
	return 1;
}

-- lua 文件
require "mytestlib"
local objStudent = StudentModule.new()

objStudent:setName("11111")
local strName = objStudent:getName()
print(strName)

for k,v in pairs(getmetatable(objStudent)) do
	print(tostring(k),tostring(v))
end

local myShoeStore = 
{
	num12_shoe = "Size 12 shoes",--12号鞋子
	num13_shoe = "Size 13 shoes",--13号鞋子
}

local myShoeStore = 
{
	num12_shoe = "Size 12 shoes",--12号鞋子
	num13_shoe = "Size 13 shoes",--13号鞋子
}

print(myShoeStore.num20_shoe)

local myShoeStore = 
{
	num12_shoe = "Size 12 shoes",--12号鞋子
	num13_shoe = "Size 13 shoes",--13号鞋子
}

 local myBranchShoeStore = {
        __index = {--关键地方,靠的就是__index来进行关联查找
           num20_shoe = "Size 20 shoes",--20号鞋子
        }
    }

 setmetatable(myShoeStore,myBranchShoeStore);--关键地方,这里等价于把两家店给串连起来了

print(myShoeStore.num20_shoe)

local myShoeStore = 
{
	num12_shoe = "Size 12 shoes",--12号鞋子
	num13_shoe = "Size 13 shoes",--13号鞋子
}

 local myBranchShoeStore = {
	 __index = 11111 -- 注意这个地方的写法
 }

 setmetatable(myShoeStore,myBranchShoeStore);--关键地方,这里等价于把两家店给串连起来了

print(myShoeStore.num20_shoe)

local myShoeStore = 
{
	num12_shoe = "Size 12 shoes",--12号鞋子
	num13_shoe = "Size 13 shoes",--13号鞋子
}

 local myBranchShoeStore = {
        __index = {--关键地方,靠的就是__index来进行关联查找
           num20_shoe = "Size 20 shoes",--20号鞋子
        }
    }

 setmetatable(myShoeStore,myBranchShoeStore);--关键地方,这里等价于把两家店给串连起来了

print(myShoeStore.num20_shoe)

local myShoeStore = 
{
	num12_shoe = "Size 12 shoes",--12号鞋子
	num13_shoe = "Size 13 shoes",--13号鞋子
}

 local myBranchShoeStore = {
        __index = function(table,key,key)
            print(table)
            print(key)
            return "Size 20 shoes"
        end
    }

 setmetatable(myShoeStore,myBranchShoeStore);--关键地方,这里等价于把两家店给串连起来了

print(myShoeStore.num20_shoe)

---当我们使用__index元方法要指向自己的方法时候
local class = {}

function class:new()
    self.__index = self
    return setmetatable( {}, self )
end

function class:get_num20_shoe()
	print("Size 20 shoes")
end

--当我们第一次new class的时候,发现可以输出get_num20_shoe函数的内容
local myshoestrore = class:new()
myshoestrore.get_num20_shoe()

-- 当我们在此调用通过myshoestroe new class的时候,发现还是能继续输出get_num20_shoe函数里面的内容
local myBranchShoeStore = myshoestrore:new()
myBranchShoeStore.get_num20_shoe()

---当我们不使用__index元方法要指向自己的方法时候
local class = {}
class.__index = class
function class:new()
    return setmetatable( {}, self )
end

function class:get_num20_shoe()
	print("Size 20 shoes")
end

--当我们第一次new class的时候,发现可以输出get_num20_shoe函数的内容
local myshoestrore = class:new()
myshoestrore.get_num20_shoe()

-- 当我们在此调用通过myshoestroe new class的时候,发现就不能在继续输出get_num20_shoe函数里面的内容了,主要原因还是
-- myshoestrore里面是没有__index元方法的,导致继承链断了
local myBranchShoeStore = myshoestrore:new()
myBranchShoeStore.get_num20_shoe()

local _class = {}
-- super 为基类
function class(super)
    local class_type = {} --类模板
    class_type.ctor = false -- 构造函数
    class_type.super = super --赋值基类
    class_type.staticFun = {} --静态函数
    class_type.new = function(...) -- new方法成员
        local obj = {}
        do
            local create  --嵌套调用主要是为了能掉到基类ctor
            create = function(c, ...)
                if c.super then
                    create(c.super, ...) --调用基类ctor
                end
                if c.ctor then
                    c.ctor(obj, ...) --调用构造
                end
            end

            create(class_type, ...)
        end
        setmetatable(obj, {__index = _class[class_type]}) --利用元表__index设置保证 obj继承自_class[class_type]
        return obj
    end
    local vtbl = {} --vtbl理解为类容器也就是存类的成员,函数等等
    vtbl.super = _class[super] 
    _class[class_type] = vtbl

    setmetatable( -- 有新的成员存到vtbl中
        class_type,
        {
            __newindex = function(t, k, v)
                vtbl[k] = v
            end
        }
    )

    if super then
        setmetatable( -- 如果子类有成员直接返回,子类没有返回基类的成员
            vtbl,
            {
                __index = function(t, k)
                    local ret = _class[super][k]
                    vtbl[k] = ret
                    return ret
                end
            }
        )
    end

    return class_type
end

local myShoeStore = 
{
	num12_shoe = "Size 12 shoes",--12号鞋子
	num13_shoe = "Size 13 shoes",--13号鞋子
}

myShoeStore.num20_shoe = "Size 20 shoes" --费劲巴拉的在自己店铺弄出了一双20号款式的鞋子

local myShoeStore = 
{
	num12_shoe = "Size 12 shoes",--12号鞋子
	num13_shoe = "Size 13 shoes",--13号鞋子
}

 local myShoeFactory = {
      __newindex = function(table, key, value) --关键地方,靠的就是__newindex来进行鞋子的创建
          rawset(table, key, value);
        end
    }

 setmetatable(myShoeStore,myShoeFactory);--关键地方,这里等价于把两家店给串连起来了

 --- 有元表的情况下设置值,这样等价于我把本来要在主店创建20号鞋子的任务,丢给我的鞋子工厂去处理了
  myShoeStore.num20_shoe = "Size 20 shoes"

print(myShoeStore.num20_shoe)

local myShoeStore = 
{
	num12_shoe = "Size 12 shoes",--12号鞋子
	num13_shoe = "Size 13 shoes",--13号鞋子
}

 local myShoeFactory = {
      __newindex = 11111
    }

 setmetatable(myShoeStore,myShoeFactory);--关键地方,这里等价于把两家店给串连起来了

 --- 设置的不是table也不是函数的时候
  myShoeStore.num20_shoe = "Size 20 shoes"

print(myShoeStore.num20_shoe)

local myShoeStore = 
{
	num12_shoe = "Size 12 shoes",--12号鞋子
	num13_shoe = "Size 13 shoes",--13号鞋子
}

 local myShoeFactory = {
      
    }

 setmetatable(myShoeStore,myShoeFactory);--关键地方,这里等价于把两家店给串连起来了

 --- _元表没有_设置newindex的时候 
  myShoeStore.num20_shoe = "Size 20 shoes"

print(myShoeStore.num20_shoe)

local myShoeStore = 
{
	num12_shoe = "Size 12 shoes",--12号鞋子
	num13_shoe = "Size 13 shoes",--13号鞋子
}

local myShoeFactoryItem = {
	num20_shoe = "Size 21 shoes"
}

 local myShoeFactory = {
      __newindex = myShoeFactoryItem
    }

 setmetatable(myShoeStore,myShoeFactory);--关键地方,这里等价于把两家店给串连起来了

 print("set num20_shoe before myShoeFactoryItem.num20_shoe:",myShoeFactoryItem.num20_shoe)
 myShoeStore.num20_shoe =  "Size 20 shoes"
 print("set num20_shoe after myShoeFactoryItem.num20_shoe:",myShoeFactoryItem.num20_shoe)

print(myShoeStore.num20_shoe)

local myShoeStore = 
{
	num12_shoe = "Size 12 shoes",--12号鞋子
	num13_shoe = "Size 13 shoes",--13号鞋子
}

 local myShoeFactory = {
      __newindex = function(table, key, value) --关键地方,靠的就是__newindex来进行鞋子的创建
          rawset(table, key, value);--使用rawset来进行设置,因为不会去调用元方法对table进行设置,所以能得到更好的性能和避免元方法的无限递归调用
        end
    }

 setmetatable(myShoeStore,myShoeFactory);--关键地方,这里等价于把两家店给串连起来了

 --- 有元表的情况下设置值,这样等价于我把本来要在主店创建20号鞋子的任务,丢给我的鞋子工厂去处理了
  myShoeStore.num20_shoe = "Size 20 shoes"

print(myShoeStore.num20_shoe)

local myShoeStore = 
{
	num12_shoe = "Size 12 shoes",--12号鞋子
	num13_shoe = "Size 13 shoes",--13号鞋子
}

print("myShoeStore addr:",myShoeStore)--先打印下myShoeStore table地址

local myShoeFactoryGC = {
	__gc =1111
}

setmetatable(myShoeStore,myShoeFactoryGC);

myShoeStore = nil --设置成nil,下面调用collectgarbage才会被回收
collectgarbage()-- 进行gc回收

local myShoeStore = 
{
	num12_shoe = "Size 12 shoes",--12号鞋子
	num13_shoe = "Size 13 shoes",--13号鞋子
}

print("myShoeStore addr:",myShoeStore)--先打印下myShoeStore table地址

local myShoeFactoryGC = {
	__gc =function( table )
		print("myShoeFactoryGC released table addr:",table) -- myShoeStore table被回收了
	end
}

setmetatable(myShoeStore,myShoeFactoryGC);

myShoeStore = nil --设置成nil,下面调用collectgarbage才会被回收
collectgarbage()-- 进行gc回收

local myShoeStore = 
{
	num12_shoe = "Size 12 shoes",--12号鞋子
	num13_shoe = "Size 13 shoes",--13号鞋子
}

 local myBranchShoeStore = {
		num20_shoe = "Size 20 shoes",--20号鞋子
		num21_shoe = "Size 21 shoes",--21号鞋子
}

local contract = {} --两人在此建立合同
contract[1] = myShoeStore
contract[2] = myBranchShoeStore

myBranchShoeStore = nil --设置成nil,下面调用collectgarbage才会被回收
collectgarbage()-- 进行gc回收


for k,v in pairs(contract) do
	print(k,v)
end

local myShoeStore = 
{
	num12_shoe = "Size 12 shoes",--12号鞋子
	num13_shoe = "Size 13 shoes",--13号鞋子
}

 local myBranchShoeStore = {
		num20_shoe = "Size 20 shoes",--20号鞋子
		num21_shoe = "Size 21 shoes",--21号鞋子
}

local contract = {} --两人在此建立合同
contract[1] = myShoeStore
contract[2] = myBranchShoeStore

for k,v in pairs(contract) do
	print(k,v)
end

print("\n-------------collectgarbage after-----------------")
setmetatable(contract,{__mode="v"})--这个地方把value设置成了弱引用

myBranchShoeStore = nil --设置成nil,下面调用collectgarbage才会被回收
collectgarbage()-- 进行gc回收


for k,v in pairs(contract) do
	print(k,v)
end

local myShoeStore = 
{
	num12_shoe = {12,"Size 12 shoes"},--12号鞋子
	num13_shoe = {13,"Size 13 shoes"},--13号鞋子
	num20_shoe = {20,"Size 20 shoes"},--20号鞋子
	num21_shoe = {21,"Size 21 shoes"},--21号鞋子
	num22_shoe = {22,"Size 22 shoes"},--22号鞋子
	num23_shoe = {23,"Size 23 shoes"},--23号鞋子
}

local myShoeStoreLen ={
	__len = function (table) --通过此处的计算直接把20号以上的鞋子都给统计出来
	local len = 0
	for k,v in pairs(table) do
		if( 20 <= v[1]) then
			len= len+ 1
		end
	end

	return len;
end

}

setmetatable(myShoeStore, myShoeStoreLen);

print(#myShoeStore)--这个地方得到__len元方法统计的数据量大小

local myShoeStore = {12,13,14,15,16,17}
print(#myShoeStore)

local myShoeStore = {12,nil,nil,nil,nil,17}
print(#myShoeStore)

local myShoeStore = {nil,nil,nil,nil,nil,17}
print(#myShoeStore)

local myShoeStore = {12,13,14,15,16,nil}
print(#myShoeStore)

local myShoeStore = {12,nil,nil,nil,16,nil}
print(#myShoeStore)

local myShoeStore = {nil,nil,nil,nil,16,nil}
print(#myShoeStore)

local myShoeStore = {12,13,14,15,nil,nil}
print(#myShoeStore)

第一轮 i = 0；j = 6；判断j - i > 1；进入white循环
第二轮 i = 0；j = 6；m = (i + j) / 2 = 3；判断array[m - 1]是不是空,不为空; i=m=3；判断j - i > 1；进入white循环
第三轮 i = 3；j = 6；m = (i + j) / 2 = 4；判断array[m - 1]是不是空,不为空; i=m=4；判断j - i > 1；进入white循环
第四轮 i = 4；j = 6；m = (i + j) / 2 = 5；判断array[m - 1]是不是空,为空; j=m=5；判断j - i 不大于1；退出循环,并返回i值

local myShoeStore = {12,13,nil,nil,nil,nil}
print(#myShoeStore)

local myShoeStore = {12,13,nil,nil,nil,nil}
print(#myShoeStore)

local myShoeStore = 
{
	[1] = "Size 12 shoes",--12号鞋子

	[3] = "Size 20 shoes",--20号鞋子
	[4] = "Size 21 shoes",--21号鞋子
	[5] = "Size 22 shoes",--22号鞋子
	[6] = "Size 23 shoes",--23号鞋子
}

print(#myShoeStore)

第一轮 i = 1; j = 2; t[2] 为nil 然后j - i 不大于1 所以直接返回i也就是大小1  

local myShoeStore = 
{
	[1] = "Size 12 shoes",--12号鞋子
	[2] = "Size 13 shoes",--13号鞋子
	[3] = "Size 20 shoes",--20号鞋子
	[4] = "Size 21 shoes",--21号鞋子

	[6] = "Size 23 shoes",--23号鞋子
}

print(#myShoeStore)

第一轮 i = 1; j = 2; t[2]不为nil；继续下一轮white循环
第二轮 i = 2; j = 4; t[4]不为nil；继续下一轮white循环
第三轮 i = 4; j = 8; t[8]为nil并且j - i > 1； 进入二分查找阶段
第四轮 i = 4; j = 8; m = (i + j) / 2 = 6; t[m]不为空设置i = 6；判断j - i > 1;继续下一轮二分查找
第五轮 i = 6; j = 8；m = (i + j) / 2 = 7; t[m]为空设置j = 7; 判断j - i 不大于1 结束二分查找返回i的值为6

local myShoeStore = 
{
	"Size 12 shoes",--12号鞋子
	"Size 13 shoes",--13号鞋子
	[3] = "Size 20 shoes",--20号鞋子
	[4] = "Size 21 shoes",--21号鞋子
	[5] = "Size 23 shoes",--23号鞋子
}

print(#myShoeStore)

第一轮 i = 2; j = 4; t[4]不为nil；继续下一轮white循环
第二轮 i = 4; j = 8; t[8]为nil；跳出white循环;判断j - i 是否大于1;发现大于;进入二分查找
第三轮 i = 4; j = 8; m = (i + j) / 2 = 6；t[m]为nil；j=m=6；判断j - i 是否大于1 发现大于,继续下一轮二分查找
第四轮 i = 4; j = 6；m = (i + j) / 2 = 5; t[m]不为nil i=m=5; 判断j - i 是否大于1 发现是等于1不符合条件,跳出循环,返回i,也就是5

local myShoeStore = 
{
	"Size 12 shoes",--12号鞋子
	"Size 13 shoes",--13号鞋子
	[4] = "Size 21 shoes",--21号鞋子
	[5] = "Size 23 shoes",--23号鞋子
}

print(#myShoeStore)

function table.length(t)
    local i = 0
    for k, v in pairs(t) do
        i = i + 1
    end
    return i
end

local myShoeStore = 
{
	{"Size 12 shoes",50,20},--鞋子类型,销售额,数量
	{"Size 13 shoes",50,80},--鞋子类型,销售额,数量
	{"Size 14 shoes",80,80},--鞋子类型,销售额,数量
}

 local myBranchShoeStore = {
	{"Size 20 shoes",50,40},--鞋子类型,销售额,数量
	{"Size 21 shoes",50,80},--鞋子类型,销售额,数量
}

--盘点操作用来做Metatable
inventoryOpe = {}

--定义相等操作来比较一下主店和分店各自销售量是不是一样
inventoryOpe.__eq = function(table1, table2)
	return #table1 == #table2
end

setmetatable(myShoeStore, inventoryOpe)

--比较一下主店和分店各自销售量是不是一样
local isSame = myShoeStore == myBranchShoeStore

print(isSame)

local myShoeStore = 
{
	{"Size 12 shoes",50,20},--鞋子类型,销售额,数量
	{"Size 13 shoes",50,80},--鞋子类型,销售额,数量
	{"Size 14 shoes",80,80},--鞋子类型,销售额,数量
}

 local myBranchShoeStore = {
	{"Size 20 shoes",50,40},--鞋子类型,销售额,数量
	{"Size 21 shoes",50,80},--鞋子类型,销售额,数量
}

--盘点操作用来做Metatable
inventoryOpe = {}

--定义乘法操作来统计下主店和分店一共挣了多少钱
inventoryOpe.__mul = function(table1, table2)
	local money = 0
	for  _,v in pairs(table1) do
		money = money + (v[2] * v[3])
	end

	for  _,v in pairs(table2) do
		money = money + (v[2] * v[3])
	end

	return money
end

setmetatable(myShoeStore, inventoryOpe)

--统计下主店和分店一共挣了多少钱
local money = myShoeStore * myBranchShoeStore

print(money)

local myShoeStore = 
{
	{"Size 12 shoes",50,20},--鞋子类型,销售额,数量
	{"Size 13 shoes",50,80},--鞋子类型,销售额,数量
	{"Size 14 shoes",80,80},--鞋子类型,销售额,数量
}

 local myBranchShoeStore = {
	{"Size 20 shoes",50,40},--鞋子类型,销售额,数量
	{"Size 21 shoes",50,80},--鞋子类型,销售额,数量
}

--盘点操作用来做Metatable
inventoryOpe = {}

--定义加法操作用来统计主店和分店的销售数据
inventoryOpe.__add = function(table1, table2)
	 for _, value in pairs(table2) do
      table.insert(table1, value)
   end
   return table1
end

setmetatable(myShoeStore, inventoryOpe)

--统计主店和分店总的销售数据
local totalShoeInfo = myShoeStore + myBranchShoeStore
--输出一下结果
for k,v in pairs(totalShoeInfo) do
	local item = ""
	for i=1,3 do
		if i ~= 3 then
			item = item .. v[i] .. ","
		else
			item = item .. v[i]
		end
	end

	print("{" .. item .. "}")
end

local myShoeStore = 
{
	{"Size 12 shoes",50,20},--鞋子类型,销售额,数量
	{"Size 13 shoes",50,80},--鞋子类型,销售额,数量
	{"Size 14 shoes",80,80},--鞋子类型,销售额,数量
}

--盘点操作用来做Metatable
inventoryOpe = {}

--定义函数调用操作来查看下每日完成金额量差距
inventoryOpe.__call = function(self,target)
	local num14 = 0
	for _,v in pairs(self) do
		num14 = num14 + (v[2] * v[3])
	end

	return target - num14
end

setmetatable(myShoeStore, inventoryOpe)

--查看下主店每日完成金额量差距
print(myShoeStore(10000))--假设需要每日完成10000金额的销售量

local myShoeStore = 
{
	{"Size 12 shoes",50,20},--鞋子类型,销售额,数量
	{"Size 13 shoes",50,80},--鞋子类型,销售额,数量
	{"Size 14 shoes",80,80},--鞋子类型,销售额,数量
	light = true, --灯开着
}

--盘点操作用来做Metatable
inventoryOpe = {}

--定义__close操作当店铺晚上关门的时候能自动把店铺的灯关闭
inventoryOpe.__close = function(self)
	self.light = false
end

setmetatable(myShoeStore, inventoryOpe)

--当主店铺晚上关门的时候能自动把店铺的灯关闭

do 
	local closeStore <close> = myShoeStore
end

print(myShoeStore.light)

local myShoeStore = 
{
	{"Size 12 shoes",50,20},--鞋子类型,销售额,数量
	{"Size 13 shoes",50,80},--鞋子类型,销售额,数量
	{"Size 14 shoes",80,80},--鞋子类型,销售额,数量
}

print("--------------set __pairs before------------------")
for k,v in pairs(myShoeStore) do
	print(v)
end

--盘点操作用来做Metatable
inventoryOpe = {}

local func = function (tbl, key)
    local nk, nv = next(tbl, key)
    if nk then 
        nv = 10 --这个地方随便写的只是为了表达我正在重写pairs,你可以按自己的实际需求改成你想要的
    end
    return nk, nv
end

--定义__pairs操作设定自定义遍历
inventoryOpe.__pairs = function(tbl)
	 return func, tbl, nil
end

setmetatable(myShoeStore, inventoryOpe)

print("--------------set __pairs after------------------")
--输出一下结果
for k,v in pairs(myShoeStore) do
	local item = ""
	for i=1,3 do
		if i ~= 3 then
			item = item .. v .. ","
		else
			item = item .. v
		end
	end

	print("{" .. item .. "}")
end

a = {}
setmetatable(a,{__metatable = "hello"})
setmetatable(a,{__metatable = "world"})

local myShoeStore = 
{
	{"Size 12 shoes",50,20},--鞋子类型,销售额,数量
	{"Size 13 shoes",50,80},--鞋子类型,销售额,数量
	{"Size 14 shoes",80,80},--鞋子类型,销售额,数量
}

print("--------------set __tostring before------------------")
for k,v in pairs(myShoeStore) do
	print(v)
end

--盘点操作用来做Metatable
inventoryOpe = {}


--定义__tostring操作重写table输出
inventoryOpe.__tostring = function(tbl)
	local str = ""
	for k,v in pairs(tbl) do
		str = str .."name:" .. v[1] .. " sales:"   .. v[2] .. " num:" .. v[3] .. "\n"
	end

	return str
end

setmetatable(myShoeStore, inventoryOpe)

print("--------------set __tostring after------------------")
--输出一下结果
print(myShoeStore)