An error means that the compiler is physically unable to deal with your code. A warning means that the compiler is capable of dealing with your code, but it believe that what you have written is wrong in some way. It seems pretty clear cut to me – it should be a warning. Besides, what … Read more
Eric Lippert discusses this here; firstly, it is incorrect that “value types are stored on the stack”. They sometimes are, but not as: fields on a class captured variables variables in an iterator block When they can be stored on the stack it is a convenient way of modelling their lifetime, but it isn’t required … Read more
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
Closely related questions (all taken by searching on [compiler] on stackoverflow): Learning Resources on Parsers, Interpreters, and Compilers Learning to write a compiler Constructing a simple interpreter … And similar topics (from the same search): Bootstrapping a language How much of the compiler should we know? Writing a compiler in its own language … Edit: … Read more
It’s a self documenting feature. It’s a way to make it possible to name a method “Class1” in some other class
Because if it was allowed, then it would not look good, and wouldn’t be as intuitive as its with reference. Suppose it is allowed, then you would write: struct A{}; A a, *pa, b; a = pa ;//doesn’t look good, also not intuitive. (not real C++) It doesn’t look good, because on left side you’ve … Read more
These are pretty tricky constructs, and it’s tough to give clear explanations; they aren’t as straightforward as Lisp macros (or, for that matter, the relationship between Lisp’s QUOTE and EVAL). However, there’s a good, lengthy discussion available in the form of notes from Robby Villegas’s 1999 talk “Unevaluated Expressions” on Wolfram’s website. Defer is omitted … Read more
This is in addition to Terry’s answer. The reason we had to make swap functions in C++ prior to 0x is because the general free-function std::swap was less efficient (and less versatile) than it could be. It made a copy of a parameter, then had two re-assignments, then released the essentially wasted copy. Making a … Read more
Regarding “Haskell’s equally powerful inference”, I don’t think Haskell has to deal with OO-style dynamic subtyping (type classes can do some similar stuff, but type classes are easier to type/infer) method overloading (type classes can do some similar stuff, but type classes are easier to type/infer) That is, I think F# has to deal with … Read more
I think to some extent it was probably an arbitrary decision based on typical use of switch. A switch can essentially be implemented in two ways (or in principle, a combination): for a small number of cases, or ones whose values are widely dispersed, a switch essentially becomes the equivalent of a series of ifs … Read more