标签: cyclic-reference

这是Python的循环引用的示例.

>>> a = [1]
>>> b = [2]
>>> a.append(b)
>>> b.append(a)

在这之后,

>>> sys.getrefcount(a) = 3
>>> sys.getrefcount(b) = 3

为什么a和b有3引用计数？

对不起,伙计们我犯了一个错误.

真正的问题是不同的问题.

>>> GNU = ['is not Unix']
>>> GNU.insert(0, GNU)
>>> sys.getrefcount(GNU) = 4

为什么'GNU'的引用计数是4？

提前致谢 :)

目前，我有一个使用 Ant 构建的现有 Java 项目，我正在尝试将其设置为使用混合源（Java 和 Scala）进行构建。

我有一个 Java 接口定义为 -public interface One<T extends Two<? super T>>

当我从 Ant 构建运行 scalac 时，出现以下错误：

错误：涉及类型 T 的非法循环引用。

由于我希望 Scala 和 Java 类在我的项目中相互依赖，因此我首先运行 scalac 任务，然后在 Ant 构建中运行 javac。我的 scalac 块如下所示：

<scalac srcdir="${src.path}" destdir="${build.classes}" encoding="UTF-8" >\n        <classpath refid="compile.classpath" />\n        <include name="**/*.scala"/>\n        <include name="**/*.java"/>\n</scalac> \n

有什么办法解决这个问题吗？我无法修改 Java 代码，因为还有大量其他代码使用它。

我正在使用 Java 7 和 Scala 2.11.5

Here\xe2\x80\x99是我最后看到的：

com.arif.One.java

package com.arif.java;\npublic interface One<T extends One<? super …

我正在实现一个函数,它比较两个JavaScript对象的"深度"相等性.这个函数的骨架,现在看起来像这样:

function check_equal(actual, expected) {
    var stack = [];
    function check_equal_r(act, exp) {
        if (is_scalar(act) || is_scalar(exp)) {
            assert(act === exp);

        } else if (stack.indexOf(act) == -1) {
            assert(have_all_the_same_properties(act, exp));
            stack.push(act);
            for (var k of Object.getOwnPropertyNames(exp)) {
                check_equal_r(act[k], exp[k]);
            }
            stack.pop(act);

        } else {
            // ??? cyclic reference detected
        }
    }
    check_equal_r(act, exp);
}

问题是该说些什么// ??? cyclic reference detected.理想情况下,我希望能够说这些对象非常平等:

var a = {foo:1, bar:2, baz:null},
    b = {foo:1, bar:2, baz:null};
a.baz = a;
b.baz = b;

而且这些对象不是 …

我还没有找到以下方法来破解在任何主要的C++论坛/博客上解释的循环引用,比如GotW,所以我想问一下这种技术是否已知,它的优缺点是什么？

class Node : public std::enable_shared_from_this<Node> {
public:
   std::shared_ptr<Node> getParent() {
      return parent.lock();    
   }

   // the getter functions ensure that "parent" always stays alive!
   std::shared_ptr<Node> getLeft() {
       return std::shared_ptr<Node>(shared_from_this(), left.get());
   }

   std::shared_ptr<Node> getRight() {
       return std::shared_ptr<Node>(shared_from_this(), right.get());
   }

   // add children.. never let them out except by the getter functions!
public:
   std::shared_ptr<Node> getOrCreateLeft() {
       if(auto p = getLeft())
          return p;
       left = std::make_shared<Node>();
       left->parent = shared_from_this();
       return getLeft();
   }

