你見過哪些令你瞠目結舌的C/C++代碼技巧？

});

也就是說，callback B 是接在callbackA後面的話，callback A 如果返回的是 T，我們可以支持callback B接受 T, T, T, Try&, Try& 廢話不說先上代碼。解釋在代碼後面，所以嫌代碼長的可以直接滑過去看解釋。

/** When this Future has completed, execute func which is a function that
takes one of:
(const) Try&
(const) Try&
(const) Try&
(const) T
(const) T
(const) T
(void)

template&
using resultOf = decltype(std::declval&()(std::declval&()...));


FunctionReferenceToPointer


可以無視掉，你可以想像成FF就是F

template&
using resultOf = decltype(std::declval&()(std::declval&()...));


這樣的語法拿到F(Args args...) 的返回值，不管F是object還是lambda。這樣，resultOf可以拿到我們的callback的返回type。現在我們得把這個返回值跟下一個函數的argument對應起來。這裡我們用callableWith

template&
struct callableWith {
template&&>
static constexpr std::true_type
check(std::nullptr_t) { return std::true_type{}; };

typedef decltype(check&(nullptr)) type;
static constexpr bool value = type::value;
};


這裡check有兩個specialization，一個在編譯時候會返回true一個會返回false。注意只要不符合第一個specialization的都是false，也就是說resultOf沒有成功，check(nullptr) 就是false type。這個技巧叫做Substitution Failure Is Not An Error SFINAE - cppreference.com 。再配倒數第二行的typedef，如果 F可以接受args，那麼callableWith&(Args args...)::value == true type。

template&
struct callableResult {
typedef typename std::conditional&< callableWith&::value,
detail::argResult&,
typename std::conditional&< callableWith&::value,
detail::argResult&,
typename std::conditional&< callableWith&::value,
detail::argResult&,
typename std::conditional&< callableWith&&>::value,
detail::argResult&&>,
detail::argResult&&>&>::type&>::type&>::type&>::type Arg;
typedef isFuture& ReturnsFuture;
typedef Future& Return;
};


我們就可以在編譯時間確保我們可以支持我們所有想支持的7個類啦。那具體拿著第一個callback的返回值怎麼傳輸到第二個callback上面做argument呢？這一段變種太多，我只給大家看最簡單的變種：

// Variant: returns a value
// e.g. f.then([](Try& t){ return t.value(); });
template &
template &
typename std::enable_if&::type
Future&::thenImplementation(F func, detail::argResult&) {
static_assert(sizeof...(Args) &<= 1, "Then must take zero/one argument"); typedef typename R::ReturnsFuture::Inner B; throwIfInvalid(); Promise& p;
p.core_-&>setInterruptHandlerNoLock(core_-&>getInterruptHandler());

// shared core state object
corePtr core_;


core_ 是future 的member，也就是說我們設置的callback僅僅只是被加到callback裡面去了，還沒有被執行。只有當你執行future.get() 的時候值才會被你拿到

template &
T Future&::get() {
return std::move(wait().value());
}

template &
void waitImpl(Future& f) {
// short-circuit if there"s nothing to do
if (f.isReady()) return;
FutureBatonType baton;
f.setCallback_([](const Try& /* t */) { baton.post(); });
baton.wait();
assert(f.isReady());
}


啊，所有的callback執行都被扔到baton裡面去了，我先不在這裡繼續深挖了。總之

auto value = folly::makeFuture(cb1).then(cb2).get();

－ 在編譯的時候，是通過一系列declval/decltype/SFAINE/std::conditional 來確保類是對的

--------三更，講點稍微實用一點的數據結構吧, 兩個看起來風馬牛不相及其實儲存上一致的folly::Optional 和 folly::Indestructible ------

folly::Optional

folly/Optional.h at master · facebook/folly · GitHub

using Storage = typename std::conditional&::value,
StorageTriviallyDestructible,
StorageNonTriviallyDestructible&>::type;

