B+树如何构造100条数据然后读书内存，把地址加到B+树的叶子节点中去，具体实现代码

以下是一个简单的C++实现示例代码：

#include <iostream>
#include <vector>

using namespace std;

const int ORDER = 5; // 定义B+树的阶数

struct BPlusTreeNode {
    vector<int> keys; // 存储节点的键值
    vector<void*> pointers; // 存储指向子节点或数据的指针
    BPlusTreeNode* parent; // 指向父节点的指针
    bool is_leaf; // 是否为叶子节点
};

class BPlusTree {
public:
    BPlusTree() {
        root = nullptr;
    }

    void insert(int key, void* pointer) {
        if (root == nullptr) { // 如果根节点为空，则创建一个新的根节点
            root = new BPlusTreeNode();
            root->is_leaf = true;
            root->keys.push_back(key);
            root->pointers.push_back(pointer);
        } else {
            BPlusTreeNode* node = find_leaf_node(key); // 找到要插入的叶子节点
            if (node->keys.size() < ORDER - 1) { // 如果叶子节点未满，则直接插入
                insert_in_leaf_node(node, key, pointer);
            } else { // 如果叶子节点已满，则需要进行分裂
                BPlusTreeNode* new_leaf_node = split_leaf_node(node, key, pointer); // 分裂叶子节点
                insert_in_parent(node, new_leaf_node->keys[0], new_leaf_node); // 将新节点插入到父节点中
            }
        }
    }

    void print_tree() {
        print_tree(root);
    }

private:
    BPlusTreeNode* root;

    BPlusTreeNode* find_leaf_node(int key) {
        BPlusTreeNode* node = root;
        while (!node->is_leaf) { // 从根节点开始查找直到找到叶子节点
            int i = 0;
            while (i < node->keys.size() && key > node->keys[i]) {
                i++;
            }
            node = (BPlusTreeNode*)node->pointers[i];
        }
        return node;
    }

    void insert_in_leaf_node(BPlusTreeNode* node, int key, void* pointer) {
        int i = 0;
        while (i < node->keys.size() && key > node->keys[i]) {
            i++;
        }
        node->keys.insert(node->keys.begin() + i, key);
        node->pointers.insert(node->pointers.begin() + i, pointer);
    }

    BPlusTreeNode* split_leaf_node(BPlusTreeNode* node, int key, void* pointer) {
        BPlusTreeNode* new_leaf_node = new BPlusTreeNode();
        new_leaf_node->is_leaf = true;
        int split_index = ORDER / 2;
        for (int i = split_index; i < ORDER - 1; i++) { // 将原节点后半部分的键值和指针移动到新节点中
            new_leaf_node->keys.push_back(node->keys[i]);
            new_leaf_node->pointers.push_back(node->pointers[i]);
        }
        new_leaf_node->pointers.push_back(node->pointers[ORDER - 1]); // 将原节点的最后一个指针复制到新节点中
        node->keys.erase(node->keys.begin() + split_index, node->keys.end()); // 删除原节点后半部分的键值和指针
        node->pointers.erase(node->pointers.begin() + split_index, node->pointers.end());
        insert_in_leaf_node((key < new_leaf_node->keys[0]) ? node : new_leaf_node, key, pointer); // 将新的键值和指针插入到对应的节点中
        new_leaf_node->parent = node->parent; // 设置新节点的父节点
        return new_leaf_node;
    }

    void insert_in_parent(BPlusTreeNode* node, int key, BPlusTreeNode* new_node) {
        if (node == root) { // 如果要插入的节点为根节点，则创建一个新的根节点
            root = new BPlusTreeNode();
            root->is_leaf = false;
            root->keys.push_back(key);
            root->pointers.push_back(node);
            root->pointers.push_back(new_node);
            node->parent = root;
            new_node->parent = root;
        } else {
            BPlusTreeNode* parent = node->parent;
            if (parent->keys.size() < ORDER - 1) { // 如果父节点未满，则直接插入
                int i = 0;
                while (i < parent->keys.size() && key > parent->keys[i]) {
                    i++;
                }
                parent->keys.insert(parent->keys.begin() + i, key);
                parent->pointers.insert(parent->pointers.begin() + i + 1, new_node);
                new_node->parent = parent;
            } else { // 如果父节点已满，则需要进行分裂
                BPlusTreeNode* new_parent = split_internal_node(parent, key, new_node); // 分裂父节点
                insert_in_parent(parent, new_parent->keys[0], new_parent); // 将新节点插入到父节点中
            }
        }
    }

    BPlusTreeNode* split_internal_node(BPlusTreeNode* node, int key, BPlusTreeNode* new_node) {
        BPlusTreeNode* new_internal_node = new BPlusTreeNode();
        new_internal_node->is_leaf = false;
        int split_index = ORDER / 2;
        for (int i = split_index + 1; i < ORDER; i++) { // 将原节点后半部分的键值和指针移动到新节点中
            new_internal_node->keys.push_back(node->keys[i]);
            new_internal_node->pointers.push_back(node->pointers[i]);
            ((BPlusTreeNode*)node->pointers[i])->parent = new_internal_node; // 更新子节点的父节点指针
        }
        new_internal_node->pointers.push_back(node->pointers[ORDER]); // 将原节点的最后一个指针复制到新节点中
        node->keys.erase(node->keys.begin() + split_index, node->keys.end()); // 删除原节点后半部分的键值和指针
        node->pointers.erase(node->pointers.begin() + split_index + 1, node->pointers.end());
        insert_in_parent(node, node->keys[split_index], new_internal_node); // 将新的键值和指针插入到父节点中
        new_internal_node->parent = node->parent; // 设置新节点的父节点
        return new_internal_node;
    }

    void print_tree(BPlusTreeNode* node) {
        if (node->is_leaf) { // 如果是叶子节点，则输出所有的键值和指针
            for (int i = 0; i < node->keys.size(); i++) {
                cout << "(" << node->keys[i] << ", " << node->pointers[i] << ") ";
            }
            cout << endl;
        } else { // 如果是内部节点，则递归输出所有子节点
            for (int i = 0; i < node->pointers.size(); i++) {
                print_tree((BPlusTreeNode*)node->pointers[i]);
            }
        }
    }
};

int main() {
    BPlusTree tree;
    for (int i = 0; i < 100; i++) {
        int key = i;
        void* pointer = (void*)&i;
        tree.insert(key, pointer);
    }
    tree.print_tree();
    return 0;
}

上述代码中，BPlusTreeNode表示B+树的节点结构体，包含了节点的键值、指针、父节点指针和是否为叶子节点的标志；BPlusTree表示B+树类，包含了插入操作和遍历操作。在插入操作中，使用find_leaf_node函数找到要插入的叶子节点，如果叶子节点未满，则直接将键值和指针插入到该节点中，否则需要进行分裂操作。在分裂操作中，将原节点后半部分的键值和指针移动到新节点中，并将新的键值和指针插入到对应的节点中。然后将新节点插入到父节点中，如果父节点已满，则需要进行类似的分裂操作。最后，使用print_tree函数遍历整个B+树并输出所有的键值和指针。