如何用C语言设计并实现一个支持块链数据结构的字符串类，包括高效完成赋值、复制、插入和删除等基础操作的功能？

在C语言中，设计一个支持区块链数据结构的字符串类可以结合链表的概念，因为每个节点可以包含字符和指向下一个节点的指针。这里给出一个简化的实现框架：

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    char data;          // 存储字符
    struct Node* next;   // 指向下一个节点
} Block;

typedef struct Blockchain {
    Block* head;
} Blockchain;

// 初始化一个空的区块链
Blockchain* create_blockchain() {
    Blockchain* chain = (Blockchain*)malloc(sizeof(Blockchain));
    chain->head = NULL;
    return chain;
}

// 添加一个新的字符到链表末尾
void add_char(Blockchain* chain, char c) {
    Block* newNode = (Block*)malloc(sizeof(Block));
    newNode->data = c;
    newNode->next = NULL;

    if (chain->head == NULL) {
        chain->head = newNode;
    } else {
        Block* current = chain->head;
        while (current->next != NULL) {
            current = current->next;
        }
        current->next = newNode;
    }
}

// 将另一个字符串添加到当前区块链的末尾
void append_string(Blockchain* chain, const char* str) {
    for (int i = 0; str[i] != '\0'; ++i) {
        add_char(chain, str[i]);
    }
}

// 复制当前区块链到一个新的区块链
Blockchain* copy_blockchain(const Blockchain* source) {
    Blockchain* dest = create_blockchain();
    Block* src = source->head;
    while (src != NULL) {
        add_char(dest, src->data);
        src = src->next;
    }
    return dest;
}

// 删除指定位置的字符，返回删除后的字符串
char* delete_char_at(Blockchain* chain, int index) {
    if (index < 0 || index >= get_length(chain)) {
        printf("Invalid index.\n");
        return NULL;
    }

    char* result = (char*)malloc(sizeof(char) * get_length(chain) - 1); // 假设链长
    Block* prev = NULL, *curr = chain->head;
    int newLength = 0;

    for (int i = 0; curr != NULL && i < index; ++i, ++newLength) {
        result[newLength] = curr->data;
        prev = curr;
        curr = curr->next;
    }

    if (curr != NULL) { // 如果还有剩余元素
        prev->next = curr->next;
    }

    result[newLength] = '\0';
    free(result + index + 1); // 释放原链表上多余的空间

    return result;
}

// 获取区块链的长度
int get_length(const Blockchain* chain) {
    int length = 0;
    Block* curr = chain->head;
    while (curr != NULL) {
        length++;
        curr = curr->next;
    }
    return length;
}