Classes

Classes
You are encouraged to solve this task according to the task description, using any language you may know.

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

Ada

Class is used in many languages to provide both encapsulation, or grouping of data and actions, and also as type definition. Ada packages provide encapsulation or grouping while type definitions are done using the type reserved word. Types participating in inheritance are named tagged record types.

A package specification has the following form:

package My_Package is
   type My_Type is tagged private;
   procedure Some_Procedure(Item : out My_Type);
   function Set(Value : in Integer) return My_Type;
private
   type My_Type is tagged record
      Variable : Integer := -12;
   end record;
end My_Package;

The type declaration at the top of the package gives public visibility to the private tagged type My_Type. Since My_Type is declared to be private the public has no visibility to its structure. The type must be treated as a black box. The private section of the package specification includes the actual tagged record definition. Note that the data member Variable is initialized to -12. This corresponds to a default constructor for the type.

The package body must contain the implementation of the procedures and functions declared in the package specification.

package body My_Package is
   procedure Some_Procedure(Item : out My_Type) is
   begin
      Item := 2 * Item;
   end Some_Procedure;

   function Set(Value : Integer) return My_Type is
      Temp : My_Type;
   begin
      Temp.Variable := Value;
      return Temp;
   end Set;

end My_Package; The Set function acts as a conversion constructor for My_Type.

An instance is typically created outside the package:

with My_Package; use My_Package;

procedure Main is
   Foo : My_Type; -- Foo is created and initialized to -12
begin
   Some_Procedure(Foo); -- Foo is doubled
   Foo := Set(2007); -- Foo.Variable is set to 2007
end Main;

BASIC

Compiler: QBasic 4.5

 DECLARE SUB MyClassDelete (pthis AS MyClass)
 DECLARE SUB MyClassSomeMethod (pthis AS MyClass)
 DECLARE SUB MyClassInit (pthis AS MyClass)

 TYPE MyClass
   Variable AS INTEGER
 END TYPE

 DIM obj AS MyClass
 MyClassInit obj
 MyClassSomeMethod obj

 SUB MyClassInit (pthis AS MyClass)
   pthis.Variable = 0
 END SUB

 SUB MyClassSomeMethod (pthis AS MyClass)
   pthis.Variable = 1
 END SUB

C

Compiler: GCC 4.0.2

 typedef struct MyClass
 {
   int variable;
 } MyClass;

 struct MyClass*  MyClass_new()
 {
   struct MyClass* pthis = (struct MyClass*)malloc( sizeof(struct MyClass) );
   //memset(pthis, 0, sizeof(struct MyClass) );
   pthis->variable = 0;
   return pthis;
 }

 void MyClass_delete(struct MyClass** pthis)
 {
   if(pthis && *pthis)
   {
     free(*pthis);
     *pthis = NULL;
   }
 }

 struct void MyClass_someMethod(struct MyClass* pthis)
 {
   pthis->variable = 1;
 }

 struct MyClass* obj = MyClass_new();
 MyClass_someMethod(obj);
 MyClass_delete(&obj);

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 */
}

Forth

Interpreter: WinForth

ANSI Forth has no object oriented features, but as Forth is a very easy language to extend, many object oriented programming systems have been implemented for it over the years. WinForth has one such system, which is described here.

Declare a class

:class MyClass <super Object

  int memvar

  :m ClassInit: ( -- )
       ClassInit: super
       1 to memvar ;m

  :m ~: ( -- )  ." Final " show: [ Self ] ;m

  :m set: ( n -- )  to memvar ;m
  :m show: ( -- ) ." Memvar = " memvar . ;m

;class

Allocate a static object

MyClass newInstance

Allocate a dynamic object, saving its pointer in a global variable.

New> MyClass  value newInstance

Call member functions

10 set: newInstance
show: newInstance

Free a dynamically allocated object

newInstance dispose
0 to newInstance   \ no dangling pointers!

Example of dynamic allocation and local variable use"

: test { \ obj -- }
    New> MyClass to obj
      show: obj
      1000 set: obj
    obj dispose ;

Java

Platform: J2SE/

 public class MyClass {
 
   // instance variable
   private int variable;  // Note: instance variables are usually "private"
 
   /**
   * The constructor
   */
   public MyClass() {
     // creates a new instance
   }
 
   /**
   * A method
   */
   public void someMethod() {
    this.variable = 1; // Note: "this." is optional
                       // variable = 1; works also
   }
 }

JavaScript

Interpreter: Firefox 2.0

//constructor
function MyClass(initVal) {
    //instance variable
    if(initVal == undefined) {
        this.number = 1;
    }
    else {
        this.number = initVal;
    }
}

//method of MyClass
MyClass.prototype.getDouble = function() {
    return this.number * 2;
};

var instance1 = new MyClass; //or "new MyClass();"
instance1.number = 5;
alert( instance1.getDouble() ); //10

var instance2 = new MyClass(3);
alert( instance2.getDouble() ); //6

Oberon-2

Compiler: OO2C 2.1.11

MODULE M;

   TYPE
      T = POINTER TO TDesc;
      TDesc = RECORD
         x: INTEGER
      END;

   PROCEDURE New*(): T;
      VAR t: T;
   BEGIN
      NEW(t); t.x := 0;
      RETURN t
   END New;


   PROCEDURE (t: T) Increment*;
   BEGIN
      INC(t.x)
   END Increment;

END M.

Exported procedures are marked with an asterisk (*). There is nothing special about the constructor New, it is just a function that returns a new object of type T. The name of the method receiver can also be chosen freely. INC is a predeclared procedure that increments its argument.

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()

for new-style classes (correct me if i'm wrong), in order to make good use of properties, class methods and the like :

class MyClass(object):
    ...

Ruby

class MyClass
  @@classVar
  def initialize
    @instanceVar = 0
  end
  def someMethod
    @instanceVar = 1
    @@classVar = 3
  end
end
myclass = MyClass.new

Turbo Pascal

Note: This is not part of standard Pascal, but Turbo Pascal specific Compiler: Turbo Pascal 6.0

type
 MyClass = object
            variable: integer;
            constructor init;
            destructor done;
            procedure someMethod;
           end;

constructor MyClass.init;
 begin
  variable := 0;
 end;

procedure MyClass.someMethod;
 begin
  variable := 1;
 end;

var
 instance: MyClass; { as variable }
 pInstance: ^MyClass; { on free store }

begin
 { create instances }
 instance.init;
 new(pInstance, init); { alternatively: pInstance := new(MyClass, init); }
 
 { call method }
 instance.someMethod;
 pInstance^.someMethod;
 
 { get rid of the objects }
 instance.done;
 dispose(pInstance, done);
end;