Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

Click here to view the latest version of this page.
PrevUpHomeNext

Class template quantity

boost::units::quantity — class declaration

Synopsis

// In header: <boost/units/quantity.hpp>

template<typename Unit, typename Y = double> 
class quantity {
public:
  // types
  typedef quantity< Unit, Y > this_type; 
  typedef Y                   value_type;
  typedef Unit                unit_type; 

  // construct/copy/destruct
  quantity();
  quantity(unspecified_null_pointer_constant_type);
  quantity(const this_type &);
  template<typename YY> 
    quantity(const quantity< Unit, YY > &, unspecified = 0);
  template<typename YY> 
    quantity(const quantity< Unit, YY > &, unspecified = 0);
  template<typename Unit2, typename YY> 
    quantity(const quantity< Unit2, YY > &, unspecified = 0);
  template<typename Unit2, typename YY> 
    quantity(const quantity< Unit2, YY > &, unspecified = 0);
  quantity(const value_type &, int);
  quantity& operator=(const this_type &);
  template<typename YY> quantity& operator=(const quantity< Unit, YY > &);
  template<typename Unit2, typename YY> 
    quantity& operator=(const quantity< Unit2, YY > &);

  // private member functions
   BOOST_MPL_ASSERT_NOT(unspecified) ;

  // public member functions
  const value_type & value() const;
  template<typename Unit2, typename YY> 
    this_type & operator+=(const quantity< Unit2, YY > &) ;
  template<typename Unit2, typename YY> 
    this_type & operator-=(const quantity< Unit2, YY > &) ;
  template<typename Unit2, typename YY> 
    this_type & operator*=(const quantity< Unit2, YY > &) ;
  template<typename Unit2, typename YY> 
    this_type & operator/=(const quantity< Unit2, YY > &) ;
  this_type & operator*=(const value_type &) ;
  this_type & operator/=(const value_type &) ;

  // public static functions
  static this_type from_value(const value_type &) ;
};

Description

quantity public construct/copy/destruct

  1. quantity();
  2. quantity(unspecified_null_pointer_constant_type);
  3. quantity(const this_type & source);
  4. template<typename YY> 
      quantity(const quantity< Unit, YY > & source, unspecified = 0);
    implicit conversion between value types is allowed if allowed for value types themselves
  5. template<typename YY> 
      quantity(const quantity< Unit, YY > & source, unspecified = 0);
    implicit conversion between value types is not allowed if not allowed for value types themselves
  6. template<typename Unit2, typename YY> 
      quantity(const quantity< Unit2, YY > & source, unspecified = 0);
    explicit conversion between different unit systems is allowed if implicit conversion is disallowed
  7. template<typename Unit2, typename YY> 
      quantity(const quantity< Unit2, YY > & source, unspecified = 0);
    implicit conversion between different unit systems is allowed if each fundamental dimension is implicitly convertible
  8. quantity(const value_type & val, int);
  9. quantity& operator=(const this_type & source);
  10. template<typename YY> quantity& operator=(const quantity< Unit, YY > & source);
    implicit assignment between value types is allowed if allowed for value types themselves
  11. template<typename Unit2, typename YY> 
      quantity& operator=(const quantity< Unit2, YY > & source);
    implicit assignment between different unit systems is allowed if each fundamental dimension is implicitly convertible

quantity private member functions

  1.  BOOST_MPL_ASSERT_NOT(unspecified) ;

quantity public member functions

  1. const value_type & value() const;
    constant accessor to value

    can add a quantity of the same type if add_typeof_helper<value_type,value_type>::type is convertible to value_type

  2. template<typename Unit2, typename YY> 
      this_type & operator+=(const quantity< Unit2, YY > & source) ;
    can subtract a quantity of the same type if subtract_typeof_helper<value_type,value_type>::type is convertible to value_type
  3. template<typename Unit2, typename YY> 
      this_type & operator-=(const quantity< Unit2, YY > & source) ;
  4. template<typename Unit2, typename YY> 
      this_type & operator*=(const quantity< Unit2, YY > & source) ;
  5. template<typename Unit2, typename YY> 
      this_type & operator/=(const quantity< Unit2, YY > & source) ;
    can multiply a quantity by a scalar value_type if multiply_typeof_helper<value_type,value_type>::type is convertible to value_type
  6. this_type & operator*=(const value_type & source) ;
    can divide a quantity by a scalar value_type if divide_typeof_helper<value_type,value_type>::type is convertible to value_type
  7. this_type & operator/=(const value_type & source) ;

quantity public static functions

  1. static this_type from_value(const value_type & val) ;
    Construct quantity directly from value_type (potentially dangerous).

PrevUpHomeNext