标签: constructor

您不能在PHP类中放置两个带有唯一参数签名的__construct函数.我想这样做:

class Student 
{
   protected $id;
   protected $name;
   // etc.

   public function __construct($id){
       $this->id = $id;
      // other members are still uninitialized
   }

   public function __construct($row_from_database){
       $this->id = $row_from_database->id;
       $this->name = $row_from_database->name;
       // etc.
   }
}

在PHP中执行此操作的最佳方法是什么？

最近我见过如下例子:

#include <iostream>

class Foo {
public:
  int bar;
  Foo(int num): bar(num) {};
};

int main(void) {
  std::cout << Foo(42).bar << std::endl;
  return 0;
}

这奇怪: bar(num)意味着什么？它似乎初始化成员变量,但我以前从未见过这种语法.它看起来像一个函数/构造函数调用,但对于一个int？对我没有任何意义.也许有人可以启发我.而且,顺便说一下,还有其他类似的深奥语言功能,你永远不会在一本普通的C++书中找到它吗？

因此,在观看了关于右值引用的精彩演讲之后,我认为每个类都会受益于这样的"移动构造函数",template<class T> MyClass(T&& other) 编辑,当然还有"移动赋值运算符",template<class T> MyClass& operator=(T&& other)正如Philipp在他的回答中指出的,如果它已经动态分配成员,或通常存储指针.就像你应该有一个copy-ctor,赋值运算符和析构函数,如果之前提到的点适用.思考？

假设我有一个类,其成员名为data,这是一个列表.

我希望能够使用例如文件名(包含初始化列表的数据)或实际列表来初始化类.

你这样做的技巧是什么？

你只是看看类型__class__吗？

我可能会缺少一些技巧吗？

我已经习惯了C++,其中按参数类型重载很容易.

请向我解释一下静态构造函数的用法.我们为什么以及何时创建静态构造函数,是否可以重载一个？

考虑一下 - 基类A,继承自A的类B,继承自B的类C.什么是在构造函数中调用父类构造函数的通用方法？如果这仍然听起来太模糊,这里有一些代码.

class A(object):
    def __init__(self):
        print "Initialiser A was called"

class B(A):
    def __init__(self):
        super(B,self).__init__()
        print "Initialiser B was called"

class C(B):
    def __init__(self):
        super(C,self).__init__()
        print "Initialiser C was called"

c = C()

这就是我现在这样做的方式.但它仍然看起来有点过于非泛型 - 您仍然必须手动传递正确的类型.

现在,我尝试使用self.__class__作为super()的第一个参数,但是,显然它不起作用 - 如果你把它放在C的构造函数中 - 公平,B的构造函数被调用.如果你在B中做同样的事情,"self"仍然指向一个C的实例,所以你最终再次调用B的构造函数(这以无限递归结束).

现在没有必要考虑钻石继承,我只想解决这个具体问题.

我正在和一位同事讨论如何从构造函数中抛出异常,并且我想要一些反馈.

从设计的角度来看,从构造函数中抛出异常是否可以？

假设我在一个类中包装一个POSIX互斥锁,它看起来像这样:

class Mutex {
public:
  Mutex() {
    if (pthread_mutex_init(&mutex_, 0) != 0) {
      throw MutexInitException();
    }
  }

  ~Mutex() {
    pthread_mutex_destroy(&mutex_);
  }

  void lock() {
    if (pthread_mutex_lock(&mutex_) != 0) {
      throw MutexLockException();
    }
  }

  void unlock() {
    if (pthread_mutex_unlock(&mutex_) != 0) {
      throw MutexUnlockException();
    }
  }

private:
  pthread_mutex_t mutex_;
};

我的问题是,这是标准的方法吗？因为如果pthread mutex_init调用失败,则互斥对象不可用,因此抛出异常可确保不会创建互斥锁.

我是否应该为Mutex类创建一个成员函数init,并pthread mutex_init在其中调用将返回基于返回的bool pthread mutex_init？这样我就不必为这种低级对象使用异常.

您可以在网上找到以下内容:

1. 更高的kinded类型==类型构造函数？

   class AClass[T]{...} // For example, class List[T]
   

   Run Code Online (Sandbox Code Playgroud)

   有人说这是一种更高的kinded类型,因为它抽象了符合定义的类型.

   较高的kinded类型是采用其他类型并构造新类型的类型

   这些虽然也称为类型构造函数.(例如,在Scala中编程).

2. 更高的kinded type == type构造函数,它将类型构造函数作为类型参数？

   在更高级别的Generics中,您可以阅读

   ...抽象类型抽象的类型("更高级的类型")......"

   这表明

   class XClass[M[T]]{...} // or
   
   trait YTrait[N[_]]{...} // e.g. trait Functor[F[_]]
   

   Run Code Online (Sandbox Code Playgroud)

   是一种更高级的类型.

因此,考虑到这一点,很难区分类型构造函数,更高的kinded类型和类型构造函数,它将类型构造函数作为类型参数,因此上面的问题.

我有一个Silverlight项目,我试图在构造函数中填充一些数据:

public class ViewModel
{
    public ObservableCollection<TData> Data { get; set; }

    async public ViewModel()
    {
        Data = await GetDataTask();
    }

    public Task<ObservableCollection<TData>> GetDataTask()
    {
        Task<ObservableCollection<TData>> task;

        //Create a task which represents getting the data
        return task;
    }
}

不幸的是,我收到一个错误:

修饰符async对此项目无效

当然,如果我在标准方法中包装并从构造函数中调用它:

public async void Foo()
{
    Data = await GetDataTask();
}

它工作正常.同样,如果我使用旧的由内而外的方式

GetData().ContinueWith(t => Data = t.Result);

这也有效.我只是想知道为什么我们不能await直接在构造函数内调用.可能有很多(甚至是明显的)边缘情况和反对它的理由,我只是想不出来.我也在寻找解释,但似乎找不到任何解释.

为什么C++没有虚拟构造函数？