This looks like the non-singleton version of the module pattern, whereby private variables can be simulated by taking advantage of JavaScript’s “closures”. I like it (kinda…). But I don’t really see the advantage in private variables done in this way, especially when it means that any new methods added (after initialisation) do not have access … Read more
In the context of a class, static variables are on the class scope (not the object) scope, but unlike a const, their values can be changed. class ClassName { static $my_var = 10; /* defaults to public unless otherwise specified */ const MY_CONST = 5; } echo ClassName::$my_var; // returns 10 echo ClassName::MY_CONST; // returns … Read more
You’re misquoting the book (at least the 2nd edition). Jeffrey Richter states value types can be more than 16 bytes if: You don’t intend to pass them to other methods or copy them to and from a collection class. Additionally Eric Gunnerson adds (regarding the 16 byte limit) Use this guideline as a trigger to … Read more
The first one is better Even better is C++0x ‘delete’ keyword: class Class { // useful stuff, then public: Class(const Class&) = delete; void operator=(const Class&) = delete; };
I would use an array of T, a head and tail pointer, and add and get methods. Like: (Bug hunting is left to the user) // Hijack these for simplicity import java.nio.BufferOverflowException; import java.nio.BufferUnderflowException; public class CircularBuffer<T> { private T[] buffer; private int tail; private int head; @SuppressWarnings(“unchecked”) public CircularBuffer(int n) { buffer = (T[]) … Read more
You can’t. The next best thing you can do is have using declarations in the files that use the class. For example, you could rewrite the dependent code using an import alias (as a quasi-typedef substitute): using ColorScheme = The.Fully.Qualified.Namespace.Outlook2007ColorScheme; Unfortunately this needs to go into every scope/file that uses the name. I therefore don’t … Read more
If you define a class without any constructor, the compiler will synthesize a constructor for you (and that will be a default constructor — i.e., one that doesn’t require any arguments). If, however, you do define a constructor, (even if it does take one or more arguments) the compiler will not synthesize a constructor for … Read more
it solves this concrete problem: you have a, b, c, d of 4 different types. all over your code you have something like: a.Process(); b.Process(); c.Process(); d.Process(); why not have them implement IProcessable, and then do List<IProcessable> list; foreach(IProcessable p in list) p.Process(); this will scale much better when you add, say, 50 types of … Read more
This is a bit of a tangent based on the response by “Mitch Wheat”. Generally, anytime I see people cite the framework design guidelines, I always like to mention that: You should generally ignore the framework design guidelines most of the time. This isn’t because of any issue with the framework design guidelines. I think … Read more
Use __new__ when you need to control the creation of a new instance. Use __init__ when you need to control initialization of a new instance. __new__ is the first step of instance creation. It’s called first, and is responsible for returning a new instance of your class. In contrast, __init__ doesn’t return anything; it’s only … Read more