R: Object Classes

class {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

[Package base version 2.6.2 Index]