# SR锁存器
用与非门实现SR锁存器如下
<center>
    <img src="/static/img/f1eaa896352e185c939b113fd7e6e4df.image.webp" width=30%>
</center>
根据与非门的特性，有



$$
Q=\overline{R+\overline{Q}},~\overline{Q}=\overline{{S+Q}}
$$

注意到当$S=0,R=0$时，有

$$
Q=Q,~\overline{Q}=\overline{Q}
$$

这意味着$Q$表征了它的状态，当$S=R=0$时，状态不变。$S$称为**置1端(set)**，$R$称为**置0端(reset)**

:::info{title="note"}
置0端为高电平时将$Q$置0，置1端为高电平时将$Q$置为1
:::

可以画出或非门SR锁存器的功能表

![image.png](/static/img/b4130fc9d585109e1378c7b334094120.image.webp)

需要注意的是当$S=R=1$时，按照或非门的逻辑特性有
$$
Q=\overline{Q}=1
$$
这显然是不可以的，如果$S$和$R$同时跳为$0$，那么$Q$的状态将不可知。因而SR锁存器有一个禁忌

:::warning{title="注意"}
不可以将SR锁存器的$S$引脚和$R$引脚同时置为1
:::

或非门SR锁存器的逻辑符号如下
<center>
    <img src="/static/img/550a6a3f25ea56856821679c09e43865.image.webp" width=30%>
</center>

输出引脚上的小圈圈表示0有效，即当$Q$为$1$时引脚输出为$0$

---

SR锁存器除了可以使用或非门，也可以使用与非门

<center>
    <img src="/static/img/1c5b040872bb08d619b439f7f4bcdab7.image.webp" width=30%>
</center>

不过鉴于
$$
\overline{AB}=\overline{A}+\overline{B}
$$
它实际上相当于

<center>
    <img src="/static/img/43597d370681aa0411014c52d73f41c1.image.webp" width=30%>
</center>

它的逻辑符号就可以简写为

<center>
    <img src="/static/img/6153cef5a894c5d16a8f231bf2acc163.image.webp" width=30%>
</center>

左侧的小圈圈表示0有效，即$S$引脚输入为0时将$Q$置为1，$R$引脚为0时将$Q$置为0。如果需要使得$S$为1时置1，$S$引脚应当输入$\overline{S}$

# 门控SR锁存器
门控SR锁存器添加了使能端，只有当使能端为高电平时才使得输入有效。门控SR锁存器的电路和逻辑符号如下

![image.png](/static/img/4ced268521fcb7352042a1d07f59a66b.image.webp)

它的功能表如下

![image.png](/static/img/05c2cdba11bf87dd4c937fc2a6b17905.image.webp)

也可以使用与非门构建，电路图如下

<center>
    <img src="/static/img/4a380d4c14c9e5a6c50c45f7deb35871.image.webp" width=50%>
</center>

根据前文所述，由于进行了取反，S和R的位置与或非门的相反

# D锁存器

D锁存器使用了一个D引脚代替了SR引脚控制置1和置0，另有使能信号控制是否保持状态。D锁存器可以由传输门构建也可以由逻辑门构建

<center>
    <img src="/static/img/c2e17c0a80ed14b70ed5c632203ab2bf.image.webp" width=49%>
    <img src="/static/img/2ab72ce8ec7a61d33a397dcaf742c511.image.webp" width=49%>
</center>
它的功能表如下

![image.png](/static/img/d1191e84c85b35f2242ede277f755459.image.webp)

需要注意的是，**建立时间$t_{SU}$** **保持时间$t_H$** **脉冲宽度$t_w$**

:::info{title="note"}
D的逻辑电平需要在使能E的有效电平结束前一段时间($t_{SU}$)建立，需要在E的的有效电平结束后保持一段时间($t_H$)，为了使Q正确的置为D，使能信号E需要保持一段时间($t_w$)
:::

事实上输出Q相对于D和E也存在延迟，不过它们的延迟相差不大。但是Q从0跳1与从1跳0的延迟具有差异，记为
$$
t_{pLH}(0\to 1),~t_{pHL}(1\to 0)
$$
一般取其平均延迟
$$
t_{pd}=\dfrac{1}{2}(t_{pLH}+t_{PHL})

SR锁存器与D锁存器

红黑树是一种自平衡的二叉搜索树，广泛应用于计算机科学中的各种领域，如操作系统的调度、数据库索引以及集合的高效管理。它通过严格的颜色规则和旋转操作，确保树的高度始终保持在较低水平，从而实现快速的插入、删除和查找操作



# 红黑树的定义
红黑树是一棵二叉搜索树，即树中的每个节点都应满足性质
- 左儿子比它小
- 右儿子不比它小

不过这样朴素的二叉搜索树会出现退化的问题，比如一条有序的链也是合法的二叉搜素树，此时查询的时间复杂度就会将为$O(n)$，这是不好的。为了解决这个问题，红黑树引入了染色机制
1. 每个节点都有颜色，要么为`红色`，要么为`黑色`
2. 红色节点的子节点只能为黑色
3. 每一个叶子节点视为拥有两个黑色的NULL节点
4. **每个从根到NULL的路径上具有相同数目的黑色节点**

关键就在于第四条，这意味着红黑树有一条非常好的性质

:::info{title="红黑树的高度性质"}
红黑树的叶节点最大深度不超过最小深度的两倍
:::
这是说红黑树可以看作是“近似平衡”的二叉树，查询操作的时间复杂度上限为$O(2\log N)$。为了简单起见还规定
- 红黑树的根节点是黑色的

# 左旋和右旋
不同于平衡二叉树，红黑树的节点仅有两种基本操作：左旋和右旋

右旋是将节点变为左儿子的右节点

![image.png](/static/img/e53aa054a3d2e18447225aeac202b19b.image.webp)

与之相反，左旋就是将节点变为右儿子的左节点

![image.png](/static/img/8808e66ff0f3ee9ae64592a37326506c.image.webp)

# 红黑树的插入
红黑树的插入分为两步
1. 按照二叉搜索树的方式插入
2. 根据染色规则调整树的结构并重新染色

插入的节点会成为叶子，由于需要保持黑高度，将其设为红色。不过这样可能会导致违规，即红色节点不能有红色的儿子。可以分为三种情况递归地调整颜色

**0. 若该节点的父亲为黑色**

这很好，不需要做调整

**1. 父亲为红色，并且父亲是爷爷的左儿子，而且父亲的兄弟也是红的**
   
这种情况可以如图处理
   
![image.png](/static/img/93cdf67ea28cad1e59c0c3e3d8cb65cd.image.webp)
   
将爷爷设置为红色，再将父亲和父亲的兄弟设置为黑色即可。然后递归处理爷爷即可
   
**2. 父亲为红色，并且父亲是爷爷的左儿子，不过父亲的兄弟是黑的，同时自己是父亲的右儿子**


![image.png](/static/img/0e7a6da194b3b0f3b062e4e159f90651.image.webp)

对父亲执行左旋操作，再递归处理即可

**3. 父亲为红色，并且父亲是爷爷的左儿子，不过父亲的兄弟是黑的，同时自己是父亲的左儿子**

![image.png](/static/img/23d5f0018c5711e9be2a33ae2b473cd7.image.webp)

将父亲设为黑色，将爷爷设置为红色，再递归处理爷爷即可

---
对于父亲是爷爷右儿子的情况，操作是相同的，只是需要将左旋操作改为右旋即可

这就是所有可能出现的情况，这些操作都保持每个节点的黑高度不变，每次操作使得违规节点上升一层，那么调整的时间复杂度为$O(\log N)$

# 红黑树的删除
由于朴素的二叉搜索树执行删除操作时是先替换再删除，即若删除某个非叶子节点
1. 将该节点的值与左子树的最大值或是右子树的最小值交换一下（只换值不换颜色！），注意它们不一定是叶子节点
2. 删除交换后的节点

若默认要删除的节点是它父亲的左儿子，可以分为三种情况

**1. 要删除的节点是叶子节点**

