According to , class complex&lt;double&gt; has a default construct of the form complex (double re = 0.0, double im = 0.0);. However, I don't know if this is really correct. Could anyone explain the strange behavior of the code below?  #include &lt;iostream&gt; #include &lt;complex&gt; #include &lt;typeinfo&gt; using namespace std;  int main() {      complex&lt;double&gt; cmp1(1, 2);     complex&lt;double&gt; cmp2(1); //isn't the same as cmp2(1, 0.0) ?     complex&lt;double&gt; cmp3(); //isn't the same as cmp3(0.0, 0.0) ?      cout &lt;&lt; cmp1.real() &lt;&lt; "\n"; //=&gt; 1     cout &lt;&lt; cmp1.imag() &lt;&lt; "\n"; //=&gt; 2      cout &lt;&lt; cmp2.real() &lt;&lt; "\n"; //=&gt; 1     cout &lt;&lt; cmp2.imag() &lt;&lt; "\n"; //=&gt; 0      //cout &lt;&lt; cmp3.real() &lt;&lt; "\n"; //error (why?) //mark1     //cout &lt;&lt; cmp3.imag() &lt;&lt; "\n"; //error (why?)      /* error message output by `mark1`: */     /* request for member ‘real’ in ‘cmp3’, which is of */     /* non-class type ‘std::complex&lt;double&gt;()’ */      cout &lt;&lt; cmp3 &lt;&lt; "\n"; //=&gt; 1 (why?)      cout &lt;&lt; typeid(cmp1).name() &lt;&lt; "\n"; //=&gt; St7complexIdE     cout &lt;&lt; typeid(cmp2).name() &lt;&lt; "\n"; //=&gt; St7complexIdE     cout &lt;&lt; typeid(cmp3).name() &lt;&lt; "\n"; //=&gt; FSt7complexIdEvE  }   Environment:  $ g++ --version g++ (Ubuntu 5.4.0-6ubuntu1~16.04.9) 5.4.0 20160609   Compiling option:  $ g++ -Wall -std=c++98 &lt;file name&gt;
1377
Is there any good reason that an empty set of round brackets (parentheses) isn't valid for calling the default constructor in C++?  MyObject  object;  // ok - default ctor MyObject  object(blah); // ok  MyObject  object();  // error   I seem to type "()" automatically everytime. Is there a good reason this isn't allowed?
203
I came across this code:  void f(const std::string &amp;s);   And then a call:  f( *((std::string*)NULL) );   And I was wondering what others think of this construction, it is used to signal that function f() should use some default value (which it computes) instead of some user provided value.  I am not sure what to think of it, it looks weird but what do you think of this construction?
77771
I can't find much information on const_cast.  The only info I could find (on Stack Overflow) is:     The const_cast&lt;&gt;() is used to add/remove const(ness) (or volatile-ness) of a variable.   This makes me nervous.  Could using a const_cast cause unexpected behavior?  If so, what?  Alternatively, when is it okay to use const_cast?
26743
How can I format my output in C++? In other words, what is the C++ equivalent to the use of printf like this:  printf("%05d", zipCode);   I know I could just use printf in C++, but I would prefer the output operator &lt;&lt;.  Would you just use the following?  std::cout &lt;&lt; "ZIP code: " &lt;&lt; sprintf("%05d", zipCode) &lt;&lt; std::endl;
33779
I came across some very strange behaviour when working with a Map with Decimal keys today. It seems like the Decimal type can't handle Integer assignments properly, but allows them nonetheless. I've written some example code demonstrating the problem:  Map&lt;Decimal, String&gt; m = new Map&lt;Decimal, String&gt;(); m.put(1234, 'Integer key');  m.put(1234.0, 'Decimal key'); m.put(1234.5, 'Decimal Unique key');  System.debug(m.get(1234));      // =&gt; Integer key, why was this not overwritten if 1234 == 1234.0? System.debug(m.get(1234.0));    // =&gt; Decimal key System.debug(m.get(1234.5));    // =&gt; Decimal Unique key  System.debug(m);        //Order of insertion matters, newest value does not override existing one but is not shown on map printout... for(Decimal d : m.keySet()){     System.debug(d);    //...unless you print it out yourself, because this loop shows all the keys }  //Sanity check System.debug(1234 == 1234.0); //True  //Digging deeper Decimal fake_d = 1234; Decimal real_d = 1234.0; Integer real_i = 1234; //Integer fake_i = 1234.0; //Illegal assignment, typechecking only works one way, it seems  //More sanity checks System.debug(fake_d == real_d); //True (Except when used in a Map, apparently) System.debug(fake_d == real_i); //True  System.debug(m.get(real_i)); // =&gt; Integer key System.debug(m.get(fake_d)); // =&gt; Integer key, even with fake_d explicitely declared as a Decimal type, it still pretends to be an Integer. System.debug(m.get(real_d)); // =&gt; Decimal key   I found this behaviour when I tried to fetch a value from a map using a Decimal sObject field, only to find that the keys I used to populate the Map (coming from a different Decimal field) were interpreted as Integers since they had no real decimal digits.  Maybe using Decimals as Map keys is not supported for some reason? Is it expected behaviour for 1234 and 1234.0 being distinct values in this case or is this an oversight in the Map implementation?
18930
The use of imaginary and complex values comes up in many physics and engineering derivations. I have a question about that: Is the use of complex numbers simply to make the process of derivation easier, or is it an essential ingredient, without which it would be impossible to derive some results?   I can identify two different settings where the answer may be different:   It doesn't look like it is mandatory for results in Newtonian mechanics, General Relativity and classical electrodynamics. Can we say the same thing about quantum mechanics either way for sure?   Could this be a difference in quantum mechanics over the classical picture?
90560
In most programming languages, integer and real (or float, rational, whatever) types are usually disjoint; 2 is not the same as 2.0 (although most languages do an automatic conversion when necessary). In addition to technical reasons, this separation makes sense -- you use them for quite different purposes.  Why did they choose to say $\mathbb{Z} \subset \mathbb{R}$ in math? In other words, why are 2 and 2.0 considered the same?  When you are working in $\mathbb{R}$, does it make any difference whether some elements, eg. 2.0, also belong to $\mathbb{Z}$ or not?
66958
I want to do:  int a = 255;  cout &lt;&lt; a;   and have it show FF in the output, how would I do this?
79557
I'm having a little argument with my friend. He says that "$a + 0i$" is, in every way, absolutely equal to "$a$" (e.g.: $2 + 0i = 2$).  I say this is practically the case, so in every calculation you just assume that "$a + 0i$" is equal to the real number "$a$" and you always get the right results (this might not even be true, but I am no expert and as far as I can see this is the case). But then again, I believe that just cutting away "$+ 0i$" makes this number is not the same kind of number anymore, it's changed its structure and is not totally equivalent anymore. This is where he says I am absolutely wrong.  So, is it mathematically (strictly speaking!) perfectly fine to say that every complex number with an imaginary part of $0$ is just a real number? Or does this change the mathematical structure so much that it cannot be mathematically-valid but just something that happens to work (which is what I believe)?  I must say that I believe a complex number is one entity, whilst he believes that it is just a conglomerate of other entitites. So, as one said here, "$(a + bi) - bi = a$", I believe is barely a good argument. But then again: is it correct to view $a + bi$ as a single entity (like "$5$" or "$2$", just consisting of multiple symbols)? I'm (as a non-mathematician) not sure there either.
62585
Given the following example, why do I have to explicitly use the statement b-&gt;A::DoSomething() rather than just b-&gt;DoSomething()?  Shouldn't the compiler's overload resolution figure out which method I'm talking about?  I'm using Microsoft VS 2005. (Note: using virtual doesn't help in this case.)  class A {   public:     int DoSomething() {return 0;}; };  class B : public A {   public:     int DoSomething(int x) {return 1;}; };  int main() {   B* b = new B();   b-&gt;A::DoSomething();    //Why this?   //b-&gt;DoSomething();    //Why not this? (Gives compiler error.)   delete b;   return 0; }
121518
Debugging some finance-related SQL code found a strange issue with numeric(24,8) mathematics precision.  Running the following query on your MSSQL you would get A + B * C expression result to be 0.123457  SELECT A,        B,        C,        A + B * C FROM ( SELECT CAST(0.12345678 AS NUMERIC(24,8)) AS A,        CAST(0 AS NUMERIC(24,8)) AS B,        CAST(500 AS NUMERIC(24,8)) AS C ) T  So we have lost 2 significant symbols. Trying to get this fixed in different ways i got that conversion of the intermediate multiplication result (which is Zero!) to numeric (24,8) would work fine.  And finally a have a solution. But still I hace a question - why MSSQL behaves in this way and which type conversions actually occured in my sample?
105280
C++ guarantees that variables in a compilation unit (.cpp file) are initialised in order of declaration. For number of compilation units this rule works for each one separately (I mean static variables outside of classes).  But, the order of initialization of variables, is undefined across different compilation units.  Where can I see some explanations about this order for gcc and MSVC (I know that relying on that is a very bad idea - it is just to understand the problems that we may have with legacy code when moving to new GCC major and different OS)?
81621
If I write the following class:  public class Example {        int j;       int k;        public Example(int j, int k) {            j = j;            k = k;       }        public static void main(String[] args) {            Example exm = new Example(1,2);            System.out.println(exm.j);            System.out.println(exm.k);       }  }   The program compiles, but when I run the program, the main method will print out two 0s. I know that in order to say that I want to initialize the instance variables in the constructor I have to write:  this.j = j; this.k = k;   But if I don't write it, then which variable is evaluated (or considered) in the constructor (on the left and on the write hand side of the expressions)? Is is the argument or the instance variable? Does it make a difference?  Are there other cases where the use of this is obligatory?
29529
I am a big fan of letting the compiler do as much work for you as possible.  When writing a simple class the compiler can give you the following for 'free':   A default (empty) constructor A copy constructor A destructor An assignment operator (operator=)   But it cannot seem to give you any comparison operators - such as operator== or operator!=.  For example:  class foo { public:     std::string str_;     int n_; };  foo f1;        // Works foo f2(f1);    // Works foo f3; f3 = f2;       // Works  if (f3 == f2)  // Fails { }  if (f3 != f2)  // Fails { }   Is there a good reason for this?  Why would performing a member-by-member comparison be a problem?  Obviously if the class allocates memory then you'd want to be careful, but for a simple class surely the compiler could do this for you?
24344
What are the C++ rules for calling the base class constructor from a derived class? For example, I know in Java, you must do it as the first line of the subclass constructor (and if you don't, an implicit call to a no-arg super constructor is assumed - giving you a compile error if that's missing).
37382
I'm a C++ guy learning Java. I'm reading Effective Java and something confused me. It says never to write code like this:  String s = new String("silly");   Because it creates unnecessary String objects. But instead it should be written like this:  String s = "No longer silly";   Ok fine so far...However, given this class:  public final class CaseInsensitiveString {     private String s;     public CaseInsensitiveString(String s) {         if (s == null) {             throw new NullPointerException();         }         this.s = s;     }     :     : }  CaseInsensitiveString cis = new CaseInsensitiveString("Polish"); String s = "polish";    Why is the first statement ok? Shouldn't it be   CaseInsensitiveString cis = "Polish"; How do I make CaseInsensitiveString behave like String so the above statement is OK (with and without extending String)? What is it about String that makes it OK to just be able to pass it a literal like that? From my understanding there is no "copy constructor" concept in Java?
37844
Is there a good reason why there is no Pair&lt;L,R&gt; in Java? What would be the equivalent of this C++ construct? I would rather avoid reimplementing my own.  It seems that 1.6 is providing something similar (AbstractMap.SimpleEntry&lt;K,V&gt;), but this looks quite convoluted.