Only a speculation, but I am afraid it will be hard to be more certain without Bjarne Stroustrup confirming how it really was: It was designed this way because it was assumed such behaviour will be expected by the programmer, that he will expect the copy to be done when = sign is used, and … Read more
Reading the value of an uninitialized variable leads to undefined behavior. And undefined behavior means that it can crash. It doesn’t mean it will or it is obliged to crash. An uninitialized variable has unspecified value – it’s just unknown what its value is. So in practice, with any sane implementation, this kind of code … Read more
The code produces undefined behavior, because it attempts to dereference an uninitialized pointer. Undefined behavior is unpredictable and follows no logic whatsoever. For this reason, any questions about why your code does something or doesn’t do something make no sense. You are asking why it runs? It doesn’t run. It produces undefined behavior. You are … Read more
So is this just a case of ‘uninitialized data leads to unspecified behavior’ Yes… Sometimes if you call malloc (or new, which calls malloc) you will get data that is filled with zeroes because it is in a fresh page from the kernel. Other times it will be full of junk. If you put something … Read more
This is possibly a situation where X macros could be applied. animals.x X(DOG, 2) X(SPIDER, 8) X(WORM, 0) foo.c enum { #define X(a,b) ID_##a, #include “animals.x” #undef X }; int const numberOfEyes[] = { #define X(a,b) b, #include “animals.x” #undef X }; This not only guarantees that the lengths match, but also that the orders … Read more
Instead of using Self or A in each of the initialisers, you can simply override each subclass’ initialiser to use its own type as operation. This works because A‘s initialiser states that operation should be a type that conforms to A, and when you override it you have the liberty to use a subclass of … Read more
I do not really understand your question. That public class Test3 { private final String test = “test123”; public Test3() { System.out.println(“Test = “+test); } public static void main(String[] args) { Test3 t = new Test3(); } } executes as follows: $ javac Test3.java && java Test3 Test = test123
In composite literals the key (index in case of array and slice literals) can be optionally provided. For array and slice literals the following rules apply: Each element has an associated integer index marking its position in the array. An element with a key uses the key as its index; the key must be a … Read more
The size of the array must be a constant integral expression. An integral literal is a constant integral expression. (int arr[5];) A constant integral variable initialized with a constant expression is a constant expression. (const int j = 4; const int i = j; int a[i];) A constant variable initialized with a non-constant expression is … Read more
The usual. template<size_t…Is> std::array<foo_t, sizeof…(Is)> make_foos(std::index_sequence<Is…>) { return { ((void)Is, make_foo())… }; } template<size_t N> std::array<foo_t, N> make_foos() { return make_foos(std::make_index_sequence<N>()); }