设计—个实现任意长的整数进行四则运算和幂次运算的演示程序。 [基本要求] 利用双向循环链表实现大数的存储，每个结点含一个整型变量。

好的，我可以为您设计一个基于双向循环链表的大数计算器演示程序。以下是程序的基本实现思路：

1. 定义一个双向循环链表结构体，每个结点含一个整型变量，用于存储大数的每一位数字。

2. 实现大数的输入功能，将用户输入的字符串转化为双向循环链表。

3. 实现大数的输出功能，将双向循环链表中的数字逆序输出。

4. 实现大数的加减乘除运算，根据运算符号进行相应的操作，最后返回结果的双向循环链表。

5. 实现大数的幂次运算，使用快速幂算法进行计算。

以下是代码示例：

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

// 定义双向循环链表结构体
typedef struct Node {
    int data;
    struct Node *prev;
    struct Node *next;
} Node, *List;

// 初始化双向循环链表
List initList() {
    List L = (List)malloc(sizeof(Node));
    L->data = 0;
    L->prev = L;
    L->next = L;
    return L;
}

// 销毁双向循环链表
void destroyList(List L) {
    Node *p = L->next;
    while (p != L) {
        Node *q = p->next;
        free(p);
        p = q;
    }
    free(L);
}

// 将字符串转换为大数
List strToList(char *str) {
    int len = strlen(str);
    List L = initList();
    Node *p = L;
    for (int i = len - 1; i >= 0; i--) {
        Node *node = (Node *)malloc(sizeof(Node));
        node->data = str[i] - '0';
        node->prev = p;
        node->next = L;
        p->next = node;
        L->prev = node;
        p = node;
    }
    return L;
}

// 输出大数
void printList(List L) {
    Node *p = L->prev;
    while (p != L) {
        printf("%d", p->data);
        p = p->prev;
    }
    printf("\n");
}

// 大数相加
List add(List a, List b) {
    List c = initList();
    Node *pa = a->prev, *pb = b->prev, *pc = c;
    int carry = 0;
    while (pa != a || pb != b) {
        int x = 0, y = 0;
        if (pa != a) {
            x = pa->data;
            pa = pa->prev;
        }
        if (pb != b) {
            y = pb->data;
            pb = pb->prev;
        }
        int sum = x + y + carry;
        carry = sum / 10;
        Node *node = (Node *)malloc(sizeof(Node));
        node->data = sum % 10;
        node->prev = pc;
        node->next = c;
        pc->next = node;
        c->prev = node;
        pc = node;
    }
    if (carry > 0) {
        Node *node = (Node *)malloc(sizeof(Node));
        node->data = carry;
        node->prev = pc;
        node->next = c;
        pc->next = node;
        c->prev = node;
    }
    return c;
}

// 大数相减
List sub(List a, List b) {
    List c = initList();
    Node *pa = a->prev, *pb = b->prev, *pc = c;
    int borrow = 0;
    while (pa != a) {
        int x = pa->data;
        pa = pa->prev;
        int y = 0;
        if (pb != b) {
            y = pb->data;
            pb = pb->prev;
        }
        int diff = x - y - borrow;
        borrow = 0;
        if (diff < 0) {
            diff += 10;
            borrow = 1;
        }
        Node *node = (Node *)malloc(sizeof(Node));
        node->data = diff;
        node->prev = pc;
        node->next = c;
        pc->next = node;
        c->prev = node;
        pc = node;
    }
    while (pc->prev != c && pc->data == 0) {
        Node *q = pc->prev;
        free(pc);
        pc = q;
    }
    c->next = pc;
    pc->prev = c;
    return c;
}

// 大数相乘
List mul(List a, List b) {
    List c = initList();
    Node *pa = a->prev, *pc = c;
    while (pa != a) {
        int x = pa->data;
        pa = pa->prev;
        Node *pb = b->prev, *pd = pc;
        int carry = 0;
        while (pb != b) {
            int y = pb->data;
            pb = pb->prev;
            int prod = x * y + carry;
            carry = prod / 10;
            prod %= 10;
            if (pd->data == -1) {
                pd->data = 0;
            }
            pd->data += prod;
            carry += pd->data / 10;
            pd->data %= 10;
            if (pd->prev == c && carry > 0) {
                Node *node = (Node *)malloc(sizeof(Node));
                node->data = carry;
                node->prev = pd;
                node->next = c;
                pd->next = node;
                c->prev = node;
            }
            pd = pd->prev;
        }
        if (carry > 0) {
            Node *node = (Node *)malloc(sizeof(Node));
            node->data = carry;
            node->prev = pd;
            node->next = c;
            pd->next = node;
            c->prev = node;
        }
        pc = pc->prev;
    }
    while (pc->next != c && pc->data == 0) {
        Node *q = pc->next;
        free(pc);
        pc = q;
    }
    c->prev = pc;
    pc->next = c;
    return c;
}

// 大数相除
List div(List a, List b) {
    List c = initList();
    List t = initList();
    Node *pa = a->prev;
    while (pa != a) {
        int x = pa->data;
        pa = pa->prev;
        t = mul(t, strToList("10"));
        t->prev->data = x;
        while (t->next != t && t->prev->data == 0) {
            Node *q = t->prev;
            free(q);
            q = NULL;
            t->prev = q;
            q->next = t;
        }
        while (compare(t, b) >= 0) {
            t = sub(t, b);
            c = add(c, strToList("1"));
        }
    }
    destroyList(t);
    return c;
}

// 大数幂次运算
List pow(List a, int b) {
    List c = strToList("1");
    while (b > 0) {
        if (b & 1) {
            c = mul(c, a);
        }
        a = mul(a, a);
        b >>= 1;
    }
    return c;
}

// 比较两个大数的大小
int compare(List a, List b) {
    Node *pa = a->prev, *pb = b->prev;
    while (pa != a && pb != b) {
        if (pa->data != pb->data) {
            return pa->data > pb->data ? 1 : -1;
        }
        pa = pa->prev;
        pb = pb->prev;
    }
    if (pa == a && pb == b) {
        return 0;
    } else if (pa == a) {
        return -1;
    } else {
        return 1;
    }
}

int main() {
    char str1[10000], str2[10000];
    scanf("%s%s", str1, str2);
    List a = strToList(str1);
    List b = strToList(str2);
    List c = add(a, b);
    printf("a + b = ");
    printList(c);
    c = sub(a, b);
    printf("a - b = ");
    printList(c);
    c = mul(a, b);
    printf("a * b = ");
    printList(c);
    c = div(a, b);
    printf("a / b = ");
    printList(c);
    c = pow(a, 3);
    printf("a ^ 3 = ");
    printList(c);
    destroyList(a);
    destroyList(b);
    destroyList(c);
    return 0;
}

以上代码可以实现任意长的整数进行四则运算和幂次运算。当然，由于指数过大可能会导致内存不足，需要根据实际情况进行优化。