void clear() {
if (hasValue) {
hasValue = false;
value.~Value();
}
}
};


StorageTriviallyDestructible 還稍微合理一點，StorageNonTriviallyDestructible.clear() 裡面~Value() 絕對很少見。這是c++11裡面unconstrained union的新玩法，因為在unconstrained union裡面你必須有能力可以銷毀一個non-POD類，所以c++語法開放了~Value() 這種語法，讓你可以銷毀這個值。這個功能在這裡就被弄出了新玩法，被用來支持folly::Optional.clear()，這樣就算是一個NonTriviallyDestructible的對象你也可以隨時銷毀它。

這種unconstrained union的啟動機制也是比較麻煩的。folly::optional.set 長這樣：

template&
void construct(Args... args) {
const void* ptr = storage_.value;
// for supporting const types
new(const_cast&(ptr)) Value(std::forward&(args)...);
storage_.hasValue = true;
}


new(const_cast&(ptr)) Value(std::forward&(args)...);


這個叫placement new，就是說你給new 一個地址，new直接在你給的地址上面initialize，而不是去heap裡面占內存。有上面兩個玩法的話，你就可以隨時隨地在c++啟動，銷毀這個值啦！

folly::Indestructible

union Storage {
T value;

template &
explicit constexpr Storage(Args... args)
: value(std::forward&(args)...) {}
~Storage() {}
};


看起來好像沒有什麼特殊的對不對？不要忘記這個T在這裡肯定是個non trivially destructable的類。在這個union裡面，既然你的destructor是空的，那麼也就是說value永遠被遺忘了。。。遺忘了。。。遺忘了。。

看到這裡有人要開罵了，為什麼不直接new一個值出來，不銷毀就好了？這跟new一個新的值出來最大的差別是這個不可以被遺忘的值是可以被inline的，它用的內存不是heap裡面的內存（至少value本身不在heap上面）。這在效率上的差別是不可小覷的。

folly::optional 跟 folly::indestructable 都是利用了新標準裡面union的新特性。看來新玩法還是要多想

---------謝謝各位踴躍點贊，這段是二更。要是過一千的話我就寫MPMCQueue哦--------

/**
* Returns the number of digits in the base 10 representation of an
* uint64_t. Useful for preallocating buffers and such. It"s also used
* internally, see below. Measurements suggest that defining a
* separate overload for 32-bit integers is not worthwhile.
*/

#else
uint32_t result = 1;
for (;;) {
if (LIKELY(v &< 10)) return resu< if (LIKELY(v &< 100)) return result + 1; if (LIKELY(v &< 1000)) return result + 2; if (LIKELY(v &< 10000)) return result + 3; // Skip ahead by 4 orders of magnitude v /= 10000U; result += 4; } #endif }

const uint32_t minLength = 1 + ((bits * 77) &>&> 8);


這個就是亮點了。高中數學沒學好的話，這裡強調一下

log_10(v) =log_10(2) * log_2(v) (The Change-of-Base Formula)

我們繼續瞎，現在開始正式轉換

/**
* Copies the ASCII base 10 representation of v into buffer and
* returns the number of bytes written. Does NOT append a . Assumes
* the buffer points to digits10(v) bytes of valid memory. Note that
* uint64 needs at most 20 bytes, uint32_t needs at most 10 bytes,
* uint16_t needs at most 5 bytes, and so on. Measurements suggest
* that defining a separate overload for 32-bit integers is not
* worthwhile.
*
* This primitive is unsafe because it makes the size assumption and
* because it does not add a terminating .
*/

// Last digit is trivial to handle
buffer[pos] = static_cast&(v) + "0";
return resu< }

這裡面開始甩說用pos慢了，估計原因是loop unrolling做不了，但是具體不好說，我得問問他。

