Observation: the codes pasted below were tested only with GCC 4.4.1, and I'm only interested in them working with GCC.

你好,

我偶然发现了一些我不理解的对象构造语句,而且直到今天我才注意到它引入的模糊性.我将解释如何重现它,并想知道是否有办法解决它(允许C++ 0x).在这里.

假设有一个类,其构造函数只接受一个参数,而这个参数的类型是另一个具有默认构造函数的类.例如:

struct ArgType {};

class Class
{
public:
    Class(ArgType arg);
};

如果我尝试Class在堆栈上构造一个类型的对象,我会产生歧义:

Class c(ArgType()); // is this an object construction or a forward declaration
                    // of a function "c" returning `Class` and taking a pointer
                    // to a function returning `ArgType` and taking no arguments
                    // as argument? (oh yeh, loli haets awkward syntax in …

假设我有以下代码

public class SuperClass {
    protected int super_class_value;

    public SuperClass (int value) {
        this.super_class_value = value;
    }
}

public class Subclass extends SuperClass {
    protected int subclass_value;

    public SubClass(int super_class_value, int subclass_value) {
        super(super_class_value);
        this.subclass_value = subclass_value;
    }
}

但是，现在我希望能够将 SuperClass 对象传递给 SubClass 构造函数。我该怎么做？

public SubClass(SuperClass super_class, int subclass_value) {
    //What do I do here?
    this.subclass_value = subclass_value;
}

基本上，我想做这样的事情......

public SubClass(SuperClass super_calss, int subclass_value) {
    super(super_class.super_class_value);
    this.subclass_value = subclass_value;
}

但是如果 SuperClass 更复杂，我不想将每个值添加到 super() 调用中。相反，我想简单地传入一个已经存在的对象，并将其用作超类。

我想做这个...