删除一个红色的叶子不需要做任何额外的操作，删除一个黑色的叶子就不一样了。为了保持黑高度，需要假定删除后会在原位留下一个**双重黑**的`NULL`节点，意为该路径上黑高度+1

**2. 要删除的节点仅有一个儿子**

删除仅有一个儿子的红节点只需要用它的儿子替换它即可，不需要额外操作。

不过如果它是黑的，由于一棵子树是空的，那么非空的子树高度必定为1，意味着它的儿子只能是一个红色的叶子。此时将它替换为儿子后为了保持黑高度，儿子应当变黑。为了方便操作，记它是**红黑的**，代表它是红的但应当变黑

**3. 要删除的节点有两个儿子**

按照惯例此时应当在右子树寻找最小的节点，该节点必定不存在左儿子（因为没有比它更小的了）。将它的值与待删除的节点交换后即转化为`情形二`

---
那么要解决的就是双重黑和红黑的节点，需要将它变为单重黑或者单纯的红色。无论是双重黑还是红黑，本质上都是对一个节点**加了一层黑**，实现该操作即可

**0. 它是红的**

将它变黑即可。由于将一个红节点变黑并不会违背红黑树的性质，因而此时的红黑树已经合规，结束

**1. 它是黑的，但它的兄弟是红的**

这意味着它的父亲一定是黑的，可以如图操作


![image.png](/static/img/a70041d3a1540e737c2a2e52db9b07ca.image.webp)

这样操作后可以保证`a`，`b`子树和双重黑子树的黑高度不变，同时将双重黑节点的父亲变为了红色

**2. 它是黑的，它的兄弟也是黑的，并且兄弟的两个儿子也是黑的**

既然它和兄弟都是黑的，它们俩都脱去一层黑，并对父亲加黑即可。即将一层黑色送给了父亲

![image.png](/static/img/c0818d0d1ebd33b61932308047cc6614.image.webp)

**3. 它是黑的，它的兄弟是黑的，但是兄弟的左儿子是红的，右儿子是黑的**

那么将兄弟和它的左儿子交换颜色，然后对兄弟节点执行右旋操作

![image.png](/static/img/69acfb5fe5aaca28bcd28a583412726d.image.webp)

这样就变为右儿子是红色的情况

**4. 它是黑的，它的兄弟是黑的，但是兄弟的右儿子是红的，左儿子不知道是什么颜色**

兄弟的颜色与父亲的颜色互换，再对父亲执行左旋操作

![image.png](/static/img/a308ff8ed0a645229f9c6e149f2737dc.image.webp)

这样它的黑高度变为了父亲+2，其余节点的黑高度均维持不变。同时父亲的颜色不变，因而现在已经合规，不需要再调整，结束即可

---

上面是对于左儿子的加黑操作，对于右儿子的加黑操作对称即可

# 简单C++红黑树类实现

~~为了算法课的作业~~ 可以简单地实现一个红黑树`rbtree.h`，简单起见就用指针实现了，如果放在OI中应该用数组实现码量会小一些 ~~不过正经人谁在OI里写红黑树啊~~

