構造函數

模板版本:

explicit quaternion(T const & requested_a = T(), T const & requested_b = T(), T const & requested_c = T(), T const & requested_d = T());
explicit quaternion(::std::complex<T> const & z0, ::std::complex<T> const & z1 = ::std::complex<T>());
template<typename X>
explicit quaternion(quaternion<X> const & a_recopier);

單精度浮點數特化版本:

explicit quaternion(float const & requested_a = 0.0f, float const & requested_b = 0.0f, float const & requested_c = 0.0f, float const & requested_d = 0.0f);
explicit quaternion(::std::complex<float> const & z0,::std::complex<float> const & z1 = ::std::complex<float>());
explicit quaternion(quaternion<double> const & a_recopier); 
explicit quaternion(quaternion<long double> const & a_recopier);

雙精度浮點數特化版本:

explicit quaternion(double const & requested_a = 0.0, double const & requested_b = 0.0, double const & requested_c = 0.0, double const & requested_d = 0.0);
explicit quaternion(::std::complex<double> const & z0, ::std::complex<double> const & z1 = ::std::complex<double>());
explicit quaternion(quaternion<float> const & a_recopier);
explicit quaternion(quaternion<long double> const & a_recopier);

長雙精度浮點數特化版本:

explicit quaternion(long double const & requested_a = 0.0L, long double const & requested_b = 0.0L, long double const & requested_c = 0.0L, long double const & requested_d = 0.0L);
explicit quaternion(	::std::complex<long double> const & z0, ::std::complex<long double> const & z1 = ::std::complex<long double>());
explicit quaternion(quaternion<float> const & a_recopier);
explicit quaternion(quaternion<double> const & a_recopier);

每一種形式都提供了缺省構造函數, 將每一個成員初始化為它所屬類型的缺省值(即. 浮點數初始化為0). . 這個構造函數也可以接受 1 到 4 個基本類型的實參 . 提供了一個可以接受 1 到 2 個基於同一基本類型的複數實參的構造函數, 未特化的模板提供了一個模板化的拷貝構造函數, 而特化的模板有使用另處兩種特化形式的拷貝構造函數 (譯注：作者的意思是說，一共有三種形式的特化：float , double , long double ， 對於float 形式的特化，它有一個基於 double 特化 的 explicit octonion(octonion const & a_recopier); 拷貝構造函數 和一個 基於 long double 特化的 octonion(octonion const & a_recopier); 拷貝構造函數， 其它的兩種特化形式 double , long double 也有類似於 float 的基於其它兩種特化的拷貝構造函數), 這些拷貝構造函數是 explicit 的為了防止存在精度丟失的風險 (譯注：防止編譯器進行隱式的類型轉換時存在的精度丟失). 對於沒有特化的類模板， 基類型(譯注： 作者在這裡是指實例化模板的類型) 的構造函數禁止拋出異常.

析構函數和未模板化的拷貝構造函數(同一種類型)由編譯器提供. 具有轉換作用的拷貝構造函數使用子名字空間中的一個模板化的輔助函數.

其它的成員函數

實部和非實部

T             real() const;
quaternion<T> unreal() const;

就像複數一樣, 四元數有一個有意義的 "實部"概念, 但是不像複數， 四元數並沒有一個有意義的 "虛部"概念. 取而代之的是四元數中有一個"非實部"的概念， 非實部本身也是一個四元數, 並且通常不能再簡化 (這一點與複數相反). 這些實部和非實部由最開始的兩個函數返回.

單獨的實部構成

T R_component_1() const;
T R_component_2() const;
T R_component_3() const;
T R_component_4() const;

一個四元數有4個實部, 這些實部通過這4個函數返回. 因此成員函數 real 和 成員函數 R_component_1 返回同樣的值.

單獨的複數構成

::std::complex<T>	C_component_1() const;
::std::complex<T>	C_component_2() const;