   std::shared_ptr<Node> getOrCreateRight() {
       if(auto p = getRight())
          return p;
       right = …

在我的项目中，我有一个 type A，用于一些地方的参数，我希望一堆类型自动转换为该类型。我已经使用A. 我已经删除了触发问题所不需要的所有内容：

trait A
object A {
  implicit class SeqA[T](v: Seq[T])(implicit x: T => A) extends A
  implicit class IntA(v: Int) extends A
  implicit class TupleA(v: (Int, Int)) extends SeqA(Seq(v._1, v._2))
}

但scalac由于非法循环引用而拒绝此代码：

$ scalac -version
Scala compiler version 2.12.8 -- Copyright 2002-2018, LAMP/EPFL and Lightbend, Inc.
$ scalac A.scala 
A.scala:5: error: illegal cyclic reference involving class TupleA
  implicit class TupleA(v: (Int, Int)) extends SeqA(Seq(v._1, v._2))
                 ^
one error found

这里究竟有什么问题？什么是编译器绑定到涉及 …

周期性包容问题

我转发声明另一个标题中的一个类,试图解决它们的周期性包含.这是我的两个文件:

第一个文件(Parameter.h):

#pragma once
#include "Token.h"`

class Expression;

class Parameter {
public:

    Parameter() {
        string = new Token();
        identifier = new Token();
        expr = new Expression();
    }

    Token* string;
    Token* identifier;
    Expression* expr;
};

第二个文件(Expression.h):

#pragma once
#include "Token.h"
#include "Parameter.h"

class Expression {
public:
    Expression() {
        param1 = new Parameter();
        param2 = new Parameter();
        op = new Token();
    }

    Expression(Parameter* p1, Token* o, Parameter* p2) {
        param1 = p1;
        param2 = p2;
        op = …

我在实现项目的Web服务层时正在处理一些循环引用.我使用JAXB(最新版本2.2.7),甚至我为有一个看看一些技巧在这里和这里我无法得到它的工作.这是关于我的问题的基本SSCCE:

/*
* The service interface
*/
@WebService
public interface IMyWS {

    @WebMethod
    public List<Class1> cyclicTest();

}

/*
* Interface implementation
*/
@WebService(endpointInterface = "com.mycompany.ws.interfaces.IMyWS")
public class MyWS implements IMyWS {

    @XmlRootElement
    public static class Class1 {

        @XmlTransient
        private Class2 class2;

        public Class1() {

        }

        public Class1(Class2 refClass) {
            class2 = refClass;
        }

        public Class2 getClass2() {
            return class2;
        }

        public void setClass2(Class2 class2) {
            this.class2 = class2;
        }

        @Override
        public String toString() { …

今天我开始使用MapStruct为我的项目创建我的Model to DTO转换器,我想知道它是否自动处理循环引用,但事实证明它没有.

这是我测试它的转换器:

package it.cdc.snp.services.rest.giudizio;

import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
import org.springframework.stereotype.Component;

import it.cdc.snp.dto.entita.Avvisinotifica;
import it.cdc.snp.dto.entita.Corrispondenza;
import it.cdc.snp.model.notifica.AvvisoDiNotificaModel;
import it.cdc.snp.model.notifica.NotificaModel;
import it.cdc.snp.model.procedimento.ProcedimentoModel;

@Component
@Mapper(componentModel="spring")
public interface NotificaMapper {

    NotificaMapper INSTANCE = Mappers.getMapper( NotificaMapper.class );

    @Mappings({
        @Mapping(source = "avvisinotificas", target = "avvisinotificas"),
    })
    NotificaModel<ProcedimentoModel> corrispondenzaToNotificaModel(Corrispondenza notifica);

    @Mappings({
        @Mapping(source = "corrispondenza", target = "notifica"),
    })
    AvvisoDiNotificaModel avvisinotificaToAvvisoDiNotificaModel(Avvisinotifica avvisinotifica);


}

这是测试:

        Notifica sourceObject1 = new Notifica();
        sourceObject1.setId(new Long(1));
        Avvisinotifica sourceObject2 = new Avvisinotifica();
        sourceObject2.setId(new Long(11));
        List<Avvisinotifica> tests= new ArrayList<>(); …

让我们考虑以下2个循环引用示例:

直接循环参考

class A {        
    B b;        
}

class B {
    A a;
}

WeakReferenceing

class A {
    B b;
}

class B {
    WeakReference<A> aRef;
}

@Jon Skeet回答的以下SO问题清楚地表明,只要没有来自已知根的"GC行走"存在于循环中,直接的示例也将被垃圾收集.

我的问题如下:

是否有任何理由表现或以其他方式使用或不使用示例2中表示的习语 - 使用WeakReference的习语？

有关背景信息,请参阅此相关问题.

注意:当我说"无效引用"时,我指的是指向无数据的引用.

假设我们有以下包含循环引用的数据结构:

       +-----------------------------------------------------+
       |                                                     |
       +-->+============+    +==========+                    |
           [ Reference ----->[ Blessed  ]                    |
$parent -->+============+    [ Hash     ]                    |
                             [          ]   +==========+     |
                             [ children --->[ Array    ]     |
                             [          ]   [          ]     |
                             +==========+   [ 0: ---------+  |
                                            [          ]  |  |
                                            +==========+  |  |
                                                          |  |
       +--------------------------------------------------+  |
       |                                                     |
       +-->+============+    +==========+                    |
           [ Reference ----->[ Blessed  ]                    |
$child --->+============+    [ Hash     ]                    |
                             [          ]                    |
                             [ parent: ----------------------+
                             [          ] …