本文由這裡翻譯，講述一些不常見的C++特性。

中括號的真正含義

訪問陣列元素ptr[3]的真正含義是*(ptr+3)簡寫。這和*(3+ptr)是等價的。所以ptr[3]也可以寫作3[ptr]。

語法分析的優先順序

C++定義變數時候的語法分析可能會導致反直覺的分析結果：

// foo是一個：
// 1) std::string型別的變數，初始化值為std::string()？
// 2) 還是一個返回std::string的函式，其帶有一個返回值為std::string的函式指標引數？
std::string foo(std::string());
// bar是一個:
// 1) int型別的變數，初始化值為int(x)?
// 2) 還是一個帶有一個引數的函式，其引數為int 型別的x？
int bar(int(x));

在這兩個例子中，C++標準都會支援第二種解釋方法，即使你覺得第一種才是符合直覺的。要想得到第一種解釋的結果，你需要加括號：

// Parentheses resolve the ambiguity
std::string foo((std::string()));
int bar((int(x)));

重新定義關鍵詞

儘管理論上重新定義關鍵詞是會導致報錯的，不過實際中很多編譯器允許這麼做。你可以重新定義true, false, else來搞亂你的程式。另外你可以通過對public，private的重新定義來繞過C++的物件導向保護機制。

#define class struct
#define private public
#define protected public
#include "library.h"
#undef class
#undef private
#undef protected

這個小技巧可能會導致一些意想不到的問題，例如記憶體物件的重新排序。有的編譯器會把private的成員統一放在public的成員後面。另外Microsoft的編譯器會給成員起一些帶public或者private的別名，這可能會導致與已經編譯的二進位制庫不相容。

在已經分配的物件上new

你可以用如下的方法在已經分配的物件上面new，其需要滿足的先決條件是大小和對齊均與原物件一致。它包括的操作是重新設定vtable和執行建構函式：

#include <iostream>
using namespace std;

struct Test {
  int data;
  Test() { cout << "Test::Test()" << endl; }
  ~Test() { cout << "Test::~Test()" << endl; }
};
int main() {
  // 使用malloc
  Test *ptr = (Test *)malloc(sizeof(Test));
  // 原地new
  new (ptr) Test;
  // 需要自己呼叫解構函式
  ptr->~Test();
  // 需要自己free記憶體
  free(ptr);
  return 0;
}

變數定義語句的返回值

C++提供了一種語法，可以在為變數賦值的同時根據其值來做條件判斷，例如：

struct Event { virtual ~Event() {} };
struct MouseEvent : Event { int x, y; };
struct KeyboardEvent : Event { int key; };

void log(Event *event) {
  if (MouseEvent *mouse = dynamic_cast<MouseEvent *>(event))
    std::cout << "MouseEvent " << mouse->x << " " << mouse->y << std::endl;
  else if (KeyboardEvent *keyboard = dynamic_cast<KeyboardEvent *>(event))
    std::cout << "KeyboardEvent " << keyboard->key << std::endl;
  else
    std::cout << "Event" << std::endl;
}

成員函式的引用限定符(Ref-qualifier)

C++11允許類的成員函式根據呼叫它的物件是左值還是右值來進行過載，宣告引用限定符（ref-qualifier）的位置和const以及volatile限定符（cv-qualifier）相同，實際呼叫的函式取決於呼叫者的this指標是左值還是右值。

struct Foo {
  void foo() & { std::cout << "lvalue" << std::endl; }
  void foo() && { std::cout << "rvalue" << std::endl; }
};
int main() {
  Foo foo;
  foo.foo(); // 列印 "lvalue"
  Foo().foo(); // 列印 "rvalue"
  return 0;
}

圖靈完全的超程式設計

模板是C++用來編譯期間超程式設計的工具，其中超程式設計的意思是說用來生成程式的程式。模板系統本來是設計用來進行簡單的型別替換的，不過它實際上已經具備了圖靈完全性，通過模板特化來進行計算：

// 遞迴定義模板
template <int N>
struct factorial {
  enum { value = N * factorial<N - 1>::value };
};

// 初始情況下的模板特化
template <>
struct factorial<0> {
  enum { value = 1 };
};

enum { result = factorial<5>::value }; // 5 * 4 * 3 * 2 * 1 == 120

我們可以認為C++模板是一種函數語言程式設計語言，因為它使用遞迴而不是迭代，也不包括任何可變狀態（mutable state）。這樣你就可以用typedef定義一個包含型別的變數，用enum定義一個包含整數的變數。型別內部可以包含資料結構：

// 編譯期整數列表
template <int D, typename N>
struct node {
  enum { data = D };
  typedef N next;
};
struct end {};

// 編譯期加法函式
template <typename L>
struct sum {
  enum { value = L::data + sum<typename L::next>::value };
};
template <>
struct sum<end> {
  enum { value = 0 };
};

