用c++编写一个完整的程序. Q1实现基于块链式存储的串 . Q2实现基于块链式串的赋值、复制、插入、删除等基本操作。 Q3 实现基于块链式串的Strindex字串匹配函数与StrReplace替换函数

在C++中，我们可以创建一个简单的块链式存储字符串的数据结构来实现Q1、Q2和Q3的需求。这里我会给出一个基础的概念框架，具体的实现细节需要结合实际编程环境和一些库文件，如iostream用于输入输出。

首先，我们创建一个Block链表节点，包含字符数据和指向下一个节点的指针：

class Block {
public:
    char data;
    Block* next;

    // 构造函数
    Block(char ch) : data(ch), next(nullptr) {}
};

接下来，我们创建一个BlockChain类，用于管理字符串的存储和操作：

class BlockChain {
private:
    Block* head;

public:
    BlockChain() : head(nullptr) {}

    // 添加新字符到链表尾部
    void addChar(char ch) {
        if (!head) {
            head = new Block(ch);
        } else {
            Block* current = head;
            while (current->next) {
                current = current->next;
            }
            current->next = new Block(ch);
        }
    }

    // 删除指定位置的字符
    void deleteChar(int index) {
        if (index < 0 || index >= length()) return;
        Block* current = head;
        for (int i = 0; i < index; ++i) {
            current = current->next;
        }
        Block* temp = current->next;
        current->next = temp->next;
        delete temp;
    }

    // 插入字符到指定位置
    void insertChar(int index, char ch) {
        if (index < 0 || index > length()) return;
        Block* newNode = new Block(ch);
        Block* current = head;
        for (int i = 0; i < index; ++i) {
            newNode->next = current->next;
            current = current->next;
        }
        newNode->next = current;
        current = newNode;
        if (index == 0) {
            head = newNode;
        }
    }

    // 字符串查找
    int strIndex(const std::string& pattern) {
        int index = 0;
        Block* search = head;
        for (const char c : pattern) {
            while (search && search->data != c) {
                search = search->next;
            }
            if (!search) break;
            search = search->next;
            index++;
        }
        return index;
    }

    // 字符串替换
    void strReplace(const std::string& oldPattern, const std::string& newPattern) {
        int currentIndex = 0;
        Block* search = head;
        while (search) {
            size_t found = search->data == oldPattern[currentIndex] ? findPattern(oldPattern, currentIndex) : -1;
            if (found != -1) {
                for (size_t i = found; i < found + oldPattern.length(); ++i) {
                    search->data = newPattern[i];
                }
                currentIndex = 0;
            } else {
                currentIndex++;
                search = search->next;
            }
        }
    }

private:
    int length() {
        int count = 0;
        Block* current = head;
        while (current) {
            count++;
            current = current->next;
        }
        return count;
    }

    // 在给定的block链表中查找pattern的下标
    size_t findPattern(const std::string& pattern, size_t start) {
        Block* search = head;
        for (size_t i = start; i < pattern.length(); ++i) {
            if (search->data == pattern[i]) {
                search = search-1;
            }
        }
        return i;
    }
};

// 主函数示例
int main() {
    BlockChain chain;
    // 使用addChar添加字符，然后进行其他操作...
    return 0;
}

这个例子仅提供了一个基础的框架，实际应用中可能需要考虑错误处理和内存管理。