Classes

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

C++

Compiler: GCC 4.0.2

 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
 };

Objective-C

Compiler: GCC 4.0.1 (apple)

The declaration:

@interface MyClass : NSObject
{
    /* member variables */
    int variable;
}

/* method declarations */
- init;
- (void)someMethod;

@end

The implementation:

@implementation MyClass
/* method implementations */

- init    /* designated constructor */
{
    if (self = [super init])
        variable = 0;
    return self;
}

- (void)someMethod
{
    variable = 1;
}

@end

A C function that uses the class:

void example()
{
    MyClass *mc = [[MyClass alloc] init];
    [mc someMethod];
    [mc release];	/* explicitly decrement reference count */
}

Perl

Interpreter: perl 5.8.6

The implementation (there are no declarations):

{
     # a class is a package (i.e. a namespace) with methods in it
    package MyClass;

     # a class method is a function that takes a class name as itself.
     # a constructor is a class method that returns a blessed object.
    sub new {
        my ($class) = @_;
        bless {variable => 0}, $class
         # the instance object is a hash in disguise.
         # (it can be any primitive type.)
    }

     # an instance method is a function that takes an object as itself.
    sub someMethod {
        my ($self) = @_;
        $$self{variable} = 1;
    }
}

Using the class:

$instance = new MyClass;      # indirect object syntax
$instance2 = MyClass->new;    # method syntax

$instance->someMethod;
 # instance deallocates when the last reference falls out of scope

Python

Interpreter: Python 2.5

class MyClass:
    name2 = 2 # Class attribute

    def __init__(self):
        """
        Constructor
        """
        self.name1 = 0 # Instance attribute
  
    def someMethod(self):
        """
        Method
        """
        self.name1 = 1
        MyClass.name2 = 3
  
  
myclass = MyClass()