// 嵌入型別的資料結構
typedef node<1, node<2, node<3, end> > > list123;
enum { total = sum<list123>::value }; // 1 + 2 + 3 == 6

這些例子整體上來說沒什麼用，僅僅用來說明超程式設計的可能性。模板超程式設計程式碼很難閱讀，編譯很慢，而且難於除錯。

在例項上呼叫靜態函式

C++允許直接在類的例項上呼叫靜態函式，這樣你可以不用改變函式呼叫方式，直接把一個例項函式變成一個靜態函式。

struct Foo {
  static void foo() {}
};
//兩者等價
Foo::foo();
Foo().foo();

過載++和--運算子

C++設計使用運算子號本身來代表自定義運算子時的函式名，大多數情況下這是有效的，例如-運算子可以通過它是一元還是二元運算子來判斷它是負號還是減號，這樣過載時它通過函式引數個數不一樣來區分。不過自加和自減運算子是不能這麼做的。C++使用一個醜陋的hack來解決這個問題，字尾++和--運算子必須帶一個沒用的int引數來讓編譯器知道過載的是一個字尾++或--運算子。

struct Number {
  Number &operator ++ (); // 過載字首++運算子
  Number operator ++ (int); // 過載字尾++運算子
};

運算子過載和運算次序

過載,(逗號)，||，以及&&運算子是非常危險的，因為它破壞了正常的求值順序。正常情況下逗號運算子會保證左邊的表示式一定在右邊的表示式之前被求值，而||和&&有所謂的“短路特性”，只在必要的時候對右側求值。然而，對這些運算子的過載只是普通的函式呼叫，對引數的求值順序是不確定的。
過載這些運算子只是一種混淆C++語法的方法，一個例子是通過C++實現Python式的不需要括號的print語句：

#include <iostream>
namespace __hidden__ {
  struct print {
    bool space;
    print() : space(false) {}
    ~print() { std::cout << std::endl; }
    template <typename T>
    print &operator , (const T &t) {
      if (space) std::cout << ' ';
      else space = true;
      std::cout << t;
      return *this;
    }
  };
}
#define print __hidden__::print(),
int main() {
  int a = 1, b = 2;
  print "this is a test";
  print "the sum of", a, "and", b, "is", a + b;
  return 0;
}

函式作為模板引數

眾所周知可以使用具體數字作為引數特化模板，不過具體函式也可以作為引數特化模板，這會讓編譯器內聯呼叫此函式來特化模板。下面的例子memoize函式以一個函式為模板引數，只有當值不在map中時候才會呼叫f求值，否則直接返回cache中存在的值。

#include <map>
template <int (*f)(int)>
int memoize(int x) {
  static std::map<int, int> cache;
  std::map<int, int>::iterator y = cache.find(x);
  if (y != cache.end()) return y->second;
  return cache[x] = f(x);
}
int fib(int n) {
  if (n < 2) return n;
  return memoize<fib>(n - 1) + memoize<fib>(n - 2);
}

模板作為模板引數

可以使用模板來作為模板的引數，它可以在例項化模板時傳遞進模板型別作為引數，所以有如下程式碼：

template <typename T>
struct Cache { ... };
template <typename T>
struct NetworkStore { ... };
template <typename T>
struct MemoryStore { ... };
template <typename Store, typename T>
struct CachedStore {
  Store store;
  Cache<T> cache;
};
CachedStore<NetworkStore<int>, int> a;
CachedStore<MemoryStore<int>, int> b;

CacheStore可以儲存一個資料Store以及該Store的一個快取。然而，在定義CachedStore型別變數的時候我們必須把實際儲存的型別int寫兩遍，一次用來例項化Store，一次用來例項化Cache，型別系統不能保證兩者的型別一致。我們真正想要的是隻定義實際儲存的型別一次。向模板傳遞另一個模板作為引數可以解決這個問題，注意需要加class關鍵字來告訴編譯器這個模板引數自己也需要引數：

template <template <typename> class Store, typename T>
struct CachedStore2 {
  Store<T> store;
  Cache<T> cache;
};
CachedStore2<NetworkStore, int> e;
CachedStore2<MemoryStore, int> f;

建構函式上的try語句

如果建構函式的初始化列表出現了異常，可以使用建構函式上的try語句來處理。可以使用如下語法：

int f() { throw 0; }

// Here there is no way to catch the error thrown by f()
struct A {
  int a;
  A::A() : a(f()) {}
};

// f()丟擲的異常值
// The value thrown from f() can be caught if a try-catch block is used as
// the function body and the initializer list is moved after the try keyword
struct B {
  int b;
  B::B() try : b(f()) {
  } catch(int e) {
  }
};

儘管語法有點奇怪，它不僅可以應用於建構函式，也可以應用於普通函式。