都用C++了，不写成类怎么体现出C艹的优雅，就酱吧。不过老师要求输出中序遍历，还是加上了`string.h`的头文件，有点可惜
```cpp
#include <string>
class rbtree
{
private:
    // 红黑树的节点类
    class node
    {
    public:
        int data;
        node *left;
        node *right;
        node *parent;
        int color; // 0为黑色，1为红色

        node(int data)
        {
            this->data = data;
            left = right = parent = NULL;
            color = 1; // 新插入节点默认为红色
        }
    };
    node *root;

    // 左旋
    void rotateLeft(node *&root, node *&pt)
    {
        node *pt_right = pt->right;
        pt->right = pt_right->left;

        if (pt->right != NULL)
            pt->right->parent = pt;

        pt_right->parent = pt->parent;

        if (pt->parent == NULL)
            root = pt_right;
        else if (pt == pt->parent->left)
            pt->parent->left = pt_right;
        else
            pt->parent->right = pt_right;

        pt_right->left = pt;
        pt->parent = pt_right;
    }
    // 右旋
    void rotateRight(node *&root, node *&pt)
    {
        node *pt_left = pt->left;
        pt->left = pt_left->right;

        if (pt->left != NULL)
            pt->left->parent = pt;

        pt_left->parent = pt->parent;

        if (pt->parent == NULL)
            root = pt_left;
        else if (pt == pt->parent->left)
            pt->parent->left = pt_left;
        else
            pt->parent->right = pt_left;

        pt_left->right = pt;
        pt->parent = pt_left;
    }
    // 修正红黑树性质
    void fixViolation(node *&root, node *&pt)
    {
        node *parent_pt = NULL;
        node *grand_parent_pt = NULL;

        while ((pt != root) && (pt->color == 1) &&
               (pt->parent->color == 1))
        {
            parent_pt = pt->parent;
            grand_parent_pt = parent_pt->parent;

            /* 情况A: 父节点是祖父节点的左孩子 */
            if (parent_pt == grand_parent_pt->left)
            {
                node *uncle_pt = grand_parent_pt->right;

                /* 情况1:
                   叔叔节点是红色，只需要重新上色和向上合并 */
                if (uncle_pt != NULL && uncle_pt->color == 1)
                {
                    grand_parent_pt->color = 1;
                    parent_pt->color = 0;
                    uncle_pt->color = 0;
                    pt = grand_parent_pt;
                }

                else
                {
                    /* 情况2:
                       pt是父节点的右孩子，先左旋转父节点 */
                    if (pt == parent_pt->right)
                    {
                        rotateLeft(root, parent_pt);
                        pt = parent_pt;
                        parent_pt = pt->parent;
                    }

                    /* 情况3:
                       pt是父节点的左孩子，对祖父节点右旋并调整颜色 */
                    rotateRight(root, grand_parent_pt);
                    int t = parent_pt->color;
                    parent_pt->color = grand_parent_pt->color;
                    grand_parent_pt->color = t;
                    pt = parent_pt;
                }
            }

            /* 情况B: 父节点是祖父节点的右孩子 */
            else
            {
                node *uncle_pt = grand_parent_pt->left;

                /* 情况1:
                   叔叔节点是红色 */
                if ((uncle_pt != NULL) && (uncle_pt->color == 1))
                {
                    grand_parent_pt->color = 1;
                    parent_pt->color = 0;
                    uncle_pt->color = 0;
                    pt = grand_parent_pt;
                }
                else
                {
                    /* 情况2:
                       pt是父节点的左孩子，先右旋父节点 */
                    if (pt == parent_pt->left)
                    {
                        rotateRight(root, parent_pt);
                        pt = parent_pt;
                        parent_pt = pt->parent;
                    }

                    /* 情况3:
                       pt是父节点的右孩子，对祖父节点左旋并调整颜色 */
                    rotateLeft(root, grand_parent_pt);
                    int t = parent_pt->color;
                    parent_pt->color = grand_parent_pt->color;
                    grand_parent_pt->color = t;
                    pt = parent_pt;
                }
            }
        }

        root->color = 0;
    }

    // 删除整棵树
    void deleteTree(node *root)
    {
        if (root == NULL)
            return;
        deleteTree(root->left);
        deleteTree(root->right);
        delete root;
    }

    // 寻找最小值节点（用于找后继）
    node *minimum(node *x)
    {
        while (x->left != NULL)
            x = x->left;
        return x;
    }

    // 用v子树替换u子树
    void rbTransplant(node *&root, node *u, node *v)
    {
        if (u->parent == NULL)
            root = v;
        else if (u == u->parent->left)
            u->parent->left = v;
        else
            u->parent->right = v;
        if (v != NULL)
            v->parent = u->parent;
    }

    // 删除修正函数
    void fixDelete(node *&root, node *x)
    {
        while (x != root && (x == NULL || x->color == 0))
        {
            if (x == x->parent->left)
            {
                node *w = x->parent->right;
                if (w != NULL && w->color == 1)
                {
                    w->color = 0;
                    x->parent->color = 1;
                    rotateLeft(root, x->parent);
                    w = x->parent->right;
                }
                if ((w->left == NULL || w->left->color == 0) &&
                    (w->right == NULL || w->right->color == 0))
                {
                    w->color = 1;
                    x = x->parent;
                }
                else
                {
                    if (w->right == NULL || w->right->color == 0)
                    {
                        if (w->left != NULL)
                            w->left->color = 0;
                        w->color = 1;
                        rotateRight(root, w);
                        w = x->parent->right;
                    }
                    w->color = x->parent->color;
                    x->parent->color = 0;
                    if (w->right != NULL)
                        w->right->color = 0;
                    rotateLeft(root, x->parent);
                    x = root;
                }
            }
            else
            {
                node *w = x->parent->left;
                if (w != NULL && w->color == 1)
                {
                    w->color = 0;
                    x->parent->color = 1;
                    rotateRight(root, x->parent);
                    w = x->parent->left;
                }
                if ((w->right == NULL || w->right->color == 0) &&
                    (w->left == NULL || w->left->color == 0))
                {
                    w->color = 1;
                    x = x->parent;
                }
                else
                {
                    if (w->left == NULL || w->left->color == 0)
                    {
                        if (w->right != NULL)
                            w->right->color = 0;
                        w->color = 1;
                        rotateLeft(root, w);
                        w = x->parent->left;
                    }
                    w->color = x->parent->color;
                    x->parent->color = 0;
                    if (w->left != NULL)
                        w->left->color = 0;
                    rotateRight(root, x->parent);
                    x = root;
                }
            }
        }
        if (x != NULL)
            x->color = 0;
    }

    // 寻找键值为key的节点
    node *searchNode(node *root, int key)
    {
        if (root == NULL || root->data == key)
            return root;
        if (key < root->data)
            return searchNode(root->left, key);
        return searchNode(root->right, key);
    }

public:
    rbtree()
    {
        root = NULL;
    }

    ~rbtree()
    {
        deleteTree(root);
    }

    // 插入键为data的节点
    void insert(const int &data)
    {
        node *pt = new node(data);

        // 普通的二叉搜索树插入
        if (root == NULL)
        {
            root = pt;
            root->color = 0; // 根节点为黑色
            return;
        }
        else
        {
            node *parent = NULL;
            node *current = root;

            while (current != NULL)
            {
                parent = current;
                if (pt->data < current->data)
                    current = current->left;
                else
                    current = current->right;
            }

            pt->parent = parent;
            if (pt->data < parent->data)
                parent->left = pt;
            else
                parent->right = pt;
        }

        // 修正红黑树性质
        fixViolation(root, pt);
    }

    // 删除键为key的节点
    void deleteKey(int key)
    {
        node *z = searchNode(root, key);
        if (z == NULL)
            return; // 未找到要删除的节点，直接返回

        node *y = z;
        node *x = NULL;
        int y_original_color = y->color;

        // 若被删节点z只有一个子节点或无子节点
        if (z->left == NULL)
        {
            x = z->right;
            rbTransplant(root, z, z->right);
        }
        else if (z->right == NULL)
        {
            x = z->left;
            rbTransplant(root, z, z->left);
        }
        else
        {
            // 若被删节点有两个子节点，则用后继替换
            y = minimum(z->right);
            y_original_color = y->color;
            x = y->right;
            if (y->parent == z)
            {
                if (x != NULL)
                    x->parent = y;
            }
            else
            {
                rbTransplant(root, y, y->right);
                y->right = z->right;
                if (y->right != NULL)
                    y->right->parent = y;
            }
            rbTransplant(root, z, y);
            y->left = z->left;
            y->left->parent = y;
            y->color = z->color;
        }

        delete z;

        // 如果被删除的颜色是黑色，需要修正
        if (y_original_color == 0 && x != NULL)
            fixDelete(root, x);
    }

    // 返回以root为根的中序遍历
    std::string inorder(node *root)
    {
        if (root == NULL)
            return std::string("");
        std::string instr = inorder(root->left);
        instr += std::to_string(root->data) + "(" + (root->color == 0 ? "B" : "R") + ") ";
        instr += inorder(root->right);
        return instr;
    }

    // 中序遍历
    std::string inorder()
    {
        return inorder(root);
    }
};

```

