class-design

Those of us who have seen the beauty of STL try to use it as much as possible, and also encourage others to use it wherever we see them using raw pointers and arrays . Scott Meyers have written a whole book on STL, with title Effective STL . Yet what happened to the developers of ifstream that they preferred char* over std::string . I wonder why the first parameter of ifstream::open() is of type const char* , instead of const std::string & . Please have a look at it's signature: void open(const char * filename, ios_base::openmode mode = ios_base::in ); Why this? Why not this: void open(const

I've noticed a variety of @interface declarations for Objective-c classes. I'd like to understand why developers declare @interface in the following ways: // in the .h file @interface MyClass : NSObject // ... @end // in the .m file (what's the purpose of the parens?) @interface MyClass () // more property declarations which seem like they can go in the .h file @end // again in the .m file (what's the purpose of private?) @interface MyClass (Private) // some method declarations @end This is just a normal class interface , inheriting from NSObject, where you declare ivars, properties and

My questions are: When should we use value types and when reference types? What are the advantages and disadvantages of one over other? What if one uses reference types everywhere? Is there any harm in it? Please also discuss advantages and disadvantages of each one. I want to understand that as well. Repo Man There seems to be a lot of confusion over this, and Jon Skeet does a good job of clearing it up in his book "C# In Depth, 2nd Ed." (section 2.3). My personal approach, which may or may not be right, is to ONLY use structs/enumerations (value types) to represent lightweight, atomic data

When should i make a function private and why is it good idea? You should make a function private when you don't need other objects or classes to access the function, when you'll be invoking it from within the class. Stick to the principle of least privilege , only allow access to variables/functions that are absolutely necessary. Anything that doesn't fit this criteria should be private . I usually make the helper functions private . But what is helper seems to be vague. So let me give you an example. Suppose you've the following class Sample ; it exposes few public functions, one of them,

There is a Checkstyle rule DesignForExtension . It says: if you have a public/protected method which is not abstract nor final nor empty it is not "designed for extension". Read the description for this rule on the Checkstyle page for the rationale. Imagine this case. I have an abstract class which defines some fields and a validate method for those fields: public abstract class Plant { private String roots; private String trunk; // setters go here protected void validate() { if (roots == null) throw new IllegalArgumentException("No roots!"); if (trunk == null) throw new

I encountered a strange bug in python where using the __new__ method of a class as a factory would lead to the __init__ method of the instantiated class to be called twice. The idea was originally to use the __new__ method of the mother class to return a specific instance of one of her children depending on the parameters that are passed, without having to declare a factory function outside of the class. I know that using a factory function would be the best design-pattern to use here, but changing the design pattern at this point of the project would be costly. My question hence is: is there