《Lua高级编程》3.4 实战案例：利用元表实现自定义数据结构和操作符重载

-- 定义 Vector 类
local Vector = {}
Vector.__index = Vector

-- 构造函数
function Vector:new(x, y)
    local obj = { x = x or 0, y = y or 0 }
    setmetatable(obj, self)
    return obj
end

-- 定义加法运算：向量加向量
function Vector.__add(a, b)
    return Vector:new(a.x + b.x, a.y + b.y)
end

-- 定义减法运算：向量减向量
function Vector.__sub(a, b)
    return Vector:new(a.x - b.x, a.y - b.y)
end

-- 定义乘法运算：支持数乘或点乘
-- 此处设计为：如果乘数为数字，则进行标量乘法；如果乘数为 Vector，则进行点乘
function Vector.__mul(a, b)
    if type(a) == "number" then
        -- 数值乘向量：a * b
        return Vector:new(a * b.x, a * b.y)
    elseif type(b) == "number" then
        -- 向量乘数值：a * b
        return Vector:new(a.x * b, a.y * b)
    elseif getmetatable(a) == Vector and getmetatable(b) == Vector then
        -- 向量点乘，返回数值
        return a.x * b.x + a.y * b.y
    else
        error("不支持的乘法操作")
    end
end

-- 定义一元负号：取反向量
function Vector.__unm(a)
    return Vector:new(-a.x, -a.y)
end

-- 定义字符串转换：便于打印输出
function Vector:__tostring()
    return string.format("Vector(%.2f, %.2f)", self.x, self.y)
end

-- 测试向量运算
local v1 = Vector:new(3, 4)
local v2 = Vector:new(1, 2)
local sum = v1 + v2
local diff = v1 - v2
local scaled = v1 * 2
local dotProduct = v1 * v2  -- 点乘，返回数字
local neg = -v1

print("v1:", v1)               -- 输出：Vector(3.00, 4.00)
print("v2:", v2)               -- 输出：Vector(1.00, 2.00)
print("v1 + v2:", sum)         -- 输出：Vector(4.00, 6.00)
print("v1 - v2:", diff)        -- 输出：Vector(2.00, 2.00)
print("v1 * 2:", scaled)       -- 输出：Vector(6.00, 8.00)
print("v1 点乘 v2:", dotProduct)  -- 输出：11
print("负 v1:", neg)           -- 输出：Vector(-3.00, -4.00)

-- 定义 Complex 类
local Complex = {}
Complex.__index = Complex

-- 构造函数：创建一个复数对象
function Complex:new(real, imag)
    local obj = { real = real or 0, imag = imag or 0 }
    setmetatable(obj, self)
    return obj
end

-- 定义加法运算：复数加法
function Complex.__add(a, b)
    return Complex:new(a.real + b.real, a.imag + b.imag)
end

-- 定义减法运算：复数减法
function Complex.__sub(a, b)
    return Complex:new(a.real - b.real, a.imag - b.imag)
end

-- 定义乘法运算：复数乘法
function Complex.__mul(a, b)
    return Complex:new(a.real * b.real - a.imag * b.imag,
                       a.real * b.imag + a.imag * b.real)
end

-- 定义除法运算：复数除法，需检查分母是否为零
function Complex.__div(a, b)
    local denominator = b.real * b.real + b.imag * b.imag
    if denominator == 0 then
        error("除数复数为零")
    end
    return Complex:new((a.real * b.real + a.imag * b.imag) / denominator,
                       (a.imag * b.real - a.real * b.imag) / denominator)
end

-- 定义一元负号：复数取反
function Complex.__unm(a)
    return Complex:new(-a.real, -a.imag)
end

-- 定义 __tostring 方法，便于格式化输出
function Complex:__tostring()
    local sign = self.imag >= 0 and "+" or "-"
    return string.format("(%g %s %gi)", self.real, sign, math.abs(self.imag))
end

-- 测试复数运算
local c1 = Complex:new(3, 4)
local c2 = Complex:new(1, -2)
local sum = c1 + c2
local diff = c1 - c2
local prod = c1 * c2
local quot = c1 / c2
local neg = -c1

print("c1:", c1)        -- 输出例如：(3 + 4i)
print("c2:", c2)        -- 输出例如：(1 - 2i)
print("c1 + c2:", sum)  -- 输出复数加法结果
print("c1 - c2:", diff) -- 输出复数减法结果
print("c1 * c2:", prod) -- 输出复数乘法结果
print("c1 / c2:", quot) -- 输出复数除法结果
print("-c1:", neg)      -- 输出取负结果