红黑树

量子力学中经常需要求解矩阵部分迹的操作，而Mathematica并没有提供求迹的函数



```wolfram
PartialTrace[ρ_, dims_List, tracedSys_List] := Module[
  {reshaped, contracted, finalDims, totalDim, reshapedResult},

  (* 将密度矩阵重塑为张量形式，维度为 dims *)
  reshaped = ArrayReshape[ρ, Join[dims, dims]];

  (* 对指定的子系统执行部分迹操作 *)
  contracted = TensorContract[
    reshaped,
    Thread[{tracedSys, tracedSys + Length[dims]}]
  ];

  (* 计算部分迹后的最终矩阵维度 *)
  finalDims = Delete[dims, List /@ tracedSys];

  (* 计算剩余系统的总维度 *)
  totalDim = Times @@ finalDims;

  (* 将结果重塑为矩阵形式 *)
  reshapedResult = ArrayReshape[contracted, {totalDim, totalDim}];

  reshapedResult
]

```
使用示例如下
```wolfram
PartialTrace[\[Rho], {2, 2, 2}, {3}]
```
表示将$8\times8$矩阵$\rho$视为三个$2\times2$矩阵的直积，并对第三个矩阵求部分迹

Mathmatica求解矩阵部分迹

格雷码是一种二进制编码, 相邻数的格雷码只有一个二进制位不同

