有哪些能炫技的代碼寫法？

一年前隨手寫的，當時寫了倆語言版本，一個是Scheme版，一個是Python版。且看且隨意。

Lisp版：

Python版：

但我不知道咋定義「炫技」呀？我只能說我這個是「眼花繚亂」，應該別當成「炫技」的。請了解，謝謝~

宏吧。

compile_assert，編譯時期斷言，失敗會編譯錯誤，原理是利用sizeof x[-1]會編譯錯誤，1-2p，p＝0，為1，p＝1，為-1，sizeof x[1-2p]，當p等於1時編譯出錯。

do {} while{0}，循環中間的代碼，利用現在編譯器的優化功能，有時候會優化掉，相當於空語句。比如compile_assert就可以放到這裡。錯誤的時候編譯出錯，正確的時候沒有任何額外代碼產生。很多宏都會用到這個循環。

利用段功能跟宏，可以把一個結構數據存到特殊段裡面，利用段其實地址跟結束地址，就可以取得這個結構數組。使用宏的時候自動加入這個數據段，免去內存維護了，而且用到多少就多少。而且還能減少耦合。比如服務註冊，有n個服務可以編譯，每個服務有個函數入口，服務名稱。但服務不一定相同，有的服務在某些情況下不編譯，比如有的服務只在Windows有效。利用這個功能，就可以不用人工去管理這些服務了，服務管理器只需要看下那個特定段，就可以發現所有編譯進去的服務。而且調用服務的時候是通過函數指針的，不需要知道函數名。服務管理器代碼不需要include每個服務的頭文件。

下面舉個初始化的例子，模塊加入系統中需要初始化，利用上面這個功能，自動註冊初始化函數：