/**
* int32_t and int64_t to string (by appending) go through here. The
* result is APPENDED to a preexisting string passed as the second
* parameter. This should be efficient with fbstring because fbstring
* incurs no dynamic allocation below 23 bytes and no number has more
* than 22 bytes in its textual representation (20 for digits, one for
* sign, one for the terminating 0).
*/
template &
typename std::enable_if&< std::is_integral&::value std::is_signed&::value
IsSomeString&::value sizeof(Src) &>= 4&>::type
toAppend(Src value, Tgt * result) {
char buffer[20];
if (value &< 0) { result-&>push_back("-");
result-&>append(buffer, uint64ToBufferUnsafe(-uint64_t(value), buffer));
} else {
result-&>append(buffer, uint64ToBufferUnsafe(value, buffer));
}
}


好了我服了。。。

-----------------------原先的答案------------------------------

union {
Atom& data;
T typedData;
};


typename Raw = typename detail::AtomicStructIntPick&::type


template &<&> struct AtomicStructIntPick&<1&> { typedef uint8_t type; };
template &<&> struct AtomicStructIntPick&<2&> { typedef uint16_t type; };
template &<&> struct AtomicStructIntPick&<3&> { typedef uint32_t type; };
template &<&> struct AtomicStructIntPick&<4&> { typedef uint32_t type; };
template &<&> struct AtomicStructIntPick&<5&> { typedef uint64_t type; };
template &<&> struct AtomicStructIntPick&<6&> { typedef uint64_t type; };
template &<&> struct AtomicStructIntPick&<7&> { typedef uint64_t type; };
template &<&> struct AtomicStructIntPick&<8&> { typedef uint64_t type; };


我看到這裡已經開始瞎了。

bool compare_exchange_weak(
T v0, T v1,
std::memory_order mo = std::memory_order_seq_cst) noexcept {

Raw d0 = encode(v0);
bool rv = data.compare_exchange_weak(d0, encode(v1), mo);
if (!rv) {
v0 = decode(d0);
}
return rv;
}


裡面的encode／decode就是拿來騙編譯器的memcpy。寫了這麼多廢話，說白了就是為了讓編譯器開心的可以用各種std::atomc&

DiscriminatedPtr

void* ptr() const {
return reinterpret_cast&(data_ ((1ULL &<&< 48) - 1)); }

那前16個bit是存什麼呢？存的是現有這個類的index。每次存的時候，會通過index找到對應的類

/**
* Set this DiscriminatedPtr to point to an object of type T.
* Fails at compile time if T is not a valid type (listed in Types)
*/
template &
void set(T* ptr) {
set(ptr, typeIndex&());
}


然後

void set(void* p, uint16_t v) {
uintptr_t ip = reinterpret_cast&(p);
CHECK(!(ip &>&> 48));
ip |= static_cast&(v) &<&< 48; data_ = ip; }

template & struct GetTypeIndex;

template &
struct GetTypeIndex& {
static const size_t value = 1 + GetTypeIndex&::value;
};


具體實現在這裡folly/DiscriminatedPtrDetail.h at master · facebook/folly · GitHub。 這樣在編譯時間你就可以知道你要的類是不是這個指針支持的類。要是對編譯時的黑魔法感興趣的話，可以從boost的index_sequence看起 boost/fusion/support/detail/index_sequence.hpp

!!! 多圖流量預警 !!!

• 重新用電腦排了版，之前手機寫的，發現版面好爛

• 修正求圓周率程序（KR vs ANSI C）
• 更新大量真·阿卡林軍團 炮姐程序

––––––––––––––––––––––––––––––––––––––––––––––––––––––

如果說「瞠目結舌」的話，IOCCC 上隨便拿一篇獲獎代碼出來就足以讓人下巴落地了。

The International Obfuscated C Code Contest

一個比較經典的例子是 1988 年得獎的代碼，這個程序直接估算字元面積求圓周率，可讀性算是比較友好的：