一位的格雷码是显然的

| 二进制 | 格雷码 |
| --- | --- |
| 0 | 0 |
| 1 | 1|

若是再添一位, 再前方补上`0`

| 二进制 | 格雷码 |
| --- | --- |
| 00 | 00 |
| 01 | 01|

对于高位为`1`的情形, 由于要求相邻数仅有一个二进制位变化,在交界处低位应当相同. 因而将已有的编码镜像
| 二进制 | 格雷码 |
| --- | --- |
| 00 | 00 |
| 01 | 01|
| 10 | 11 |
| 11 | 10|

依次类推, 三位格雷码的对应关系就是
| 二进制 | 格雷码 |
| --- | --- |
| 000 | 000 |
| 001 | 001|
| 010 | 011 |
| 011 | 010|
| 100 | 110 |
| 101 | 111|
| 110 | 101 |
| 111 | 100|

格雷码

# pybind11安装
pybind11安装很简单，只需要
```shell
pip install pybind11
```
# 库的编写
编写一个简单的加法函数`myadd.cpp`
```cpp
#include <pybind11/pybind11.h>

// 一个简单的 C++ 函数
int add(int i, int j)
{
    return i + j;
}

// PYBIND11_MODULE 宏用于定义 Python 模块
PYBIND11_MODULE(myadd, m) // 这里将模块名称改为 'myadd'
{
    m.def("add", &add, "A function that adds two numbers");
}
```
编辑器会在第一行报错，因为它找不到这个文件。此时就要在编辑器的`Include Path`中加上
```
C:\Users\gbwat\AppData\Local\Programs\Python\Python311\Include
C:\Users\gbwat\AppData\Local\Programs\Python\Python311\Lib\site-packages\pybind11\include
C:\Users\gbwat\AppData\Local\Programs\Python\Python311\libs
```
这样就不会报错了。此处需要根据自己的python版本和安装位置进行修改
# CMake编译配置
## cmakelists
使用CMake编译是非常方便的，我使用的`CMakelists.txt`如下
```cmake
cmake_minimum_required(VERSION 3.12)
project(myadd)

# 设置 pybind11 的目录路径
set(pybind11_DIR "C:/Users/gbwat/AppData/Local/Programs/Python/Python311/Lib/site-packages/pybind11/share/cmake/pybind11")

# 寻找 pybind11 包
find_package(pybind11 REQUIRED)

# 设置静态链接
set(BUILD_SHARED_LIBS OFF)

# 添加 C++ 模块
pybind11_add_module(myadd myadd.cpp) # 模块名称 'myadd'

# 设置输出目录
set_target_properties(myadd PROPERTIES 
    LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)

# 针对 Windows 平台的额外设置
if (WIN32)
    target_compile_definitions(myadd PRIVATE NOMINMAX)
    target_link_libraries(myadd PRIVATE ${PYTHON_LIBRARIES})

    # 针对 MinGW 添加静态链接选项
    if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
        target_link_options(myadd PRIVATE -static-libgcc -static-libstdc++)
    endif()
endif()

if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
    target_compile_options(myadd PRIVATE -Wall -Wextra -Wpedantic)
elseif (MSVC)
    target_compile_options(myadd PRIVATE /W4 /permissive-)
endif()

message(STATUS "Using C++ compiler: ${CMAKE_CXX_COMPILER}")
message(STATUS "Using Python include directories: ${PYTHON_INCLUDE_DIRS}")
message(STATUS "Output library will be placed in: ${CMAKE_CURRENT_SOURCE_DIR}")
```
注意一定要设置静态链接，否则在python中调用会找不到dll从而出错！！！
## vscode编译
在vscode中安装`CMAKE`扩展后直接点击生成即可

