标签: constructor

不知何故,在下面的Node类中,wordList和adjacencyList变量在Node的所有实例之间共享.

>>> class Node:
...     def __init__(self, wordList = [], adjacencyList = []):
...         self.wordList = wordList
...         self.adjacencyList = adjacencyList
... 
>>> a = Node()
>>> b = Node()
>>> a.wordList.append("hahaha")
>>> b.wordList
['hahaha']
>>> b.adjacencyList.append("hoho")
>>> a.adjacencyList
['hoho']

有没有什么方法可以继续使用默认值(在这种情况下为空列表)的构造函数参数,但要让a和b都有自己的wordList和adjacencyList变量？

我正在使用python 3.1.2.

这是我想写的结构:

  public struct AttackTraits
        {
            public AttackTraits(double probability, int damage, float distance)
            {
                Probability = probability;
                Distance = distance;
                Damage = damage;
            }

            private double probability;
            public double Probability
            {
                get
                {
                    return probability;
                }
                set
                {
                    if (value > 1 || value < 0)
                    {
                        throw new ArgumentOutOfRangeException("Probability values must be in the range [0, 1]");
                    }
                    probability = value;
                }
            }

            public int Damage { get; set; }

            public float Distance { get; set; }
        }

这会导致以下编译错误:

在分配所有字段之前,不能使用"this"对象 …

默认构造函数与直接初始化对象字段之间的区别是什么？

有什么理由更喜欢以下示例中的一个而不是另一个？

例1

public class Foo
{
    private int x = 5;
    private String[] y = new String[10];
}

例2

public class Foo
{
    private int x;
    private String[] y;

    public Foo()
    {
        x = 5;
        y = new String[10];
    }
}

有一些类似的主题,但我找不到一个有足够答案的主题.

我想知道在Java中构造函数重载的最佳实践是什么.我已经对这个问题有了自己的想法,但我想听听更多建议.

我指的是简单类中的构造函数重载和构造函数重载,同时继承已经重载的类(意味着基类具有重载的构造函数).

谢谢 :)

给定一个功能:

function x(arg) { return 30; }

您可以通过两种方式调用它:

result = x(4);
result = new x(4);

第一个返回30,第二个返回一个对象.

如何检测函数本身内部调用函数的方式？

无论您的解决方案是什么,它都必须使用以下调用:

var Z = new x(); 
Z.lolol = x; 
Z.lolol();

目前认为所有解决方案Z.lolol()都将其称为构造函数.

我正在使用Spring 3.0.5并尽可能地为我的班级成员使用@Autowire注释.我需要自动装配的bean之一需要其构造函数的参数.我查看了Spring文档,但似乎找不到任何关于如何注释构造函数参数的引用.

在XML中,我可以将其用作bean定义的一部分.@Autowire注释是否有类似的机制？

例如:

@Component
public class MyConstructorClass{

  String var;
  public MyConstructorClass( String constrArg ){
    this.var = var;
  }
...
}


@Service
public class MyBeanService{
  @Autowired
  MyConstructorClass myConstructorClass;

  ....
}

在此示例中,如何使用@Autowire注释在MyBeanService中指定"constrArg"的值？有没有办法做到这一点？

谢谢,

埃里克

今天,我发现了一个相当有趣的事情g++或者nm......构造函数定义似乎在库中有两个条目.

我有一个标题thing.hpp:

class Thing
{
    Thing();

    Thing(int x);

    void foo();
};

而且thing.cpp:

#include "thing.hpp"

Thing::Thing()
{ }

Thing::Thing(int x)
{ }

void Thing::foo()
{ }

我编译它:

g++ thing.cpp -c -o libthing.a

然后,我继续nm:

%> nm -gC libthing.a
0000000000000030 T Thing::foo()
0000000000000022 T Thing::Thing(int)
000000000000000a T Thing::Thing()
0000000000000014 T Thing::Thing(int)
0000000000000000 T Thing::Thing()
                 U __gxx_personality_v0

如您所见,两个构造函数Thing都在生成的静态库中列出了两个条目.我的g++是4.4.3,但是同样的行为发生在clang,所以这不仅仅是一个gcc问题.

这不会引起任何明显的问题,但我想知道:

• 为什么定义的构造函数列出两次？
• 为什么这不会导致"符号__的多重定义"问题？

编辑:对于卡尔,没有C参数的输出:

%> …

如果我的目标setter是私有的,我可能想使用目标对象的构造函数映射到该对象.你会如何使用Automapper做到这一点？

在Scala 2.8中是否有一种方法来重载案例类的构造函数？

如果是的话,请把一个片段解释一下,如果没有,请解释原因？

在C++中,

除了动态内存分配之外,以下两行代码之间是否存在功能差异:

Time t (12, 0, 0); //t is a Time object

Time* t = new Time(12, 0, 0);//t is a pointer to a dynamically allocated Time object

我当然假设定义了一个Time(int,int,int)ctor.我也意识到在第二种情况下,t将需要删除,因为它是在堆上分配的.还有其他区别吗？