Component bslmf_removecvq [Package bslmf]

Provide a meta-function for removing const/volatile qualifiers. More...

Namespaces
namespace	bslmf
Defines
#define	bslmf_RemoveCvq   bslmf::RemoveCvq

---

Detailed Description

Outline

• Purpose
• Classes
• Description
  • Usage

Purpose:

Provide a meta-function for removing const/volatile qualifiers.

Classes:

bslmf::RemoveCvq

meta-function for stripping const/volatile qualifiers

Description:

This component defines a simple template structure used to strip of any top-level const/volatile qualifiers from it's single template parameter. The un-qualified type can be accessed via the Type member defined in bslmf::RemoveCvq.

  struct MyType {};

  bslmf::RemoveCvq<int              >::Type i1; // int i1;
  bslmf::RemoveCvq<const int        >::Type i2; // int i2;
  bslmf::RemoveCvq<volatile int     >::Type i3; // int i3;
  bslmf::RemoveCvq<int *            >::Type i4; // int *i4;
  bslmf::RemoveCvq<int **           >::Type i5; // int **i5;
  bslmf::RemoveCvq<int *const       >::Type i6; // int *i6;
  bslmf::RemoveCvq<int *const *     >::Type i7; // int *const *i7;
  bslmf::RemoveCvq<int *const *const>::Type i8; // int *const *i8;
  bslmf::RemoveCvq<MyType           >::Type m1; // MyType m1;
  bslmf::RemoveCvq<MyType const     >::Type m2; // MyType m2;

Usage:

We can make a simple template function that shows whether two objects are the same type, ignoring const and volatile qualifiers.

First, we create a template that will determine whether two objects are EXACTLY the same type:

  template <class t_TYPE>
  bool isSame(t_TYPE& a, t_TYPE& b) { return true; }
  template <class TYPEA, class TYPEB>
  bool isSame(TYPEA& a, TYPEB& b) { return false; }

Next, we combine that template function with the use of bslmf::RemoveCvq to create a template that will determine whether two objects are the same type, ignoring const and volatile qualifiers:

  template <class TYPEA, class TYPEB>
  bool isSortaSame(TYPEA& a, TYPEB& b)
  {
      typename bslmf::RemoveCvq<TYPEA>::Type aa = a;
      typename bslmf::RemoveCvq<TYPEB>::Type bb = b;

      return isSame(aa, bb);
  }

Next, we use the templates

  int i = 0, j = 0;
  const int ci = 0, cj = 0;
  volatile int vi = 0, vj = 0;
  const volatile int cvi = 0, cvj = 0;

  double x = 0, y = 0;

  assert(  isSame(i, j));
  assert(  isSame(ci, cj));
  assert(  isSame(vi, vj));
  assert(  isSame(cvi, cvj));
  assert(  isSame(x, y));

  assert(! isSame(i, x));
  assert(! isSame(i, ci));
  assert(! isSame(i, vi));
  assert(! isSame(i, cvi));
  assert(! isSame(ci, vi));
  assert(! isSame(ci, cvi));
  assert(! isSame(vi, cvi));

  assert(! isSortaSame(i, x));
  assert(  isSortaSame(i, ci));
  assert(  isSortaSame(i, vi));
  assert(  isSortaSame(i, cvi));
  assert(  isSortaSame(ci, vi));
  assert(  isSortaSame(ci, vi));
  assert(  isSortaSame(ci, cvi));
  assert(  isSortaSame(vi, cvi));

---

Define Documentation

#define bslmf_RemoveCvq   bslmf::RemoveCvq