![image.png](/static/img/cdfc7ae7941528238ecb3309201492b9.image.webp)

生成完毕即可在当前目录下找到编译出的文件`myadd.cp311-win_amd64.pyd`

## 终端编译
我使用的是`MinGW`编译器，不同的编译器需要使用不同的命令

在当前目录建立一个新文件夹build，在终端中进入文件夹
```ahell
cd build
```
随后执行`cmake`命令进行配置
```shell
cmake -G "MinGW Makefiles" .. 
```
随后执行编译
```
mingw32-make
```
就可以在上级目录（build文件夹的上级目录）看见编译出的`myadd.cp311-win_amd64.pyd`

# python调用
确保python脚本与`myadd.cp311-win_amd64.pyd`处于同一目录中，随后直接`import`就可以了。一个实例如下
```python
import myadd

print(myadd.add(1, 2))
```
运行之，会输出结果`3`

# 可能的错误及解决办法
## 测试成功但是编译不成功
该情况下CMake会输出
```
[main] 正在生成文件夹: d:/py/build 
[build] 正在启动生成
[proc] 执行命令: "C:\Program Files\CMake\bin\cmake.EXE" --build d:/py/build --config Debug --target all -j 24 --
[build] [ 50%] Linking CXX shared module myadd.cp311-win_amd64.pyd
[build] Copying runtime dependencies
[build] Error copying file "/python312.dll" to "D:/py/build".
[build] mingw32-make[2]: *** [CMakeFiles\myadd.dir\build.make:104: myadd.cp311-win_amd64.pyd] Error 1
[build] mingw32-make[2]: *** Deleting file 'myadd.cp311-win_amd64.pyd'
[build] mingw32-make[1]: *** [CMakeFiles\Makefile2:82: CMakeFiles/myadd.dir/all] Error 2
[build] mingw32-make: *** [Makefile:90: all] Error 2
[proc] 命令“"C:\Program Files\CMake\bin\cmake.EXE" --build d:/py/build --config Debug --target all -j 24 --”已退出，代码为 2
[driver] 生成完毕: 00:00:01.309
[build] 生成已完成，退出代码为 2
[rollbar] 未处理的异常: 未处理的拒绝承诺: ctest Error: 生成失败。 {}
```
这是因为`gcc`版本太低，经测试`gcc 8.1`不能成功编译但是`gcc 14`可以
## 编译成功python调用提示‘找不到指定的模块’
这种情况下python会报错
```
PS D:\py> python .\test.py 
Traceback (most recent call last):
  File "D:\py\test.py", line 1, in <module>
    import myadd
ImportError: DLL load failed while importing myadd: 找不到指定的模块。
```
这是因为找不到dll。用`Process Monitor`查看调用情况如下

![image.png](/static/img/7b1fa57e197abd62dee52eeb9a20c4e5.image.webp)

可见是c++库的dll找不到。这是因为编译器的lib没有加入`PATH`。好的做法是使用静态链接，就像前面说的那样