public SubClass(SuperClass super_class, …

在Perl5中,您可以执行以下操作:

#!/usr/bin/env perl
use 5.010;

package Local::Class {
  use Moo;
  has [qw( x y )] => ( is => 'ro');
  sub BUILDARGS { shift; return (@_) ? (@_ > 1) ? { @_ } : shift : {} }
}

use Local::Class;

# Create object directly
my $x = Local::Class->new( x => 1, y => 10 );
say $x->x, ' ', $x->y; # 1 10

# Arguments from a hash
my %hash = ( x => 5, y => 20 …

我想初始化派生类的成员变量，然后将其传递给基类构造函数。我想出了下面的解决方案（也在这里：http : //cpp.sh/4uu4q）

1) 以下代码是否具有已定义或未定义的行为 (UB)？

2）我试图做的是否表明设计不佳？

struct Data {
    int fValue;

    Data( int value = -1 ) : fValue( value )
    {}
};


struct Base {
    Base( const std::unique_ptr<Data> & derivedData ) {
        std::cout << "Constructing Base derivedData=" << derivedData->fValue << std::endl;
    }
};


struct Derived : public Base {
    std::unique_ptr<Data> fData = std::move( fData );

    Derived() : Base( ConstructData() )
    {}

    const std::unique_ptr<Data> & ConstructData() {
        fData.release();
        fData.reset( new Data(777) );
        std::cout << "in ConstructData: fData->fValue …

与Perl5中的大多数内容一样,有许多方法可以创建支持其属性的自定义类型强制的类.这是一个简单的,从数组引用到哈希:

#!/usr/bin/env perl

package Local::Class {
  use Moo;
  use Types::Standard qw( HashRef ArrayRef );

  has set => (
    is => 'ro',
    coerce => 1,
    isa => HashRef->plus_coercions(
      ArrayRef, sub { return { map { $_ => 1} @{$_[0]} } },
    ),
  );
}

my $o = Local::Class->new({ set => [qw( a b b c )] });
# $o->set now holds { a => 1, b => 1, c => 1}

我一直试图将这样的东西移植到Perl6,在那里看起来我需要的是一种强制转换Array为a的方法SetHash.到目前为止,我能够做到这一点的唯一方法是:

#!/usr/bin/env perl6

class Local::Class { …

您能解释一下下面的代码有什么问题吗？

function box (width, height, color) {
    this.width=width;
    this.height=height;
    this.color=color;
    this.style.width=width;
    this.style.height=height;
    this.style.backgroundColor=color;
}

var box1 = new box (100, 100, 'red');

document.body.appendChild(box1);

除了“再次”询问有关Python__new__和__init__Python 的明显问题之外，我可以保证，我知道它的作用。我将展示一些奇怪的、在我看来没有记录的行为，为此我寻求专业帮助:)。

背景

__slots__我正在使用用户定义的元类（称为 ）实现多个功能，例如抽象方法、抽象类、必须重写的方法、单调行为、槽类（自动推断）和混合类（延迟槽） ExtendedType。以下代码可以在开发分支的pyTooling/pyTooling中找到。

因此，提出的问题是一个精简和简化的变体，展示了 的奇怪行为object.__new__。

主意

根据 的内部算法ExtendedType，它可能会决定一个类A是抽象的。如果是这样，该__new__方法将被替换为引发异常的虚拟方法 ( AbstractClassError)。稍后，当一个类B(A)继承自 时A，元类可能会做出决定，B不再是抽象的，因此我们希望允许再次创建对象并允许调用原始__new__方法。因此，原始方法被保留为类中的字段。

为了简化抽象性决策的内部算法，元类实现了一个布尔命名参数abstract。

class AbstractClassError(Exception):
    pass

class M(type):
  # staticmethod
  def __new__(cls,  className, baseClasses, members, abstract):
    newClass = type.__new__(cls, className, baseClasses, members)
        
    if abstract:
      def newnew(cls, *_, **__):
        raise AbstractClassError(f"Class is abstract")
            
      # keep original __new__ and exchange it with …

我特意在Ninject中使用C#,但问题不仅仅是Ninject.我的问题是我有几个类都有不同的构造函数参数加上注入的类.我知道我可以kernel.Get<MyObject>(constructor args here)用来实例化对象.这对我来说并不合适,因为我的内核遍布整个地方.我会尽力列出下面的例子.

我现在拥有的:

public interface IStore<T>
{
    void CommitToDatabase(T item);
}

public abstract class Thing
{
    private IStore<Thing> _store;

    protected Thing(object key, IStore<Thing> store)
    {
        Key = key;
        _store = store;
    }

    public object Key { get; private set; }

    public virtual void Update()
    {
        _store.CommitToDatabase(this);
    }
}

public class Person :Thing
{
    public Person(object key, string name, int age, IStore<Thing> store)
        : base(key, store)
    {
        Name = name;
        Age = age;
    }

    public string Name { …

我的问题或多或少与需要一个设计模式去除对象创建中的枚举和切换语句的问题相同但是我没有看到抽象工厂模式适合这里.

我目前正计划对一些现有的DAL/ORM混合库进行重构/重新实现.在现有代码中的某处,代码如下所示:

class Base
{
  static Base * create(struct Databasevalues dbValues)
  {
    switch(dbValues.ObjectType)
    {
    case typeA:
      return new DerivedA(dbValues);
      break;
    case typeB:
      return new DerivedB(dbValues);
      break;
    }
  }
}

class DerivedA : public Base
{
  // ...
}

class DerivedB : public Base
{
  // ...
}

因此,负责数据库通信的库使用有关数据库实体的所有信息填充结构,然后调用上述create()方法以在ORM中实际创建相应的对象.但我不喜欢基类知道所有派生类的想法,我也不喜欢switch语句.我还想避免创建另一个类只是为了创建这些对象.您如何看待当前的方法？你会如何实现这个功能？

我有一个抽象类及其具体的子类,当我创建子类的对象时,它会自动调用超级构造函数.JVM是否在内部创建抽象类的对象？

public abstract class MyAbstractClass {

    public MyAbstractClass() {
        System.out.println("abstract default constructor");
    }

}
public class ConcreteClass extends MyAbstractClass{

    public static void main(String[] args) {
        new ConcreteClass();
    }

}

然后如何在JVM中没有对象的构造函数存在？(如果是抽象类)

构造函数在创建对象后执行,然后不创建抽象类的对象如何执行默认构造函数？(这在Java Doc中提到)