Compound data type: Difference between revisions

From Rosetta Code
Content added Content deleted
m (Spelling/grammar/aesthetics.)
m (Changed over to works with template)
Line 34: Line 34:


=={{header|BASIC}}==
=={{header|BASIC}}==
'''Interpeter:''' [[QuickBasic]] 4.5, PB 7.1
{{works with|QuickBasic|4.5}}
{{works with|PB|7.1}}
TYPE Point
TYPE Point
x AS INTEGER
x AS INTEGER
Line 41: Line 42:


=={{header|C}}==
=={{header|C}}==
{{works with|GCC}}
'''Compiler:''' GCC, MSVC, BCC, Watcom
{{works with|MSVC}}
{{works with|BCC}}
{{works with|Watcom}}


'''Libraries:''' Standard
'''Libraries:''' Standard
Line 52: Line 56:


=={{header|C++}}==
=={{header|C++}}==
{{works with|g++}}
'''Compiler:''' [[g++]], [[Visual C++]], [[BCC]], [[Watcom]]
{{works with|Visual C++}}
{{works with|BCC}}
{{works with|Watcom}}


struct Point
struct Point
Line 118: Line 125:


=={{header|Forth}}==
=={{header|Forth}}==
{{works with|GNU Forth|0.6.2}}

There is no standard structure syntax in Forth, but it is easy to define words for creating and accessing data structures.
There is no standard structure syntax in Forth, but it is easy to define words for creating and accessing data structures.


Line 128: Line 135:
7 point pt>y !
7 point pt>y !
.pt \ 6 7
.pt \ 6 7
'''Interpreter:''' GNU Forth 0.6.2


Some Forths have mechanisms for declaring complex structures. For example, GNU Forth uses this syntax:
Some Forths have mechanisms for declaring complex structures. For example, GNU Forth uses this syntax:
Line 185: Line 190:


=={{header|Java}}==
=={{header|Java}}==

