bslalg_scalardestructionprimitives

Typedefs
typedef bslalg::ScalarDestructionPrimitives	bslalg_ScalarDestructionPrimitives
	This alias is defined for backward compatibility.

Detailed Description

Outline

• Purpose
• Classes
• Description
  • Usage
    • Example 1: Destroy int and an Integer Wrapper

Purpose

Provide primitive algorithms that destroy scalars.

Deprecated:

Use bslma_destructionutil instead.

Classes

• bslalg::ScalarDestructionPrimitives: namespace for scalar algorithms

See also

bslalg_scalarprimitives, bslalg_typetraits

Description

This component provides utilities to destroy scalars with a uniform interface, but select a different implementation according to the traits possessed by the underlying type.

The trait under consideration by this component is:

Trait                             Note
-------------------------------   -------------------------------------
bslmf::IsBitwiseCopyable          Expressed in English as "TYPE has the
                                  bit-wise copyable trait", or "TYPE is
                                  bit-wise copyable", this trait also
                                  implies that destructor calls can be
                                  elided with no effect on observable
                                  behavior.

Usage

In this section we show intended use of this component. Note that this component is for use by the bslstl package. Other clients should use the STL algorithms (in header <algorithm> and <memory>).

Example 1: Destroy int and an Integer Wrapper

In this example, we will use bslalg::ScalarDestructionPrimitives to destroy both a scalar integer and a MyInteger type object. Calling the destroy method on a scalar integer is a no-op while calling the destroy method on an object of MyInteger class invokes the destructor of the object.

First, we define a MyInteger class that represents an integer value:

class MyInteger {
    // This class represents an integer value.
 
    // DATA
    int d_intValue;  // integer value
 
  public:
    // CREATORS
    MyInteger();
        // Create a 'MyInteger' object having integer value '0'.
 
    explicit MyInteger(int value);
        // Create a 'MyInteger' object having the specified 'value'.
 
    ~MyInteger();
        // Destroy this object.
 
    // ACCESSORS
    int getValue() const;
};

Then, we create an object, myInteger, of type MyInteger:

bsls::ObjectBuffer<MyInteger> buffer;
MyInteger *myInteger = &buffer.object();
new (myInteger) MyInteger(1);

Notice that we use an ObjectBuffer to allow us to safely invoke the destructor explicitly.

Now, we define a primitive integer:

int scalarInteger = 2;

Finally, we use the uniform bslalg::ScalarDestructionPrimitives:destroy method to destroy both myInteger and scalarInteger:

bslalg::ScalarDestructionPrimitives::destroy(myInteger);
bslalg::ScalarDestructionPrimitives::destroy(&scalarInteger);

Typedef Documentation

bslalg_ScalarDestructionPrimitives

typedef bslalg::ScalarDestructionPrimitives bslalg_ScalarDestructionPrimitives