一個四元數同樣有2個複數構成, 就像我們在上面看到的一樣, 對於任意的四元數 q = α + βi + γj + δk 我們也有 q = (α + βi) + (γ + δi)j 這種形式. 這些函數返回這些複數. q. C_component_1() 的實部和q.real()一樣.

四元數成員運算符

賦值運算符

quaternion<T>& operator = (quaternion<T> const & a_affecter);
template<typename X> 
quaternion<T>& operator = (quaternion<X> const& a_affecter);
quaternion<T>& operator = (T const& a_affecter);
quaternion<T>& operator = (::std::complex<T> const& a_affecter);

這些操作符進行預期的賦值操作, 如果有必要的話會伴有類型調整 (例如, 從一個基類型 進行賦值將會把實部賦為那個值, 而所有其它的成員將會被設為0). 對於沒有特化的形式, 基類型的賦值操作禁止拋出異常.

加法運算符

quaternion<T>& operator += (T const & rhs)
quaternion<T>& operator += (::std::complex<T> const & rhs);
template<typename X>	
quaternion<T>& operator += (quaternion<X> const & rhs);

這些+= 操作符進行(*this)+rhs 的數學運算 並且將結果存放在 *this中. 未特化的形式有異常保護, 但是特化的形式沒有異常保護, 以便確保異常安全 (譯注:作者的意思是這樣的， 因為特化的形式是針對 float , double , long double 進行的，我們知道， 這三種類型的 數值在進行賦值操作時是不會拋出異常的， 所以作都就沒有對這個特化形式設置異常保護，但是對於沒有特化的形式， 作者設置了異常保護，這是因為，對於沒有特化的形式， 用戶可能使用自定義的「具有數值特性的類」來實例化這個四元數 類模板而生成一個模板類，在這種情況下， 庫的作者不能確保用戶實例化這個類模板的用戶自定義類型的賦值操作一定不會拋出 異常， 所以，作者就對於這些未特化的形式設置了異常保護以確保異常安全性). 對於未特化的形式, 基類型的賦值操作禁止拋出異常.

減法運算符

quaternion<T>& operator -= (T const & rhs)
quaternion<T>& operator -= (::std::complex<T> const & rhs);
template<typename X>	
quaternion<T>& operator -= (quaternion<X> const & rhs);

這些-=操作符進行(*this)-rhs 的數學運算 並且將結果存放在*this中. 未特化的形式有異常保護, 但是特化的形式沒有異常保護, 以便確保異常安全. 對於未特化的形式， 基類型的賦值操作禁止拋出異常.

乘法運算符

quaternion<T>& operator *= (T const & rhs)
quaternion<T>& operator *= (::std::complex<T> const & rhs);
template<typename X>	
quaternion<T>& operator *= (quaternion<X> const & rhs);

這些*=運算符進行依照的(*this)*rhs 這種順序的數學計算 (順序很重要，因為四元數的乘法並不滿足可交換性) 並且將結果存放在*this中. 未特化的形式有異常保護, 但是特化的形式沒有異常保護, 以便確保異常安全. 對於未特化的形式， 基類型的賦值操作禁止拋出異常.

除法運算符

quaternion<T>& operator /= (T const & rhs)
quaternion<T>& operator /= (::std::complex<T> const & rhs);
template<typename X>	
quaternion<T>& operator /= (quaternion<X> const & rhs);

這些/=運算符進行依照的(*this)*inverse_of(rhs) 這種順序的數學計算 (順序很重要，因為四元數的乘法並不滿足可交換性 (譯注:這句話初看起來很矛盾,除法運算中的順序為什麼會受到 乘法運算中的「不可交換性」的影響呢，實際上是這樣的， 作者是將四元數的除法運算轉化為了四元數的乘法運算， (*this)*inverse_of(rhs) ，因為四元數乘法是不滿足交換律的， 所以，四元數中的除法的順序很重要) ) 並且將結果存放在 *this中. 未特化的形式有異常保護, 但是特化的形式沒有異常保護, 以便確保異常安全. 對於未特化的形式， 基類型的賦值操作禁止拋出異常.