// The byte structure format does not exist natively --> TODO.
public class Point
public class Point
{
{
Line 226: Line 229:


=={{header|OpenEdge/Progress}}==
=={{header|OpenEdge/Progress}}==



The temp-table is a in memory database table. So you can query sort and iterate it, but is the data structure that comes closest.
The temp-table is a in memory database table. So you can query sort and iterate it, but is the data structure that comes closest.
Line 238: Line 240:


=={{header|Perl}}==
=={{header|Perl}}==
'''Interpreter:''' [[Perl]] 5.x
{{works with|Perl|5.x}}

This is a hash (associative array), but accomplishes the task.
This is a hash (associative array), but accomplishes the task.
my %point = (
my %point = (
Line 268: Line 269:


=={{header|Python}}==
=={{header|Python}}==

'''Interpreter:''' [[Python]]


The simplest way it to use a tuple, or a list if it should be mutable:
The simplest way it to use a tuple, or a list if it should be mutable:

Revision as of 02:28, 19 February 2008

Task
Compound data type
You are encouraged to solve this task according to the task description, using any language you may know.

Data Structure
This illustrates a data structure, a means of storing data within a program.

You may see other such structures in the Data Structures category.

Create a compound data type Point(x,y).

A compound data type is one that holds multiple independent values. See also Enumeration.

Ada

Tagged Type

Ada tagged types are extensible through inheritance. The reserved word tagged causes the compiler to create a tag for the type. The tag identifies the position of the type in an inheritance hierarchy.

type Point is tagged record
   X : Integer := 0;
   Y : Integer := 0;
end record;

Record Type

Ada record types are not extensible through inheritance. Without the reserved word tagged the record does not belong to an inheritance hierarchy.

type Point is record
   X : Integer := 0;
   Y : Integer := 0;
end record;

Parameterized Types

An Ada record type can contain a discriminant. The discriminant is used to choose between internal structural representations. Parameterized types were introduced to Ada before tagged types. Inheritance is generally a cleaner solution to multiple representations than is a parameterized type.

type Person (Gender : Gender_Type) is record
   Name   : Name_String;
   Age    : Natural;
   Weight : Float;
   Case Gender is
      when Male =>
         Beard_Length : Float;
      when Female =>
         null;
   end case;
end record;

In this case every person will have the attributes of gender, name, age, and weight. A person with a male gender will also have a beard length.

BASIC

Works with: QuickBasic version 4.5
Works with: PB version 7.1
TYPE Point
  x AS INTEGER
  y AS INTEGER
END TYPE

C

Works with: GCC
Works with: MSVC
Works with: BCC
Works with: Watcom

Libraries: Standard

 typedef struct Point
 {
   int x;
   int y;
 } Point;

C++

Works with: g++
Works with: Visual C++
Works with: BCC
Works with: Watcom
 struct Point
 {
   int x;
   int y;
 };

It is also possible to add a constructor (this allows the use of Point(x, y) in expressions):

 struct Point
 {
   int x;
   int y;
   Point(int ax, int ay): x(ax), y(ax) {}
 };

Point can also be parametrized on the coordinate type:

 template<typename Coordinate> struct point
 {
   Coordinate x, y;
 };
 
 // A point with integer coordinates
 Point<int> point1 = { 3, 5 };
 
 // a point with floating point coordinates
 Point<float> point2 = { 1.7, 3.6 };

Of course, a constructor can be added in this case as well.

C#

 struct Point
 {
   public int x, y;
   public Point(int x, int y) {
     this.x = x;
     this.y = y;
   }
 }

Clean

Record type

:: Point = { x :: Int, y :: Int }

Parameterized Algebraic type

:: Point a = Point a a  // usage: (Point Int)

Synonym type

:: Point :== (Int, Int)

Common Lisp

(defstruct point x y)

E

def makePoint(x, y) {
    def point {
        to getX() { return x }
        to getY() { return y }
    }
    return point
}

Forth

Works with: GNU Forth version 0.6.2

There is no standard structure syntax in Forth, but it is easy to define words for creating and accessing data structures.

: pt>x ( point -- x ) ;
: pt>y ( point -- y ) CELL+ ;
: .pt ( point -- ) 2@ . . ;

create point 6 , 0 ,
7 point pt>y !
.pt    \ 6 7

Some Forths have mechanisms for declaring complex structures. For example, GNU Forth uses this syntax:

struct
  cell% field pt>x
  cell% field pt>y
end-struct point%

Haskell

Tagged Type

 data Point = Point Integer Integer
 instance Show Point where
     show (Point x y) = "("++(show x)++","++(show y)++")"
 p = Point 6 7

Record Type

data Point = Point { x :: Integer, y :: Integer } 
deriving (Eq, Show)

The deriving clause here provides default instances for equality and conversion to string.

Different equivalent ways of constructing a point:

p  = Point 2 3
p' = Point { x=4, y=5 }

Tuple Type

The declared type is a type synonym.

type Point = (2,3)

p = (2,3)

Discriminated Type

data Person =
    Male   { name :: String, age :: Integer, weight :: Double, 
             beard_length :: Double }
  | Female { name :: String, age :: Integer, weight :: Double }
  deriving (Eq, Show)

Note that the field names may be identical in alternatives.

IDL

point = {x: 6 , y: 0 } 
point.y = 7
print, point
;=> {       6       7}

Java

public class Point
{
  public int x, y;
  public Point() { this(0); }
  public Point(int x0) { this(x0,0); }
  public Point(int x0, int y0) { x = x0; y = y0; }

  public static void main(String args[])
  {
    Point point = new Point(1,2);
    System.out.println("x = " + point.x );
    System.out.println("y = " + point.y );
  }
}

JavaScript

 var point = new Object();
 point.x = 1;
 point.y = 2;

JSON

 var point = {
   x:1,
   y:2
 };

MAXScript

Point is a built-in object type in MAX, so...

struct myPoint (x, y)
newPoint = myPoint x:3 y:4

In practice however, you'd use MAX's built in Point2 type

newPoint = Point2 3 4

OCaml

 type point = < x: int; y: int >

OpenEdge/Progress

The temp-table is a in memory database table. So you can query sort and iterate it, but is the data structure that comes closest.

 def temp-table point
   field x as int
   field y as int
   .

Another option would be a simple class.

Perl

Works with: Perl version 5.x

This is a hash (associative array), but accomplishes the task.

my %point = ( 
   x => 3,
   y => 8
);

PHP

 # Using pack/unpack 
 $point = pack("ii", 1, 2);
 $u = unpack("ix/iy", $point);
 echo $x;
 echo $y;
 list($x,$y) = unpack("ii", $point);
 echo $x;
 echo $y;

Pop11

uses objectclass;
define :class Point;
   slot x = 0;
   slot y = 0;
enddefine;

Python

The simplest way it to use a tuple, or a list if it should be mutable:

X, Y = 0, 1
p = (3, 4)
p = [3, 4]

print p[X]

If needed, you can use class:

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

p = Point()
print p.x

One could also simply instantiate a generic object and "monkeypatch" it:

point = object()
point.x, point.y = 0, 1

Ruby

 Point = Struct.new(:x,:y)
 p = Point.new(6,7)
 p.y=3
 puts p
 => #<struct Point x=6, y=3>

Scheme

(define (make-point x y)
  (cons x y))

(define (point-x point)
  (car point))

(define (point-y point)
  (cdr point))

Tcl

This appears to be a sub-functionality of a proper associative array:

 array set point {x 4 y 5}
 set point(y) 7
 puts "Point is {$point(x),$point(y)}"
 # => Point is {4,7}