class                  package:base                  R Documentation

Object Classes

Description:

     R possesses a simple generic function mechanism which can be used
     for an object-oriented style of programming.  Method dispatch
     takes place based on the class of the first argument to the
     generic function.

Usage:

     class(x)
     class(x) <- value
     unclass(x)
     inherits(x, what, which = FALSE)

     oldClass(x)
     oldClass(x) <- value

Arguments:

       x: a R object

what, value: a character vector naming classes.  'value' can also be
          'NULL'.

   which: logical affecting return value: see 'Details'.

Details:

     Many R objects have a 'class' attribute, a character vector giving
     the names of the classes from which the object _inherits_. If the
     object does not have a class attribute, it has an implicit class,
     '"matrix"', '"array"' or the result of 'mode(x)' (except that
     integer vectors have implicit class '"integer"').  (Functions
     'oldClass' and 'oldClass<-' get and set the attribute, which can
     also be done directly.)

     When a generic function 'fun' is applied to an object with class
     attribute 'c("first", "second")', the system searches for a
     function called 'fun.first' and, if it finds it, applies it to the
     object.  If no such function is found, a function called
     'fun.second' is tried.  If no class name produces a suitable
     function, the function 'fun.default' is used (if it exists).  If
     there is no class attribute, the implicit class is tried, then the
     default method.

     The function 'class' prints the vector of names of classes an
     object inherits from.  Correspondingly, 'class<-' sets the classes
     an object inherits from.  Assigning a zero-length vector or 'NULL'
     removes the class attribute.

     'unclass' returns (a copy of) its argument with its class
     attribute removed.  (It is not allowed for objects which cannot be
     copied, namely environments and external pointers.)

     'inherits' indicates whether its first argument inherits from any
     of the classes specified in the 'what' argument.  If 'which' is
     'TRUE' then an integer vector of the same length as 'what' is
     returned. Each element indicates the position in the 'class(x)'
     matched by the element of 'what'; zero indicates no match. If
     'which' is 'FALSE' then 'TRUE' is  returned by 'inherits' if any
     of the names in 'what' match with any 'class'.

Formal classes:

     An additional mechanism of _formal_ classes is available in
     packages 'methods' which is attached by default.  For objects
     which have a formal class, its name is returned by 'class' as a
     character vector of length one.

     The replacement version of the function sets the class to the
     value provided.  For classes that have a formal definition,
     directly replacing the class this way is strongly deprecated.  The
     expression 'as(object, value)' is the way to coerce an object to a
     particular class.

     The analogue of 'inherits' for formal classes is 'is'.

Note:

     Functions 'oldClass' and 'oldClass<-' behave in the same way as
     functions of those names in S-PLUS 5/6, _but_ in R 'UseMethod'
     dispatches on the class as returned by 'class' (with some
     interpolated classes: see the link) rather than 'oldClass'. 
     _However_, group generics dispatch on the 'oldClass' for
     efficiency, and internal generics only dispatch on objects for
     which 'is.object' is true.

See Also:

     'UseMethod', 'NextMethod', 'group generic', 'internal generic'

Examples:

     x <- 10
     class(x) # "numeric"
     oldClass(x) # NULL
     inherits(x, "a") #FALSE
     class(x) <- c("a", "b")
     inherits(x,"a") #TRUE
     inherits(x, "a", TRUE) # 1
     inherits(x, c("a", "b", "c"), TRUE) # 1 2 0