local Matrix = {}
Matrix.__index = Matrix

-- 构造函数：创建一个 m 行 n 列的矩阵，初始值为0
function Matrix:new(m, n, init)
    local obj = { m = m, n = n, data = {} }
    for i = 1, m do
        obj.data[i] = {}
        for j = 1, n do
            obj.data[i][j] = init or 0
        end
    end
    setmetatable(obj, self)
    return obj
end

-- 定义 __tostring 方法用于矩阵输出
function Matrix:__tostring()
    local s = ""
    for i = 1, self.m do
        local row = {}
        for j = 1, self.n do
            table.insert(row, string.format("%g", self.data[i][j]))
        end
        s = s .. table.concat(row, "\t") .. "\n"
    end
    return s
end

-- 定义矩阵加法：要求两个矩阵尺寸相同
function Matrix.__add(a, b)
    if a.m ~= b.m or a.n ~= b.n then
        error("矩阵尺寸不匹配，无法相加")
    end
    local result = Matrix:new(a.m, a.n)
    for i = 1, a.m do
        for j = 1, a.n do
            result.data[i][j] = a.data[i][j] + b.data[i][j]
        end
    end
    return result
end

-- 定义矩阵乘法：支持矩阵乘矩阵以及矩阵与标量相乘
function Matrix.__mul(a, b)
    if type(a) == "number" then
        -- 数字乘矩阵：a * b
        local result = Matrix:new(b.m, b.n)
        for i = 1, b.m do
            for j = 1, b.n do
                result.data[i][j] = a * b.data[i][j]
            end
        end
        return result
    elseif type(b) == "number" then
        -- 矩阵乘数字：a * b
        local result = Matrix:new(a.m, a.n)
        for i = 1, a.m do
            for j = 1, a.n do
                result.data[i][j] = a.data[i][j] * b
            end
        end
        return result
    else
        -- 矩阵乘矩阵：要求 a.n == b.m
        if a.n ~= b.m then
            error("矩阵尺寸不匹配，无法相乘")
        end
        local result = Matrix:new(a.m, b.n)
        for i = 1, a.m do
            for j = 1, b.n do
                local sum = 0
                for k = 1, a.n do
                    sum = sum + a.data[i][k] * b.data[k][j]
                end
                result.data[i][j] = sum
            end
        end
        return result
    end
end

-- 定义矩阵转置：返回一个新矩阵，其行列互换
function Matrix:transpose()
    local result = Matrix:new(self.n, self.m)
    for i = 1, self.m do
        for j = 1, self.n do
            result.data[j][i] = self.data[i][j]
        end
    end
    return result
end

-- 测试矩阵运算
local A = Matrix:new(2, 3, 1)  -- 2行3列，初始值均为1
local B = Matrix:new(2, 3, 2)  -- 2行3列，初始值均为2
local C = A + B
print("矩阵 A:")
print(A)
print("矩阵 B:")
print(B)
print("A + B:")
print(C)

local D = Matrix:new(3, 2)
-- 为 D 手动赋值
D.data = { {1, 2}, {3, 4}, {5, 6} }
local E = A * D  -- A 为 2x3, D 为 3x2, E 为 2x2
print("矩阵 D:")
print(D)
print("A * D:")
print(E)

-- 标量乘法
local F = A * 3
print("A * 3:")
print(F)

-- 转置
local At = A:transpose()
print("矩阵 A 的转置:")
print(At)

local Polynomial = {}
Polynomial.__index = Polynomial

-- 构造函数：传入系数数组，系数数组的第一个元素为常数项
function Polynomial:new(coeffs)
    local obj = { coeffs = coeffs or {} }
    setmetatable(obj, self)
    return obj
end

-- 辅助函数：清理多余的零
local function trim(coeffs)
    local i = #coeffs
    while i > 1 and coeffs[i] == 0 do
        coeffs[i] = nil
        i = i - 1
    end
    return coeffs
end

