0
"A class containing a static variable that stores a unique, and inaccesible
to external classes (private), intance of itself. The static variable is
accessed by a static method, with public access, usually called getIntance.
The static variable is initiated by the static getInstance method that
validates wether or not the static variable already exits. If the static
variable has not being initiated, a new instance of the class is created
and assigned to the static variable which reference is then returned by the
method. If the static variable was previously created, the method will
return a reference to the static variable." 1
A Singleton class is used when you wish to restrict instantiation of a class to only one object.
"Simple Singleton Pattern Example in AS3
class Data
{
private static var dataInstance:Data;
public static function getInstance():Data
{
if(!dataInstance) dataInstance = new Data();
return dataInstance;
}
public function Data()
{
if(dataInstance) throw Error("instance exists, please use Data.getInstance()");
}
}
" 2
1 [Daniel Guzman - AS3 Object Oriented Programming]
2 [Daniel Guzman - AS3 Object Oriented Programming]
Wiki User
∙ 13y ago
Wiki User
∙ 14y ago//Sample Code
public class SingleInstance {
private static SingleInstance ourInstance = new SingleInstance();
public static SingleInstance getInstance() {
if(null==ourInstance){
ourInstance= new SingleInstance();
}
return ourInstance;
}
private SingleInstance() {
}
}
Add your answer:
Earn +20 pts
How does member function of class define?
Static member functions (or static member methods) are local to the class in which they are declared but, unlike non-static member functions, they are not attached to any instance of the class. That is, they have no access to an implicit this pointer.Static member functions are often used to declare global functions in conjunction with private static member variables. The variables are not global as they are only accessible to the class itself, but because they are static they exist for the lifetime of the application.The best possible example of a static member function relates to singleton classes. A singleton class is typically a global class for which one instance (and one instance only) must be guaranteed to remain in scope for the entire duration of the program. A typical usage for such a class might be to enable logging (writing a log of all program activity), and we'd only need one logger.This means we must actively prevent new instances from being created once the first instance is created, and must ensure it cannot be destroyed while the program is active, intentionally or otherwise. In order to achieve this, the default constructor, the copy constructor and the assignment operator must be declared private with no implementation. This then means that only the class itself can instantiate the one and only instance of the class, and the only way to achieve that is with a static member function and a static member variable.The following demonstrates the skeleton of a singleton declaration. In a real-life singleton, you would design the remainder of the class just as you would an ordinary class, with instance variables and methods that permit it to carry out its role (whether as a logger or as some other global class for which only one instance is ever required). The example includes simple code to demonstrate its usage as a container for an int using dynamic memory.Note how the static variable Singleton::instance is initialised to NULL outside of the class declaration (at file scope). This ensures correct initialisation at compile time. This line is typically placed in the class cpp file (implementation file), while the class declaration itself is placed in the class hpp file (header). The one and only instance of the Singleton class is created upon the first call to Singleton::Instance(), which returns a reference to the instance thus permitting access to the instance members.Since the instance is static, it is guaranteed to remain in scope for the entire life-cycle of the program. It doesn't matter that the static Singleton::instance variable is instantiated dynamically but is never actually released. Since it is a static variable, the memory it points to will be released automatically when the program terminates. The same can also be said of the Singleton::instance->pointer member variable, but it's always good practice to release all non-static members in the private destructor.The design is such that it would be impossible to inadvertently create two or more instances of the Singleton class, and impossible to destroy the one and only instance until the program terminates.While there are many other examples of static member functions, the majority merely demonstrate usage that could be far better implemented as a non-static member function or even a friend function. Demonstrations of any practical merit are few and far between (although they do exist), but the Singleton usage is by far the most ingenious and practical usage you will encounter. Microsoft may not agree (a Microsoft singleton isn't strictly a singleton), but the framework shown below is tried and tested, is robust, and does exactly what it says on the tin!#include using namespace std;class Singleton{private:Singleton():pointer(new int(100)){} // No creation outside the class.Singleton(Singleton const&){} // No copying outside the class.Singleton& operator=(Singleton const&){} // No assignment outside the class.~Singleton(){delete(pointer);} // No destruction outside the class.static Singleton* instance; // The only instance there can ever be.int * pointer; // Dynamic memory allocation (for illustrative purpose).public:// Static member function:static Singleton& Instance(){if( !instance ) // Creates the instance on first usage only.instance = new Singleton();VERIFY(instance != NULL); // Not essential, but prudent.return(*instance);}// A member function (for illustrative purposes).void foo(void){cout
Subclasses of an abstract class that do not provide an implementation of an abtract method are also abstract?
Yes. Any class that does not provide implementation to all its methods as well as its parent class methods needs to be Abstract. The Java compiler would not successfully compile a class that does not do this.
Does separation of interface from implementation within classes provide advantage?
Yes, it helps both the users and the maintainers of your class. Users are generally only interested the class interface (how to interact with the class), so by separating the implementation you do not distract the user with any unnecessary implementation details. Conversely, maintainers are more concerned with the implementation than the interface. By keeping the two separate, maintainers are much less likely to break any code that uses the class.
What is the recent public implementation of Java?
Apache Harmony is the recent open source implementation of the Java runtime with class libraries and associated tools.
What is the major difference in class and interface in c?
The implementation detail. Classes may provide a default implementation, interfaces provide only the method signatures
How do you make a class as singleton. Explain with a example?
/** * @author lalatendu puhan * */ class TestSingleton { // Singleton implementation private static TestSingleton testSingleton = null; /** * Default contructor, with singleton implementation */ private TestSingleton() { } /** * I return the singleton instance . * @return */ public static TestSingleton getSingleton() { if(null == testSingleton) testSingleton = new TestSingleton(); return testSingleton; } } to access this /** * @author Lalatendu puhan * */ public class AccessSingleton { TestSingleton mSingleton; public void getSingletonObj() { mSingleton = TestSingleton.getSingleton(); } public static void main(String[] args) { AccessSingleton obj1 = new AccessSingleton(); obj1.getSingletonObj(); } }
What are the features and purpose of an abstract method?
abstract means nothing to implement its responsible of implementation its implementation class
How does member function of class define?
Static member functions (or static member methods) are local to the class in which they are declared but, unlike non-static member functions, they are not attached to any instance of the class. That is, they have no access to an implicit this pointer.Static member functions are often used to declare global functions in conjunction with private static member variables. The variables are not global as they are only accessible to the class itself, but because they are static they exist for the lifetime of the application.The best possible example of a static member function relates to singleton classes. A singleton class is typically a global class for which one instance (and one instance only) must be guaranteed to remain in scope for the entire duration of the program. A typical usage for such a class might be to enable logging (writing a log of all program activity), and we'd only need one logger.This means we must actively prevent new instances from being created once the first instance is created, and must ensure it cannot be destroyed while the program is active, intentionally or otherwise. In order to achieve this, the default constructor, the copy constructor and the assignment operator must be declared private with no implementation. This then means that only the class itself can instantiate the one and only instance of the class, and the only way to achieve that is with a static member function and a static member variable.The following demonstrates the skeleton of a singleton declaration. In a real-life singleton, you would design the remainder of the class just as you would an ordinary class, with instance variables and methods that permit it to carry out its role (whether as a logger or as some other global class for which only one instance is ever required). The example includes simple code to demonstrate its usage as a container for an int using dynamic memory.Note how the static variable Singleton::instance is initialised to NULL outside of the class declaration (at file scope). This ensures correct initialisation at compile time. This line is typically placed in the class cpp file (implementation file), while the class declaration itself is placed in the class hpp file (header). The one and only instance of the Singleton class is created upon the first call to Singleton::Instance(), which returns a reference to the instance thus permitting access to the instance members.Since the instance is static, it is guaranteed to remain in scope for the entire life-cycle of the program. It doesn't matter that the static Singleton::instance variable is instantiated dynamically but is never actually released. Since it is a static variable, the memory it points to will be released automatically when the program terminates. The same can also be said of the Singleton::instance->pointer member variable, but it's always good practice to release all non-static members in the private destructor.The design is such that it would be impossible to inadvertently create two or more instances of the Singleton class, and impossible to destroy the one and only instance until the program terminates.While there are many other examples of static member functions, the majority merely demonstrate usage that could be far better implemented as a non-static member function or even a friend function. Demonstrations of any practical merit are few and far between (although they do exist), but the Singleton usage is by far the most ingenious and practical usage you will encounter. Microsoft may not agree (a Microsoft singleton isn't strictly a singleton), but the framework shown below is tried and tested, is robust, and does exactly what it says on the tin!#include using namespace std;class Singleton{private:Singleton():pointer(new int(100)){} // No creation outside the class.Singleton(Singleton const&){} // No copying outside the class.Singleton& operator=(Singleton const&){} // No assignment outside the class.~Singleton(){delete(pointer);} // No destruction outside the class.static Singleton* instance; // The only instance there can ever be.int * pointer; // Dynamic memory allocation (for illustrative purpose).public:// Static member function:static Singleton& Instance(){if( !instance ) // Creates the instance on first usage only.instance = new Singleton();VERIFY(instance != NULL); // Not essential, but prudent.return(*instance);}// A member function (for illustrative purposes).void foo(void){cout
Subclasses of an abstract class that do not provide an implementation of an abtract method are also abstract?
Yes. Any class that does not provide implementation to all its methods as well as its parent class methods needs to be Abstract. The Java compiler would not successfully compile a class that does not do this.
Does separation of interface from implementation within classes provide advantage?
Yes, it helps both the users and the maintainers of your class. Users are generally only interested the class interface (how to interact with the class), so by separating the implementation you do not distract the user with any unnecessary implementation details. Conversely, maintainers are more concerned with the implementation than the interface. By keeping the two separate, maintainers are much less likely to break any code that uses the class.
What is the recent public implementation of Java?
Apache Harmony is the recent open source implementation of the Java runtime with class libraries and associated tools.
What is the major difference in class and interface in c?
The implementation detail. Classes may provide a default implementation, interfaces provide only the method signatures
What is singleton in c plus plus?
A singleton is a class of object from which only one instance of the object can be instantiated within your program. They are generally used to store global variables or to provide some common functionality, such as an application log. They are generally frowned upon because of their global nature, but when you need common functionality there are far worse ways of going about it than with a singleton. There are several design patterns for a singleton, but probably the simplest and most common form is shown below. Note the private constructors and assignment operator, and the static member method containing a static variable -- the only instance of the class that can ever exist. Access to the members (not shown) is via a static call: CSingleton::Instance().<member> class CSingleton { private: CSingleton() {}; // Prevent construction outside of the class. CSingleton(const CSingleton&); // Prevent copy-construction. CSingleton& operator=(const CSingleton&); // Prevent assignment. public: static CSingleton& Instance() { static CSingleton singleton; // Created on first access. // Destroyed on application exit. return( singleton ); } // Specific members omitted. Dependant upon purpose of singleton. };
What is the birth name of IronE Singleton?
IronE Singleton's birth name is Robert Singleton.
What is the birth name of Doris Singleton?
Doris Singleton's birth name is Dorthea Singleton.
Can you define the constructor as private?
Yes, you can. Making a constructor private ensures that no other class can instantiate that class you just created with a private constructor. It is usually used in Singleton Patterns.
What is the birth name of Alshermond Singleton?
Alshermond Singleton's birth name is Alshermond Glendale Singleton.
