lazy-initialization

This question already has answers here : When to use lazy instantiation in iOS? (4 answers) Closed 5 years ago . Why does the course at Stanford use the lazy initialization for all getters? Is this correct? Does it have any real advantage? One advantage (for me) is that the init method can become much shorter and you need not check if a variable is allocated. The idea is to load resources on demand. This way everything loads faster and when needed. In the cases it's not used, it doesn't allocate additional memory. 来源： https://stackoverflow.com/questions/21764666/why-do-the-courses-at-stanford

Say I have this: int x; int x = (State Determined By Program); const char * pArray[(const int)x]; // ?? How would I initialize pArray before using it? Because the initial size of the Array is determined by user input Thanks! You cannot initialize an array at compile-time if you are determining the size at run-time. But depending on what you are trying to do, a non-const pointer to const data may provide you with what you're going for. const char * pArray = new const char[determine_size()]; A more complete example: int determine_size() { return 5; } const char * const allocate_a( int size ) {

I usually lazy instantiate my @property objects in their getter methods like this: @interface MyGenericClass : UIViewController @property(nonatomic, readonly) UIImageView *infoImageView // ... @implementation GenericClass - (UIImageView *)infoImageView { if (!_infoImageView) { _infoImageView = [[UIImageView alloc]initWithImage:[UIImage imageNamed:@"PlaceholderInfoImage"]]; } return _infoImageView; } But when subclassing, I would often like to override some of the @properties to be more subclass specific. So I'd like to change the instantiation and do something like: @interface

Below are two ways to implement a singleton. What are the advantages and disadvantages of each? Static initialization: class Singleton { private Singleton instance; static { instance = new Singleton(); } public Singleton getInstance() { return instance; } } Lazy initialization is: class Singleton { private Singleton instance; public Singleton getInstance(){ if (instance == null) instance = new Singleton(); return instance; } } Alexander Synchronized Accessor public class Singleton { private static Singleton instance; public static synchronized Singleton getInstance() { if (instance == null) {

I've been using the gcc const and pure attributes for functions which return a pointer to "constant" data that's allocated and initialized on the first use, i.e. where the function will return the same value each time it's called. As an example (not my usage case, but a well-known example) think of a function that allocates and computes trig lookup tables on the first call and just returns a pointer to the existing tables after the first call. The problem: I've been told this usage is incorrect because these attributes forbid side effects, and that the compiler could even optimize out the call

What is the difference between a Lazy or Optional property in Swift? For example, if someone is building a navigation bar that comes in from the side, I think that should all be within one UIViewController . The user might never open the menu but sometimes they will. var menu: NavigationBar? lazy var menu: NavigationBar = NavigationBar.initialize() Both of the optional I think are good code, because they don't create the view unless its needed. I understand Optional means there might be a value it might be nil . I also understand Lazy means don't worry about it until I need it. Specific

I was reading the section on Lazyness [sic] over at Twitter's Effective Scala page, which includes this suggestion (emphasis is mine): Use lazy fields for this purpose [computing and caching values on-demand], but avoid using lazyness when lazyness is required by semantics . In these cases it's better to be explicit since it makes the cost model explicit, and side effects can be controlled more precisely. I don't understand why they would make this claim. Why would it be better to avoid using the lazy keyword for cases when laziness is required by the semantics (meaning that it's necessary for