C++: Classes

In object-oriented programming class is a set (a transitive closure) of types bound by the relation of inheritance. It is said that all types derived from some base type T and the type T itself form a class T. The first type T from the class T sometimes is called the root type of the class.

A class of types itself, as a type, has the values and operations of its own. The operations of are usually called methods of the root type. Both operations and values are called polymorphic.

A polymorphic operation (method) selects an implementation depending on the actual specific type of the polymorphic argument. The action of choice the type-specific implementation of a polymorphic operation is called dispatch. Correspondingly, polymorphic operations are often called dispatching or virtual. Operations with multiple arguments and/or the results of the class are called multi-methods. A further generalization of is the operation with arguments and/or results from different classes.

• single-dispatch languages are those that allow only one argument or result to control the dispatch. Usually it is the first parameter, often hidden, so that a prefix notation x.f() is used instead of mathematical f(x).
• multiple-dispatch languages allow many arguments and/or results to control the dispatch.

A polymorphic value has a type tag indicating its specific type from the class and the corresponding specific value of that type. This type is sometimes called the most specific type of a [polymorphic] value. The type tag of the value is used in order to resolve the dispatch. The set of polymorphic values of a class is a transitive closure of the sets of values of all types from that class.

In many OO languages the type of the class of T and T itself are considered equivalent. In some languages they are distinct (like in Ada). When class T and T are equivalent, there is no way to distinguish polymorphic and specific values.

The purpose of this task is to create a basic class with a method, a constructor, an instance variable and how to instantiate it.

class MyClass
{
public:
	void someMethod(); // member function = method
	MyClass(); // constructor
private:
	int variable; // member variable = instance variable
};

// implementation of constructor
MyClass::MyClass():
variable(0)
{
	// here could be more code
}

// implementation of member function
void MyClass::someMethod()
{
	variable = 1; // alternatively: this->variable = 1
}

// Create an instance as variable
MyClass instance;

// Create an instance on free store
MyClass* pInstance = new MyClass;
// Instances allocated with new must be explicitly destroyed when not needed any more:
delete pInstance;

Note: MyClass instance(); would not define an instance, but declare a function returning an instance. Accidentally declaring functions when object definitions are wanted is a rather common bug in C++.

Functions can also be defined inline:

class MyClass
{
public:
	MyClass(): variable(0) {}
	void someMethod() { variable = 1; }
private:
	int variable;
};

Note that member functions in C++ by default are not polymorphic; if you want a polymorphic member function, you have to mark it as virtual. In that case, you should also add a virtual destructor, even if that is empty. Example:

class MyClass
{
public:
	virtual void someMethod(); // this is polymorphic
	virtual ~MyClass(); // destructor
};

SOURCE

Content is available under GNU Free Documentation License 1.2.