---
name: "sc_Ref"
section: "3"
platform: "linux"
package: "libsc-doc"
version: "2.3.1-22"
release: "Debian 12 (Bookworm)"
platforms: ["linux"]
url: "https://new.carta.tech/sc_Ref"
---

# sc\_Ref(3)

A template class that maintains references counts.

## NAME

sc::Ref\< T \> - A template class that maintains references counts.

## SYNOPSIS

`#include <ref.h>`

Inherits **sc::RefBase**.

### Public Member Functions

**Ref** ()\
 Create a reference to a null object.  **Ref** (T \*a)\
 Create a reference to the object a.  **Ref** (const **Ref**\< T \> &a)\
 Create a reference to the object referred to by a.  template\<class A \> **Ref** (const **Ref**\< A \> &a)\
 Create a reference to the object referred to by a.  **~Ref** ()\
 Delete this reference to the object.  T \* **operator-\>** () const\
 Returns the reference counted object.  T \* **pointer** () const\
 Returns a pointer the reference counted object.  **RefCount** \* **parentpointer** () const\
 Implements the parentpointer pure virtual in the base class.  **operator T\*** () const\
 T & **operator\*** () const\
 Returns a C++ reference to the reference counted object.  int **null** () const\
 Return 1 if this is a reference to a null object.  int **nonnull** () const\
 Return !null().  template\<class A \> int **operator==** (const **Ref**\< A \> &a) const\
 A variety of ordering and equivalence operators are provided using the **Identity** class.  template\<class A \> int **operator\>=** (const **Ref**\< A \> &a) const\
 template\<class A \> int **operator\<=** (const **Ref**\< A \> &a) const\
 template\<class A \> int **operator\>** (const **Ref**\< A \> &a) const\
 template\<class A \> int **operator\<** (const **Ref**\< A \> &a) const\
 template\<class A \> int **operator!=** (const **Ref**\< A \> &a) const\
 int **compare** (const **Ref**\< T \> &a) const\
 Compare two objects returning -1, 0, or 1.  void **clear** ()\
 Refer to the null object.  **Ref**\< T \> & **operator=** (const **Ref**\< T \> &c)\
 Assignment to c.  template\<class A \> **Ref**\< T \> & **operator=** (const **Ref**\< A \> &c)\
 Assignment to c.  **Ref**\< T \> & **operator\<\<** (const **RefBase** &a)\
 Assignment to the object that a references using dynamic\_cast.  **Ref**\< T \> & **operator\<\<** (**RefCount** \*a)\
 Assigns to the given base class pointer using dynamic\_cast.  **Ref**\< T \> & **operator=** (T \*cr)\
 Assignment to cr.  void **assign\_pointer** (T \*cr)\
 Assignment to cr.  void **check\_pointer** () const\
 Check the validity of the pointer.  void **ref\_info** (std::ostream &os) const\
 Print information about the reference to os.  void **warn** (const char \*s) const\
 Print a warning concerning the reference.

### Additional Inherited Members

## Detailed Description

### template\<class T\>

class sc::Ref\< T \>"A template class that maintains references counts.

Several of these operations can cause a reference to an object to be replaced by a reference to a different object. If a reference to a nonnull object is eliminated, the object's reference count is decremented and the object is deleted if the reference count becomes zero.

There also may be a to convert to T\*, where T is the type of the object which **Ref** references. Some compilers have bugs that prevent the use of operator T\*(). The **pointer()** member should be used instead.

## Constructor & Destructor Documentation

### template\<class T \> sc::Ref\< T \>::~Ref ()` [inline]`

Delete this reference to the object. Decrement the object's reference count and delete the object if the count is zero.

References **sc::Ref\< T \>::clear()**.

## Member Function Documentation

### template\<class T \> int sc::Ref\< T \>::compare (const Ref\< T \> & a) const` [inline]`

Compare two objects returning -1, 0, or 1. Similar to the C library routine strcmp.

### template\<class T \> int sc::Ref\< T \>::null () const` [inline]`

Return 1 if this is a reference to a null object. Otherwise return 0.

### template\<class T \> T & sc::Ref\< T \>::operator\* () const` [inline]`

Returns a C++ reference to the reference counted object. The behaviour is undefined if the object is null.

### template\<class T \> T \* sc::Ref\< T \>::operator-\> () const` [inline]`

Returns the reference counted object. The behaviour is undefined if the object is null.

### template\<class T \> Ref\< T \> & sc::Ref\< T \>::operator\<\< (RefCount \* a)` [inline]`

Assigns to the given base class pointer using dynamic\_cast. If the dynamic\_cast fails and the argument is nonnull and has a reference count of zero, then it is deleted.

### template\<class T \> RefCount \* sc::Ref\< T \>::parentpointer () const` [inline]`, ` [virtual]`

Implements the parentpointer pure virtual in the base class.

Implements **sc::RefBase**.

## Author

Generated automatically by Doxygen for MPQC from the source code.