User defined literal是c++提供的特性，可以讓程式設計者僅用常規的幾個資料型別來初始化自定義的類物件，而不需要顯式呼叫類構造／拷貝方法，使程式碼可讀性更高。但實際上這本質上還是是運算子的過載，還是要呼叫一部分方法。下文記錄了嘗試該特性的實驗，這個小實驗以構建一個複數類為契機，簡單瞭解一下udl特性。

首先構建一個簡單的複數類模板，只實現讀取／賦值實部虛部的介面：

template <typename T> class ComplexBase {
public:
	ComplexBase() = default;

	T re() const {return x;}
	T& re() {return x;}
	T im() const {return y;}
	T& im() {return y;}

protected:
	T x;
	T y;
};
 

對該類派生出一個實虛部都是整數型別的虛數類以及相應的過載方法：

class ComplexInt : public ComplexBase<int> {
public:
	ComplexInt() = default; // explicit declaration, avoid being ambiguous
	ComplexInt(int i, int j) { x = i; y = j; }

	/* Leave copy and = to default */

	ComplexInt(int i) { x = i; y = 0;} // converting constructor

	inline friend std::ostream& operator<< (std::ostream& os, ComplexInt c) {
		os << c.re() << " + " << c.im() << "i";
		return os;
	}
};

inline ComplexInt operator+ (const ComplexInt c1, const ComplexInt c2) {
	ComplexInt c;
	c.re() = c1.re() + c2.re();
	c.im() = c1.im() + c2.im();
	return c;
}

inline ComplexInt operator- (const ComplexInt c1, const ComplexInt c2) {
	ComplexInt c;
	c.re() = c1.re() - c2.re();
	c.im() = c1.im() - c2.im();
	return c;
}

inline ComplexInt operator* (const ComplexInt c1, const ComplexInt c2) {
	ComplexInt c;
	c.re() = c1.re() * c2.re() - c1.im() * c2.im();
	c.im() = c1.re() * c2.im() + c1.im() * c2.re();
	return c;
}
 

到此為止一個可以使用的複數類就實現了，在主函式裡可以這樣呼叫：

int main() {

	ComplexInt c1(1, 1), c2(1, -1);
	cout << c1 + c2 << endl;
	cout << c1 * c2 << endl;
}

但是諸如c(x, y)這樣的初始化方法還是太不直觀了，使用者希望使用c = x + y_i這樣的形式來構建簡單的複數物件。

literal運算子或者說operator ""，和其他型別的運算子一樣，可以過載亦可模板化，甚至可以作為類的友元，其形式為

template <T1> T2 operator "" _x();
 

注意！literal過載不能寫在類宣告內，必須置於外部。如果放在類宣告內，報錯：

error: literal operator 'operator""_i' must be in a namespace or global scope
        ComplexInt operator"" _i (int j) {return ComplexInt(0, j);}

其中T1只能是常用型別中的unsigned long long, long double, char, const char*這幾個型別，當然還有其他型別但不常用，就不列出了。在這個複數類例子中，過載為：

ComplexInt operator"" _i (unsigned long long j) {return ComplexInt(0, j);}

該過載將一個代下表的整數轉換成一個ComplexInt類的純虛數。

通過原本就實現的型別轉換，可以實現將一個整數轉換成ComplexInt類的純實數。於是可以在主函式裡呼叫：

int main() {

	ComplexInt c1 = 1 + 1_i, c2 = 1 - 1_i;
	cout << c1 + c2 << endl;
	cout << c1 - c2 + 1 << endl;
	cout << c1 * c2 << endl;
	cout << c1 * c2 - 2_i << endl;
}

輸出：

2 + 0i
1 + 2i
2 + 0i
2 + -2i