用友元表达两个复数相加

可以使用以下代码实现：

-- 定义复数加法函数
function complex_add(a, b)
    return {a[1] + b[1], a[2] + b[2]}
end

-- 定义两个复数
local a = {1, 2}
local b = {3, 4}

-- 将复数加法函数设置为a的元表
setmetatable(a, {
    __add = complex_add
})

-- 执行复数加法
local c = a + b

-- 输出结果
print(c[1], c[2]) -- 输出 4 6

这段代码使用了元表来实现复数加法，将复数加法函数设置为一个复数的元表，然后使用加法运算符来执行加法操作。

相关问题

用友元加法运算符重载异或加密

首先，我们定义一个类`XorEncrypt`，其中包含一个私有成员`std::string str`，表示待加密的字符串。然后，我们需要重载加法运算符`+`和异或运算符`^`。

为了能够在加密函数中访问`XorEncrypt`类的私有成员`str`，我们需要使用友元函数。因此，我们将加法运算符重载函数和异或运算符重载函数声明为`XorEncrypt`类的友元函数。

具体实现如下：

#include <iostream>
#include <string>

class XorEncrypt {
public:
    XorEncrypt(const std::string& s) : str(s) {}
    friend XorEncrypt operator+(const XorEncrypt& e1, const XorEncrypt& e2);
    friend XorEncrypt operator^(const XorEncrypt& e1, const XorEncrypt& e2);
    void print() { std::cout << str << std::endl; }
private:
    std::string str;
};

XorEncrypt operator+(const XorEncrypt& e1, const XorEncrypt& e2) {
    return XorEncrypt(e1.str + e2.str);
}

XorEncrypt operator^(const XorEncrypt& e1, const XorEncrypt& e2) {
    std::string result = "";
    for (int i = 0; i < e1.str.length(); i++) {
        result += (char)(e1.str[i] ^ e2.str[i % e2.str.length()]);
    }
    return XorEncrypt(result);
}

int main() {
    XorEncrypt e1("hello");
    XorEncrypt e2("world");
    XorEncrypt e3 = e1 + e2;
    e3.print();
    XorEncrypt e4 = e1 ^ e2;
    e4.print();
    return 0;
}

在上述代码中，我们首先定义了`XorEncrypt`类，并在其中定义了一个私有成员`std::string str`，表示待加密的字符串。然后我们重载了加法运算符`+`和异或运算符`^`，并将它们声明为`XorEncrypt`类的友元函数。

在`operator+`函数中，我们通过对两个`XorEncrypt`对象的`str`成员进行拼接，得到一个新的`XorEncrypt`对象。

在`operator^`函数中，我们对两个`XorEncrypt`对象的`str`成员进行逐个异或运算，并将结果存入一个新的字符串中。需要注意的是，为了让两个字符串的长度相同，我们将`e2.str`的长度作为循环的次数取模，以保证可以对`e1.str`的每个字符都进行异或运算。

最后，在`main`函数中，我们创建了两个`XorEncrypt`对象`e1`和`e2`，并使用加法运算符和异或运算符对它们进行了运算，得到了两个新的`XorEncrypt`对象`e3`和`e4`。然后我们分别调用了它们的`print`函数，输出了加密后的结果。

设计一个分数类，将加减乘除运算符重载，加减用成员函数，乘除用友元

下面是一个设计分数类的示例代码，实现了加减乘除的运算符重载：

#include <iostream>
#include <cmath>

using namespace std;

class Fraction {
public:
    Fraction(int num, int den = 1) : numerator(num), denominator(den) {}
    Fraction operator+(const Fraction& rhs);
    Fraction operator-(const Fraction& rhs);
    friend Fraction operator*(const Fraction& lhs, const Fraction& rhs);
    friend Fraction operator/(const Fraction& lhs, const Fraction& rhs);
    void print();
private:
    int numerator;
    int denominator;
    void reduce();
};

Fraction Fraction::operator+(const Fraction& rhs) {
    int new_num = numerator * rhs.denominator + denominator * rhs.numerator;
    int new_den = denominator * rhs.denominator;
    return Fraction(new_num, new_den);
}

Fraction Fraction::operator-(const Fraction& rhs) {
    int new_num = numerator * rhs.denominator - denominator * rhs.numerator;
    int new_den = denominator * rhs.denominator;
    return Fraction(new_num, new_den);
}

Fraction operator*(const Fraction& lhs, const Fraction& rhs) {
    int new_num = lhs.numerator * rhs.numerator;
    int new_den = lhs.denominator * rhs.denominator;
    return Fraction(new_num, new_den);
}

Fraction operator/(const Fraction& lhs, const Fraction& rhs) {
    int new_num = lhs.numerator * rhs.denominator;
    int new_den = lhs.denominator * rhs.numerator;
    return Fraction(new_num, new_den);
}

void Fraction::print() {
    reduce();
    cout << numerator << "/" << denominator << endl;
}

void Fraction::reduce() {
    int gcd = abs(__gcd(numerator, denominator));
    numerator /= gcd;
    denominator /= gcd;
}

int main() {
    Fraction a(1, 2);
    Fraction b(3, 4);
    Fraction c = a + b;
    c.print(); // 输出 5/4
    c = a - b;
    c.print(); // 输出 -1/4
    c = a * b;
    c.print(); // 输出 3/8
    c = a / b;
    c.print(); // 输出 2/3
    return 0;
}

在上面的代码中，我们定义了一个分数类`Fraction`，其中`numerator`表示分子，`denominator`表示分母。构造函数可以接受一个分子和一个分母，如果只传入一个参数，则默认分母为1。`operator+`和`operator-`是成员函数，重载了加法和减法运算符。`operator*`和`operator/`是友元函数，重载了乘法和除法运算符。`print`函数用于输出分数，`reduce`函数用于化简分数。在`main`函数中，我们创建了两个分数`a`和`b`，然后对它们进行加减乘除运算，并输出结果。