Question

所以，我正在尝试在c＃中编写一个新的链表，它将在不安全的上下文中正常运行，因此我可以将其传递给多线程进程。不幸的是，即使我需要的是一个恒定大小的指针，这也是一个循环依赖。我宁愿不把它变成一个类，我也不确定它在不安全的环境中会如何表现。我也不认为接口解决方案可以在我的情况下工作，因为它实际上是指向自身的指针。此外，当我尝试编写它时，它会抱怨一些代码正在被管理......我该如何解决？以下是代码段：

from math import log,ceil
import error

def bisection2(f,x1,x2,switch=0,tol=1.0e-9):
        f1 = f(x1)
        if f1 == 0.0: return x1
        f2 = f(x2)
        if f2 == 0.0: return x2
        if f1*f2 > 0.0: error.err('Root is not bracketed')
        n = ceil(log(abs(x2 - x1)/epsilon)/log(2.0))
        for i in range(n):
            x3 = 0.5*(x1 + x2); f3 = f(x3)
            if (switch == 1) and (abs(f3) > abs(f1)) \
                                         (abs(f3) > abs(f2)):
                return None
            if f3 == 0.0:return x3
            if f2*f3 < 0.0:
                x1 = x3; f1 = f3
            else:
                x2 = x3; f2 = f3
        return (x1 + x2)/2.0

Answer 1

这解决了循环依赖和代码管理问题。最后在3天后解决，然后在发布后的几分钟内解决。不幸的是，由于某些原因，仍然存在尝试获取节点地址的问题，但这是 THIS 问题的解决方案：

struct UnsafeLinkedListNode
{
    public EncodedData value;
    unsafe public UnsafeLinkedListNode* next;
    unsafe public UnsafeLinkedListNode* prev;
}

class UnsafeLinkedList
{

    unsafe public UnsafeLinkedListNode *head = null;
    unsafe public UnsafeLinkedListNode *tail = null;
    public ulong count { get; private set; }
    unsafe public void AddAfter(EncodedData value)
    {
        UnsafeLinkedListNode temp = new UnsafeLinkedListNode();
        temp.value = value;
        AddAfter(&temp);
    }
    unsafe public void AddAfter(UnsafeLinkedListNode* value)
    {
        unsafe
        {
            if(head !=null)
            {
                value->prev = tail;
                value->next = null;
                tail->next = value;
                count++;

            }
            else
            {
                value->next = null;
                value->prev = null;
                head = value;
                tail = value;
                count++;
            }
        }
    }
}

c＃node struct自定义LinkedListNode结构中的循环依赖

1 个答案: