implicit-cast

Given this class with an implicit cast operator: public class MyDateTime { public static implicit operator MyDateTime(System.Int64 encoded) { return new MyDateTime(encoded); } public MyDateTime(System.Int64 encoded) { _encoded = encoded; } System.Int64 _encoded; } I can now do the following: long a = 5; MyDateTime b = a; But NOT the following: long f = 5; object g = f; MyDateTime h = g; This gives a compile time: Cannot implicitly convert type 'object' to 'MyDateTime'. Makes sense to me. Now I modify the previous example as follows: long f = 5; object g = f; MyDateTime h = (MyDateTime)g; This

What is implicit_cast? when should I prefer implicit_cast rather than static_cast? Johannes Schaub - litb I'm copying over from a comment i made to answer this comment at another place. You can down-cast with static_cast . Not so with implicit_cast . static_cast basically allows you to do any implicit conversion, and in addition the reverse of any implicit conversion (up to some limits. you can't downcast if there is a virtual base-class involved). But implicit_cast will only accept implicit conversions. no down-cast, no void*->T* , no U->T if T has only explicit constructors for U. Note that

short s; s = (EitherTrueOrFalse()) ? 0 : 1; This fails with: error CS0266: Cannot implicitly convert type 'int' to 'short'. An explicit conversion exists (are you missing a cast?) Can anyone explain why this is so? The only thing I can think of is that the compiler doesn't look at the second value and doesn't know the range between the two, in the case I wrote something like short s; s = (EitherTrueOrFalse()) ? 0 : 65000; Correct? The only fix is with an ugly cast? Also, it seems C# does not have a type suffix for the short type. That's a pretty grave oversight IMO. Otherwise, that would've

How do I avoid implicit casting on non-constructing functions? I have a function that takes an integer as a parameter, but that function will also take characters, bools, and longs. I believe it does this by implicitly casting them. How can I avoid this so that the function only accepts parameters of a matching type, and will refuse to compile otherwise? There is a keyword "explicit" but it does not work on non-constructing functions. :\ what do I do? The following program compiles, although I'd like it not to: #include <cstdlib> //the function signature requires an int void function(int i);

In Java, when you do int b = 0; b = b + 1.0; You get a possible loss of precision error. But why is it that if you do int b = 0; b += 1.0; There isn't any error? polygenelubricants That's because b += 1.0; is equivalent to b = (int) ((b) + (1.0)); . The narrowing primitive conversion (JLS 5.1.3) is hidden in the compound assignment operation. JLS 15.26.2 Compound Assignment Operators (JLS Third Edition): A compound assignment expression of the form E1 op= E2 is equivalent to E1 = (T)((E1) op (E2)) , where T is the type of E1 , except that E1 is evaluated only once. For example, the following