In this declaration toto t = new toto(0); the object t of the class type toto is initialized by the pointer returned by the expression new toto(0). As the returned pointer is not equal to nullptr then it is implicitly converted to the boolean value true. So in fact you have toto t = true; … Read more
I think the lvalue-to-rvalue conversion is more than just use an lvalue where an rvalue is required. It can create a copy of a class, and always yields a value, not an object. I’m using n3485 for “C++11” and n1256 for “C99”. Objects and values The most concise description is in C99/3.14: object region of … Read more
… why I get two different numbers … Aside from the usual float-point issues, the computation paths to b and c are arrived in different ways. c is calculated by first saving the value as double a. double a =(Vmax-Vmin)/step; int b = (Vmax-Vmin)/step; int c = a; C allows intermediate floating-point math to be … Read more
You can take a look at how compiler lowers this code: int? a = 3; Sample<int> sampleA = a; into this: int? nullable = 3; int? nullable2 = nullable; Sample<int> sample = nullable2.HasValue ? ((Sample<int>)nullable2.GetValueOrDefault()) : null; Because Sample<int> is a class its instance can be assigned a null value and with such an implicit … Read more
Quoting from C++ standard draft N4296, Section 5.16 Conditional operator, Paragraph 6.3: One or both of the second and third operands have pointer type; pointer conversions (4.10) and qualification conversions (4.4) are performed to bring them to their composite pointer type (Clause 5). The result is of the composite pointer type. Section 5 Expressions, Paragraph … Read more
No, you can’t use explicit, but you can use a templated function to catch the incorrect parameter types. With C++11, you can declare the templated function as deleted. Here is a simple example: #include <iostream> struct Thing { void Foo(int value) { std::cout << “Foo: value” << std::endl; } template <typename T> void Foo(T value) … Read more
Let’s simplify: interface IAnimal { … } interface ICage<T> where T : IAnimal { void Enclose(T animal); } class Tiger : IAnimal { … } class Fish : IAnimal { … } class Cage<T> : ICage<T> where T : IAnimal { … } ICage<IAnimal> cage = new Cage<Tiger>(); Your question is: why is the last … Read more
Let’s look at the limitations listed for value classes and think when they may not be suitable for implicit classes: “must have only a primary constructor with exactly one public, val parameter whose type is not a value class.” So if the class you are wrapping is itself a value class, you can’t use an … Read more
I’m just replying to the first part of the question to start with. (I suggest that the second part should be a separate question; it’s more likely to be a bug.) There’s only an explicit conversion from decimal to int, but that conversion is being implicitly called in your code. The conversion happens in this … Read more
This is a fairly frequently asked question. In C#, we almost always reason from inside to outside. When you see x = y; we work out what is the type of x, what is the type of y, and whether the type of y is assignment compatible with x. But we do not use the … Read more