factory-pattern

What does typedef Class *(createClassFunction)(void) (or another variation is typedef Class* (__stdcall *CreateClassFunction)(void) )stand for? What does it mean? How am I supposed to explain it? Especially in the context of Factory Patterns... Reading C type expressions createClassFunction is a typedef for a function taking no arguments and returning a Class * . With that declaration, a pointer to such a funciton can obviously act as factory for a Class . Usage might be as follows: // the class factory Class * MostTrivialFactoryKnownToMan() { return new Class; } // another class factory Class

I was looking through many approaches to implement a Factory pattern in Java and still couldn't find a perfect one which doesn't suffer from both if/switch plus doesn't use reflection. One of the best that I found was inside Tom Hawtin's answer here: https://stackoverflow.com/a/3434505/1390874 But my biggest concern is that it stores a HashMap of Anonymous classes in a memory. The question is what do people think about using Class.newInstance() in addition to Tom Hawtin's answer? This will avoid us from storing unnecessary anonymous classes in memory? Plus code will be more clean. It will look

Below is an article about .net framework's use of patterns. I'm not sure I understand the bolded part in the excerpt below. Is it implying if you change the details of creating the object, you (might) change the constructor arguments? There are many cases in the Framework where you can obtain a new instance of a struct or class without calling its constructor yourself. The System.Convert class contains a host of static methods that work like this. To convert an integer to a Boolean, for example, you can call Convert.ToBoolean and pass in the integer. The return value of this method call is a

This pattern uses an abstract factory, and then an implementation of the factory. I am sure there is a standard naming convention for these two classes, but I don't know what it is. For example: public abstract class ChocolateFactory { }; public class MyChocolateFactory { } : ChocolateFactory What's the standard convention here? I'm thinking either ChocolateFactoryBase, or ConcreteChocolateFactory, but perhaps there is something else (much like Enums tend to be suffixed with Enum, e.g. PetTypeEnum so that you can do PetTypeEnum PetType; Hopefully this isn't subjective. The question and the

I am using ASP.NET Core, I know that such Logging mechanism is already provided by the framework, but using this to illustrate my problem. I am using kind of Factory pattern to build the Logger class, since I don't know the type of logging (because it is stored in DB). The ILogger Contract Log(string msg) Then LoggerFactory will return an ILogger after creating a Logger based on param passed from DB: public class LoggerFactory { public static Contracts.ILogger BuildLogger(LogType type) { return GetLogger(type); } //other code is omitted, GetLogger will return an implementation of the related