/* 1 */ Foo* foo1 = new Foo (); Creates an object of type Foo in dynamic memory. foo1 points to it. Normally, you wouldn’t use raw pointers in C++, but rather a smart pointer. If Foo was a POD-type, this would perform value-initialization (it doesn’t apply here). /* 2 */ Foo* foo2 = new … Read more
This is simply how C# is going to work. The constructors for each type in the type hierarchy will be called in the order of Most Base -> Most Derived. So in your particular instance, it calls Person(), and then Customer() in the constructor orders. The reason why you need to sometimes use the base … Read more
Both do different things. The first creates an object with automatic storage duration. It is created, used, and then goes out of scope when the current block ({ … }) ends. It’s the simplest way to create an object, and is just the same as when you write int x = 0; The second creates … Read more
Calling a generic constructor This is unusual alright, but fully valid Java. To understand we need to know that a class may have a generic constructor, for example: public class TypeWithGenericConstructor { public <T> TypeWithGenericConstructor(T arg) { // TODO Auto-generated constructor stub } } I suppose that more often than not when instantiating the class … Read more
You cannot instantiate final fields in the constructor body. There is a special syntax for that: class Point { final num x; final num y; final num distanceFromOrigin; // Old syntax // Point(x, y) : // x = x, // y = y, // distanceFromOrigin = sqrt(pow(x, 2) + pow(y, 2)); // New syntax Point(this.x, … Read more
If this class is only a utility class, you should make the class final and define a private constructor: public final class FilePathHelper { private FilePathHelper() { //not called } } This prevents the default parameter-less constructor from being used elsewhere in your code. Additionally, you can make the class final, so that it can’t … Read more
Yes, it is, the syntax is close to C#, here is an example with both default constructor and named constructor: class Foo { Foo(int a, int b) { //Code of constructor } Foo.named(int c, int d) { //Code of named constructor } } class Bar extends Foo { Bar(int a, int b) : super(a, b); … Read more
Definitely a matter of style. I prefer constructors with default parameters, so long as the parameters make sense. Classes in the standard use them as well, which speaks in their favor. One thing to watch out for is if you have defaults for all but one parameter, your class can be implicitly converted from that … Read more
There is no way to explicitly specify the template arguments when calling a constructor template, so they have to be deduced through argument deduction. This is because if you say: Foo<int> f = Foo<int>(); The <int> is the template argument list for the type Foo, not for its constructor. There’s nowhere for the constructor template’s … Read more
Because if it’s not by reference, it’s by value. To do that you make a copy, and to do that you call the copy constructor. But to do that, we need to make a new value, so we call the copy constructor, and so on… (You would have infinite recursion because “to make a copy, … Read more