default-constructor

What should I do to initialize boost::optional< T > if underlying type T is non-default constructible, non-copyable/moveable, but one's instance still can exist? Is it forbidden for boost::optional by any semantic reasons to have some member function like template< typename... Args > boost::optional< T >::construct(Args && ...args) , that delivers all the arguments to in-place operator new to construct the object entirely (for non-ref type T )? Variant is to have non-member function like std::make_shared< T > . It seems to me, that my problem can be solved by means of using of std::unique_ptr

I have a problem with Cython usage of default constructors. My C++ class Node is the following Node.h class Node { public: Node() { std::cerr << "calling no arg constructor" << std::endl; w=0.0; d=0.0; } Node(double val, double val2); { std::cerr << "calling 2 args constructor" << std::endl; this->w=val; this->d=val2; } private: double d,w; } is wrapped in Cython as follows cdef extern from "Node.h": cdef cppclass Node: Node() except + Node(double val1, double val2) except + double d double w cdef class pyNode: cdef Node *thisptr # hold a C++ instance which we're wrapping def __cinit__(self):

Suppose I have one POJO class User with a constuctor public User(int id, String name){...} . But when I instantiate the User object like User u=new User() with no parameter Eclipse gives error like The constructor User() is undefined . But it works fine when I have no parameterized Constructor. Can someone please explain why It requires to define default constructor? Kon The default (no-parameter) constructor is ONLY provided if you have provided no others. If you define even a single constructor for your class, you MUST use one of the explicitly defined (ie, in your code) constructors to

I have a general question, that may be a little compiler-specific. I'm interested in the conditions under which a constructor will be called. Specifically, in release mode/builds optimised for speed , will a compiler-generated or empty constructor always be called when you instantiate an object? class NoConstructor { int member; }; class EmptyConstructor { int member; }; class InitConstructor { InitConstructor() : member(3) {} int member; }; int main(int argc, _TCHAR* argv[]) { NoConstructor* nc = new NoConstructor(); //will this call the generated constructor? EmptyConstructor* ec = new

If I have a structure with an array member, and I explicitly call the default constructor of the array in the structure's constructor, will the elements get default-constructed? (In the case of an integer array, this would mean getting zero-initialized). struct S { S() : array() {} int array[SIZE]; }; ... S s; // is s.array zero-initialized? A quick test with gcc suggests that this is the case, but I wanted to confirm that I can rely on this behaviour. (I have noticed that if I don't explicitly default-construct the array in the structure constructor, the array elements have random values.)

I encountered a question that asks "Which of the following are true about the "default" constructor?" and an option "It initializes the instance members of the class." was incorrect choice. Now my understanding was that if we have a code such as Class Test { String name; } then the compiler creates default constructor that looks like Class Test { String name; Test(){ super(); name = null; } } Isn't the default constructor initializing the instance member name=null ? The class constructor is not the one doing the initialization, the JVM does this. After memory for the object is created, the