#ifdef CONFIG_LTO
/* Work around a LTO gcc problem: when there is no reference to a variable
* in a module it will be moved to the end of the program. This causes
* reordering of initcalls which the kernel does not like.
* Add a dummy reference function to avoid this. The function is
* deleted by the linker.
*/
#define LTO_REFERENCE_INITCALL(x)
; /* yes this is needed */
static __used __exit void *reference_##x(void)
{
return x;
}
#else
#define LTO_REFERENCE_INITCALL(x)
#endif
#define __define_initcall(fn, id)
static initcall_t __initcall_##fn##id __used
__attribute__((__section__(".initcall" #id ".init"))) = fn;
LTO_REFERENCE_INITCALL(__initcall_##fn##id)
#define pure_initcall(fn) __define_initcall(fn, 0)
#define core_initcall(fn) __define_initcall(fn, 1)
...


可以定義多個初始化階段

//module.c
static int init_module_call(bool isbp)
{
...
}

pure_initcall(init_module_call);


上面申明一個static函數，然後註冊初始化函數。由於是static，0耦合，其他模塊不需要引用這個模塊的任何數據跟函數，只需要編譯進去就行，就會在initcall0這個數據段裡面註冊一個結構，而主函數只需要讀取這個段即可完成初始化，不需要知道每個模塊的初始化函數名。

extern initcall_t __initcallap_start[];
extern initcall_t __initcallap_end[];

for (fn = initcall_levels[level]; fn &< initcall_levels[level + 1]; fn++) do_one_initcall(*fn, isbp); }

ld文件：

.init.data : AT(ADDR(.init.data)) {
*(.init.data)
__initcall_start = .; *(.initcallearly.init)
__initcall0_start = .; *(.initcall0.init) *(.initcall0s.init)
__initcall1_start = .; *(.initcall1.init) *(.initcall1s.init)
__initcall2_start = .; *(.initcall2.init) *(.initcall2s.init)
__initcall3_start = .; *(.initcall3.init) *(.initcall3s.init)
__initcall4_start = .; *(.initcall4.init) *(.initcall4s.init)
__initcall5_start = .; *(.initcall5.init) *(.initcall5s.init)
__initcallrootfs_start = .; *(.initcallrootfs.init) *(.initcallrootfss.init)
__initcall6_start = .; *(.initcall6.init) *(.initcall6s.init)
__initcall7_start = .; *(.initcall7.init) *(.initcall7s.init)
__initcall_end = .;
}


在黑星際2的時候，為了過調用者檢測寫過一段我認為自己寫過最喪心病狂的代碼：模板彙編

星際2的上萬個函數中都有調用者檢測，也就是檢查堆棧里的調用者是否屬於遊戲模塊，如果不屬於則偷偷上報。如果作弊器主動調用遊戲函數，結果就會被檢測。

這裡簡單介紹一下Return-oriented programming (ROP) 技術。當一段程序執行到ret，就會跳轉到棧頂指向的地址。如果攻擊者可以入侵調用棧，通過小心地選擇壓棧的內容，使得每個額外的跳轉都指向 (某個想要執行的指令 + ret)，就可以在宿主中執行任意程序。

如果要繞過一個函數的檢查，可以手動寫一段彙編找個trampoline，但假如需要繞過幾千個簽名各不同的函數難道也要手動寫嗎？有請萬能的C++出場—— （以下只拿x86的cdecl情況做例子，其他calling convention和x64有其他變化）

// ============================================================================================== //
// Bypass caller check varargs (cdecl) wrapper //
// ============================================================================================== //
template&
constexpr std::size_t SizeOfPack()
{
return sizeof(T);
}

//Call wrapper function
template&
RetT VarargsCallWrapper(void* funcAddr, ArgsT.../*copy intended*/ args, VarArgsT... va)
{
using WrapperT = VarargsCallWrapperHelper&;
WrapperT::func = funcAddr;
return WrapperT::Call(std::move(args)..., va...);
}


原理簡單說就是在調用時，向堆棧壓入某個遊戲模塊內的地址，而這個地址指向一個跳轉指令，例如JMP [0x????????] ，修改這個跳轉的目標讓它跳回原調用者。最大的問題在於cdecl可以不定參數長度，由調用者清棧，如何為傳給目標函數的參數清棧就成了問題。於是這裡利用了一個stdcall 函數負責傳參，主動替換掉返迴路徑到trampoline，再從trampoline到原函數的一個標籤。

貼個當時一個功能效果，拖拽滑鼠完美力場：

http://v.youku.com/v_show/id_XNzk4MTc3NjMy.html?sharefrom=iphone

在 .c 文件里，用include和main開個頭，配上各種小括弧和大括弧。

然後是#asm{ }；//在C文件里嵌入彙編指令的意思。

把所有的程序都寫在上述的大括弧中。也就是在C語言里完全嵌入彙編指令，所有程序都是彙編。

{-# LANGUAGE DataKinds #-}

{-# LANGUAGE ConstraintKinds #-}

type family Min :: Nat -&> Nat -&> Nat where

type family Lcm :: Nat -&> Nat -&> Nat where

type Divides n m = n ~ Gcd n m

newtype Magic n = Magic (KnownNat n =&> Dict (KnownNat n))

magic :: forall n m o. (Integer -&> Integer -&> Integer) -&> (KnownNat n, KnownNat m) :- KnownNat o

axiom :: forall a b. Dict (a ~ b)

然後這時候，可以說， unsafeCoerce 的事，能叫作弊嗎

euclideanNat :: (1 &<= c) :- (a ~ (c * Div a c + Mod a c))

plusCommutes :: forall n m. Dict ((m + n) ~ (n + m))

timesCommutes :: forall n m. Dict ((m * n) ~ (n * m))

minCommutes :: forall n m. Dict (Min m n ~ Min n m)

maxCommutes :: forall n m. Dict (Min m n ~ Min n m)

plusAssociates :: forall n m o. Dict (((m + n) + o) ~ (m + (n + o)))

timesAssociates :: forall n m o. Dict (((m * n) * o) ~ (m * (n * o)))

minAssociates :: forall n m o. Dict (Min (Min m n) o ~ Min m (Min n o))

maxAssociates :: forall n m o. Dict (Max (Max m n) o ~ Max m (Max n o))

gcdAssociates :: forall a b c. Dict (Gcd (Gcd a b) c ~ Gcd a (Gcd b c))

lcmAssociates :: forall a b c. Dict (Lcm (Lcm a b) c ~ Lcm a (Lcm b c))

minIsIdempotent :: forall n. Dict (Min n n ~ n)

目前寫過最炫技的項目是CSAPP的datalab。。。

最炫技的代碼是datalab中的ilog2。。。

目標是用最少的legal ops（不計賦值符號=）實現對正數log2並取整的函數，常數只能用0x00~0xFF，類型只能用int/unsigned，不能用for、while、if等控制語句或其他函數。

只用了19個ops~

/*
* ilog2 - return floor(log base 2 of x), where x &> 0
* Example: ilog2(16) = 4
* Legal ops: ! ~ ^ | + &<&< &>&>
* Max ops: 90
* Rating: 4
*/
int ilog2(int x) {
int ans = (!(x &>&> 16)) &<&< 4; ans ^= (!(x &<&< ans &>&> 24)) &<&< 3; ans ^= 28; ans ^= (!(x &>&> ans)) &<&< 2; x = x &>&> ans;
ans ^= ((~0x5B) &>&> (x 30)) 3;
return ans;
}


貼個完整的當時的datalab的代碼：https://github.com/Seterplus/CSAPP/blob/master/datalab/bits.c

char add_1_byasm(char data) {
/*
pcode:
mov_reg_ptr eax,ptr_buffer 65, 03, 00, xx, xx, xx, xx
runasm ptr_data,3 99, xx, xx, xx, xx, 03, 00, 00, 00
mov_ptr_reg ptr_buffer,eax 65, 04, xx, xx, xx, xx, 00
*/
BYTE pcode_l[] = {
0x65, 0x03, 0x00,/*here*/0x00, 0x00, 0x00, 0x00,// 7
0x99,/*here*/0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,// 9
0x65, 0x04,/*here*/0x00, 0x00, 0x00, 0x00, 0x00,
0x00
};

VMACHINE VM;
int t = 0;
t = data;
int * ptr_data = t;
void * ptr_asmcode = ASMCode;
memcpy(pcode_l[3], ptr_data, 4);
memcpy(pcode_l[8], ptr_asmcode, 4);
memcpy(pcode_l[18], ptr_data, 4);
VM_Init(VM);
VM_Run(VM, pcode_l);
VM_Destroy(VM);
return (char)t;
}


當然是一個可以一邊模擬一邊隨便和真實環境切換的VM了

a=a^b；

當年大一時驚呆一眾小夥伴

_Static_assert/static_assert 之前的變通方式、宏中使用 {} 的標準手法，都沒什麼炫技成分吧…

說到宏的話還有這個：

預覽地址：

這就是預覽地址：方正的React實驗室（手機上看也可以，就是字體比較小）

這是項目地址：方正github「無恥求：星，沒星點贊，哈哈哈」

以前寫C++的時候沒能寫過啥絢麗技巧，後面學前端的時候倒是寫了不少。

80+代碼實現一個React版本的酷炫動效簡歷，之前寫的一個，這種炫技方式不難又簡單...

不是c++也來湊個熱鬧啦..

我們來實現下斷言,但是標準C不輸出函數名(不影響)，為了炫(裝)技(逼)，我們當然要加上啦！不得不說宏定義實在是太牛啦~

// assert.h

@mika

有一天，

我照常打開供職公司豈安科技的官方主頁，

手癢右鍵查看『網頁源代碼』，

看到了如下產物：

真身在這裡

我們的程序猿GG和程序猿小姐姐，也是悄咪咪羞澀萌的（筆芯）