-- 定义加法：多项式加法，对应系数逐项相加
function Polynomial.__add(a, b)
    local maxn = math.max(#a.coeffs, #b.coeffs)
    local resultCoeffs = {}
    for i = 1, maxn do
        local ca = a.coeffs[i] or 0
        local cb = b.coeffs[i] or 0
        resultCoeffs[i] = ca + cb
    end
    return Polynomial:new(trim(resultCoeffs))
end

-- 定义乘法：多项式乘法（卷积），结果多项式的次数为 a.degree + b.degree
function Polynomial.__mul(a, b)
    local m = #a.coeffs
    local n = #b.coeffs
    local resultCoeffs = {}
    for i = 1, m + n - 1 do
        resultCoeffs[i] = 0
    end
    for i = 1, m do
        for j = 1, n do
            resultCoeffs[i + j - 1] = resultCoeffs[i + j - 1] + a.coeffs[i] * b.coeffs[j]
        end
    end
    return Polynomial:new(trim(resultCoeffs))
end

-- 定义 __tostring：格式化输出多项式
function Polynomial:__tostring()
    local terms = {}
    for i = #self.coeffs, 1, -1 do
        local coeff = self.coeffs[i]
        if coeff ~= 0 then
            local term = ""
            -- 处理系数
            if i == 1 then
                term = term .. coeff
            else
                if coeff == 1 then
                    term = term .. ""
                elseif coeff == -1 then
                    term = term .. "-"
                else
                    term = term .. coeff
                end
            end
            -- 处理变量部分
            if i > 1 then
                term = term .. "x"
                if i > 2 then
                    term = term .. "^" .. (i - 1)
                end
            end
            table.insert(terms, term)
        end
    end
    if #terms == 0 then
        return "0"
    else
        return table.concat(terms, " + "):gsub("%+ %-", "- ")
    end
end

-- 测试多项式运算
-- 定义多项式 P(x) = 2x^2 + 3x + 4，系数数组表示为 {4, 3, 2}
local P = Polynomial:new({4, 3, 2})
-- 定义多项式 Q(x) = -x + 5，系数数组为 {5, -1}
local Q = Polynomial:new({5, -1})
local R = P + Q
local S = P * Q

print("多项式 P(x):", P)  -- 输出：2x^2 + 3x + 4
print("多项式 Q(x):", Q)  -- 输出：-x + 5
print("P(x) + Q(x):", R)  -- 输出：2x^2 + 2x + 9
print("P(x) * Q(x):", S)  -- 输出：多项式乘积

function Polynomial:evaluate(x)
    local result = 0
    for i = 1, #self.coeffs do
        result = result + self.coeffs[i] * x^(i-1)
    end
    return result
end

print("P(2) =", P:evaluate(2))  -- 计算 P(x) 在 x = 2 时的值

local MixedObject = {}
MixedObject.__index = function(t, key)
    -- 如果对象自身存在该字段，直接返回，否则查找默认方法表
    return rawget(t, key) or MixedObject.methods[key]
end

-- 默认方法表，保存基本操作
MixedObject.methods = {}

-- 构造函数：创建一个混合对象，包含一个数值和一个模式字段
function MixedObject:new(value, mode)
    local obj = { value = value or 0, mode = mode or "normal" }
    setmetatable(obj, self)
    return obj
end

-- 定义一个默认加法方法
function MixedObject.methods:add(other)
    if type(other) ~= "table" or not other.value then
        error("参数错误：需要传入 MixedObject 对象")
    end
    if self.mode == "normal" then
        return MixedObject:new(self.value + other.value, self.mode)
    elseif self.mode == "double" then
        -- 双倍加法模式：将加法结果乘以2
        return MixedObject:new((self.value + other.value) * 2, self.mode)
    else
        error("未知模式：" .. tostring(self.mode))
    end
end

-- 利用 __add 元方法实现操作符重载
function MixedObject.__add(a, b)
    return a:add(b)
end

-- 定义 __tostring 方法，用于输出对象信息
function MixedObject:__tostring()
    return string.format("MixedObject(value=%s, mode=%s)", tostring(self.value), tostring(self.mode))
end

-- 定义动态切换模式的方法
function MixedObject:setMode(newMode)
    self.mode = newMode
end

-- 测试混合对象动态绑定
local obj1 = MixedObject:new(10, "normal")
local obj2 = MixedObject:new(20, "normal")

print("初始模式：")
print(obj1)  -- MixedObject(value=10, mode=normal)
print(obj2)  -- MixedObject(value=20, mode=normal)

local objSum = obj1 + obj2
print("正常加法结果：", objSum)  -- MixedObject(value=30, mode=normal)

-- 切换到双倍模式
obj1:setMode("double")
obj2:setMode("double")
local objSum2 = obj1 + obj2
print("双倍模式加法结果：", objSum2)  -- (10+20)*2 = 60

-- 动态绑定机制使得同一操作符在不同模式下表现不同

local iterations = 1e6
local v1 = Vector:new(3, 4)
local v2 = Vector:new(1, 2)
local startTime = os.clock()
for i = 1, iterations do
    local s = v1 + v2
end
local elapsed = os.clock() - startTime
print(string.format("向量加法执行 %d 次耗时：%.4f 秒", iterations, elapsed))