#define _ F--&>00||-F-OO--;
int F=00,OO=00;main(){F_OO();printf("%1.3f
",4.*-F/OO/OO);}F_OO()
{
_-_-_-_
_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_
_-_-_-_
}


註：這段程序實際上是 1989 年修正過的，由於 88 年原來程序代碼沒有考慮到 ANSI C 的編譯標準，導致在處理例如

#define _ -i
-_


的時候，老舊的 KR 框架和 ANSI C 結果不一樣：KR 是直接的

--i


而 ANSI C 編譯結果實際上等同於

-(-i)


因此之前的程序現在運行的話出來的結果是 0.250，而不是 3.141。修正過的程序就沒有這個問題了。

又比如 13 年有個只有一行的程序，可以判斷從 Franklin Pierce 往後的 31 位美國總統是民主黨還是共和黨，這個就有點不知所云了：

main(int riguing,char**acters){puts(1[acters-~!(*(int*)1[acters]%4796%275%riguing)]);}


食用方法：

make cable1

./cable1 obama republican democrat
./cable1 bush republican democrat


總統名要小寫，republican 和 democrat 順序不能顛倒。

./cable1 roosevelt republican democrat


表示 Theodore Roosevelt，而用

./cable1 fdr republican democrat


表示 Franklin D. Roosevelt。

這一行代碼做了這麼多事：首先查詢輸入的總統的名字，然後在一個 look-up table 裡面找出對應的政治陣營，再輸出出來。問題在於這 31 位總統名字存放在哪裡？而這個 look-up table 又存放在哪裡？

./cable1 Cooper Mac PC
./cable1 Noll Mac PC
./cable1 Broukhis Mac PC
./cable1 Jobs Mac PC
./cable1 Gates Mac PC
./cable1 Ballmer Mac PC


難道這個程序暴露了 Ballmer 離開微軟的真相？

最近幾屆比賽的代碼為了增加混亂程度，代碼越來越長，可讀性也越來越差（不過話說回來，讓可讀性變得越來越差其實原本就是這個比賽的第一宗旨吧），不少代碼甚至本身就是個 ASCII artwork……比如 11 年有一隻阿卡林：

?akari.c?

–––––––––– !!! 前方阿卡林軍團高能預警 !!! ––––––––––

make akari
./akari akari.c akari2.c


然後生成的阿卡林·2號是這個樣子的：

make akari2.c
./akari2 & akari2fat.txt


成功了！生成了一隻阿卡林·2號·舒松：

./akari2 rot13 & akari2fat.txt


生成的是經過 ROT13 仿射變換的文本，我們稱之為阿卡林·2號·舒松·加蜜吧！

./akari &< akari.c | ./akari &> akari3.c


於是阿卡林·3號誕生：

wm_aoi(n)
/*ity,,[2*/{}char*y=
(")M{lpduKtjsa(v""YY"
"*yuruyuri") ;main(/*
/",U/ R)U* Y0U= ="/
*/){puts (y+ 17/*
"NR{I=" ){/=*
=* */);/*
**/{ ;;}}


可憐的阿卡林·3號，由於「馬賽克」（down-sample）次數太多，摘了眼鏡也只能模糊看到一點點……我們來問問阿卡林·3號對於誕生的感受吧：

make akari3
./akari3


於是她回答：

yuruyuri


居然會說ゆるゆり！

./akari &< akari.c | ./akari | ./akari &> akari4.c


main
(){puts("Y"
"U RU YU "
"RI" )/*
*/ ;}


順利生產！雖然內容已經直截了當了，不過我們還是採訪一下她吧：

make akari4
./akari4


她的答覆是：

YU RU YU RI


至此，阿卡林軍團全部誕生！

經 @馬琦明 提醒，我又把上面這位作者的另一個作品搬出來了，13 年的 Most Catty——炮姐程序。這程序的代碼長這個樣子：

?misaka.c?

make misaka


這個御坂的作用是把輸入的 ASCII 橫向連接起來。首先連接兩個自己試試：

./misaka misaka.c misaka.c &> misaka2.c


「把兩個御坂輸入一個御坂，會生成什麼？」「兩個御坂。」

make misaka2.c


御坂-2 的功能是把輸入的 ASCII 縱向連接起來。那我們就試著縱向連接兩個御坂：

./misaka2 misaka.c misaka.c &> misaka3.c


於是御坂-3 誕生了：

?misaka3.c?

make misaka3
./misaka3


./misaka2 misaka.c misaka.c misaka.c misaka.c &> misaka4.c
make misaka4.c
./misaka4


那麼御坂-4 會給你造一隻更長的 looooong cat：

13 年還有浙大教授侯啟明寫的 ray tracer 程序，雖然代碼本身存在爭議是否符合比賽規則，例如為避免長度超限制而使用了一些壓縮方法、程序是個死循環。如果這段程序可讀性不是這麼噁心的話其實還是非常值得鑽研的，裡面用到了很多有趣的數據結構和著色體系。

食用方法也很簡單，把程序掛在那兒跑一晚上，強制退出，就可以看結果了。由於是無窮盡的遞歸，程序跑的時間越長，圖像就越精緻。詳細的說明和源文件還是參考官網吧：

Previous IOCCC Winners with spoilers

這裡有個示例圖。

侯老師還有另外三個作品上榜，一個是極其酷炫的 syntax highlightener，還有一個（源代碼本身就是 GUI 的）科學計算器，後面這個已經有人@paintsnow回答過了。最新一個是上個月剛剛公布的新一屆獲獎作品 MD5 without integers，但是這個的源碼還沒有公布，估計要等到明年了。

看輪子哥寫了個關於lambda序列化的，我也準備寫個相關的東西。

1. 先寫個C++反射的吧。

這個反射主要好用在不需要用戶先去進行任何註冊操作。

Note:剛發現似乎只有在gcc上才不需要註冊（哎喲，瞬間感覺不高端了）。

而標準里寫了：

It is implementation-defined whether the dynamic initialization of a non-local variable with static storage duration is done before the first statement of main.

確實是每種編譯器自己實現決定的。

#include &
#include &
#include &
#include &
#include & #include &
using namespace std;

int main(int argc ,char** argv)
{
if (argc == 1) {
std::string cmd = "";
cmd += argv[0];
cmd += " "" + Reflection&::type_name&() + """;
std::cout &<&< cmd &<&< std::endl; system(cmd.c_str()); return 0; } std::cout &<&< "in sub process" &<&< std::endl; std::string name = argv[1]; Reflection&::create(name)-&>call(); // 注意這子進程里從未顯式調用過任何註冊相關的代碼
}


class ToInt: public MapFn& {
int map(std::string input) const {
return boost::lexical_cast&(input);
}
};

run_workflow();
}


然後在client端把這些要執行的函數記錄下來，翻譯到分散式系統上，再到分散式系統上正確的位置反射出來正確的函數並執行即可。

template&
class Serde {
public:
typedef T ObjectType;

// for debug
virtual std::string to_string(const T object) const = 0;
};


然後，弄一個SerdeOf，用來獲取一個類型默認的序列化器：

template&
struct SerdeOf;


然後把各種常見類型都註冊到SerdeOf上，例如：

template&
class ProtobufSerde : public Serde& {
public:
virtual uint32_t serialize(const T message, char* buffer, uint32_t buffer_size) const {
google::protobuf::io::ArrayOutputStream stream(buffer, buffer_size);
if (message.SerializeToZeroCopyStream(stream)) {
return stream.ByteCount();
}
return message.ByteSize();
}

template&
struct SerdeOf&::type
&>::type&> {
typedef ProtobufSerde& type;
};


這樣，就實現了一套可以擴展的且原生、常見類型都不需要用戶設置序列化器的序列化機制。