min 巨集定義 避免副作用
阿新 • • 發佈：2019-02-03
min巨集定義探究 在GCC的文件中建議使用如下的min巨集定義：
({ /
typeof(X) __x=(X), __y=(Y); /
(__x<__y)?__x:__y; /
}) /
)
本文討論了這樣作法的意義。
1、傳統的min帶來的副作用
2、GCC中的({statement list})的擴充套件
3、typeof(expression)
4、__extension__的含義
5、使用typeof和({})實現min，避免了副作用
附錄1、舊版本的的GCC中的的解決方法
附錄2、C++中使用template的解決方法
1、傳統的min帶來的副作用
min通常被定義成這樣的巨集：
#define min(X,Y) ((X) < (Y) ? (X) : (Y))
這種定義會帶來一些副作用，看下面的例子：
int x = 1, y = 2;
int main()
{
printf("min=%d/n", min(x++, y++));
printf("x = %d, y = %d/n", x, y);
}
執行完min(x++、y++)，我們期望x的值為2，y的值為3。
但是，實際的結果是，執行完mini(x++、y++)後，x的值為3，y的值為3，原因在於巨集展開後x++被執行了兩次：
引用：
int x = 1, y = 2;
int main()
{
printf("min=%d/n", x++ < y++ ? x++ : y++);
printf("x = %d, y = %d/n", x, y);
}
2、GCC中的({statement list})的擴充套件
({statement list})是一個表示式，逗號表示式類似，但是功能更強，({與})中可以包含有多條語句(可以是變數定義、複雜的控制語句)，該表示式的值為statement list中最後一條語句的值，舉例：
int main()
{
int result = ({
int i, sum = 0;
for (i = 1; i <= 100; i++)
sum+= i;
sum;
})
printf("result=%d/n", result);
}
執行結果：
result=5050
3、typeof(expression)
typeof(expression)用來獲取expression的型別，舉例：
int main()
{
int integer;
typeof(100) i; /* 表示式100的型別是int，定義了int型變數i */
typeof(integer) j; /* 表示式integer的型別是int，定義了int型變數j */
i = 1;
j = 2;
}
4、__extension__的含義
GCC引入了很多標準C中的沒有的擴充套件，如({和)}，GCC提供了pednatic選項用於檢測程式是否使用了GCC的擴充套件，當使用pedantic選項編譯如下程式時
int main()
{
int result = ({
int i, sum = 0;
for (i = 1; i <= 100; i++)
sum+= i;
sum;
})
printf("result=%d/n", result);
}
編譯器發出警告：
$ cc -pedantic test.c
test.c: 在函式 ‘main’ 中：
test.c:9: 警告：ISO C 不允許在表示式中使用花括號組
編譯器提醒程式設計師，這段C程式使用了不符合ISO C標準的語法，如果使用其他的編譯器(非GCC)編譯這段程式碼有能會出錯。在所有使用GNU 擴充套件關鍵字的表示式之前加__extension__ 關鍵字後，使用pedantic選項編譯時，編譯器就不再發出警告資訊:
int main()
{
int result = __extension__({
int i, sum = 0;
for (i = 1; i <= 100; i++)
sum+= i;
sum;
})
printf("result=%d/n", result);
}
$ cc -pedantic test.c
$ 編譯成功！
5、使用typeof和({})實現min，避免了副作用
#define min(X,Y) /
({ /
typeof(X) __x=(X), __y=(Y); /
(__x<__y)?__x:__y; /
})
使用傳統的min會出現問題的例子：
int x = 1, y = 2;;
int main()
{
printf("min=%d/n", min(x++, y++));
printf("x = %d, y = %d/n", x, y);
}
它被擴充套件為
引用：
int x = 1, y = 2;;
int main()
{
printf("min=%d/n", ({
typeof(x) __x = (x++), __y = (y++); /* 定義了兩個整形變數 */
(__x<__y)?__x:__y;
})
);
printf("x = %d, y = %d/n", x, y);
}
在執行min(x++, y++)期間，x++和y++只執行了一次，因而結果是正確的。
附錄1、舊版本的的GCC中的的解決方法
舊版本的GCC提供了兩個內建的運算操作符：?， ?返回兩個運算元中較大的一個，使用這兩個操作符定義的min如下:
#define min(x, y) ((x) #define max(x, y) ((x) >? (y))
但是新版本的GCC文件中宣稱：現在這兩個運算操作符已經過時了，建議大家不要使用。
附錄2、C++中使用template的解決方法
template
type min(type a, type b)
{
return a < b ? a : b;
}
來源： http://www.chinaunix.net/jh/23/934870.html
add linux kernel min, max define:
include/linux/kernel.h
/*
* min()/max() macros that also do
* strict type-checking.. See the
* "unnecessary" pointer comparison.
*/
#define min(x,y) ({ /
typeof(x) _x = (x); /
typeof(y) _y = (y); /
(void) (&_x == &_y); /
_x < _y ? _x : _y; })
#define max(x,y) ({ /
typeof(x) _x = (x); /
typeof(y) _y = (y); /
(void) (&_x == &_y); /
_x > _y ? _x : _y; })
Min和Max巨集：
/*
* min()/max() macros that also do
* strict type-checking.. See the
* "unnecessary" pointer comparison.
*/
#define min(x,y) ({ typeof(x) _x = (x); typeof(y) _y = (y); (void) (&_x == &_y); _x < _y ?_x : _y; })
#define max(x,y) ({ typeof(x) _x = (x); typeof(y) _y = (y); (void) (&_x == &_y); _x > _y? _x : _y; })
/*
* ..and if you can't take the strict
* types, you can specify one yourself.
*
* Or not use min/max at all, of course.
*/
#define min_t(type,x,y) ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })
#define max_t(type,x,y) ({ type __x = (x); type __y = (y); __x > __y ? __x: __y; })
不是感覺跟我們用的有些不一樣啊:
(void) (&_x == &_y);
(void) (&_x == &_y)這句話本身都執行程式來講完全是一句廢話，它的作用在於，本身我們無法做這樣的操作typeof(_x)==typeof(_y)，所以故意判斷他們2個的地址指標是否相等，顯然是不可能相等，但是如果_x和_y的型別不一樣，其指標型別也會不一樣，2個不一樣的指標型別進行比較操作，會丟擲一個編譯警告。也就是說char *p; int *q; 然後p==q;，這個判斷因為一個是char*一個是int*，會在編譯時產生一個warning。巧妙就巧妙在這裡。
由於核心是很多開發著一起開發的，其中還有一些其他的實現，就跟我們平常用的一樣：
#define min(a,b) (((a) < (b)) ? (a) : (b))
試想：
min(++a,++b) ==> ((++a)<(++b))?(++a):(++b)
是不是就有問題了，傳入的引數被加了兩次。
引用：
#define min(X,Y) /
(__extension__ /({ /
typeof(X) __x=(X), __y=(Y); /
(__x<__y)?__x:__y; /
}) /
)
本文討論了這樣作法的意義。
1、傳統的min帶來的副作用
2、GCC中的({statement list})的擴充套件
3、typeof(expression)
4、__extension__的含義
5、使用typeof和({})實現min，避免了副作用
附錄1、舊版本的的GCC中的的解決方法
附錄2、C++中使用template的解決方法
1、傳統的min帶來的副作用
min通常被定義成這樣的巨集：
#define min(X,Y) ((X) < (Y) ? (X) : (Y))
這種定義會帶來一些副作用，看下面的例子：
int x = 1, y = 2;
int main()
{
printf("min=%d/n", min(x++, y++));
printf("x = %d, y = %d/n", x, y);
}
執行完min(x++、y++)，我們期望x的值為2，y的值為3。
但是，實際的結果是，執行完mini(x++、y++)後，x的值為3，y的值為3，原因在於巨集展開後x++被執行了兩次：
引用：
int x = 1, y = 2;
int main()
{
printf("min=%d/n", x++ < y++ ? x++ : y++);
printf("x = %d, y = %d/n", x, y);
}
2、GCC中的({statement list})的擴充套件
({statement list})是一個表示式，逗號表示式類似，但是功能更強，({與})中可以包含有多條語句(可以是變數定義、複雜的控制語句)，該表示式的值為statement list中最後一條語句的值，舉例：
int main()
{
int result = ({
int i, sum = 0;
for (i = 1; i <= 100; i++)
sum+= i;
sum;
})
printf("result=%d/n", result);
}
執行結果：
result=5050
3、typeof(expression)
typeof(expression)用來獲取expression的型別，舉例：
int main()
{
int integer;
typeof(100) i; /* 表示式100的型別是int，定義了int型變數i */
typeof(integer) j; /* 表示式integer的型別是int，定義了int型變數j */
i = 1;
j = 2;
}
4、__extension__的含義
GCC引入了很多標準C中的沒有的擴充套件，如({和)}，GCC提供了pednatic選項用於檢測程式是否使用了GCC的擴充套件，當使用pedantic選項編譯如下程式時
int main()
{
int result = ({
int i, sum = 0;
for (i = 1; i <= 100; i++)
sum+= i;
sum;
})
printf("result=%d/n", result);
}
編譯器發出警告：
$ cc -pedantic test.c
test.c: 在函式 ‘main’ 中：
test.c:9: 警告：ISO C 不允許在表示式中使用花括號組
編譯器提醒程式設計師，這段C程式使用了不符合ISO C標準的語法，如果使用其他的編譯器(非GCC)編譯這段程式碼有能會出錯。在所有使用GNU 擴充套件關鍵字的表示式之前加__extension__ 關鍵字後，使用pedantic選項編譯時，編譯器就不再發出警告資訊:
int main()
{
int result = __extension__({
int i, sum = 0;
for (i = 1; i <= 100; i++)
sum+= i;
sum;
})
printf("result=%d/n", result);
}
$ cc -pedantic test.c
$ 編譯成功！
5、使用typeof和({})實現min，避免了副作用
#define min(X,Y) /
({ /
typeof(X) __x=(X), __y=(Y); /
(__x<__y)?__x:__y; /
})
使用傳統的min會出現問題的例子：
int x = 1, y = 2;;
int main()
{
printf("min=%d/n", min(x++, y++));
printf("x = %d, y = %d/n", x, y);
}
它被擴充套件為
引用：
int x = 1, y = 2;;
int main()
{
printf("min=%d/n", ({
typeof(x) __x = (x++), __y = (y++); /* 定義了兩個整形變數 */
(__x<__y)?__x:__y;
})
);
printf("x = %d, y = %d/n", x, y);
}
在執行min(x++, y++)期間，x++和y++只執行了一次，因而結果是正確的。
附錄1、舊版本的的GCC中的的解決方法
舊版本的GCC提供了兩個內建的運算操作符：?， ?返回兩個運算元中較大的一個，使用這兩個操作符定義的min如下:
#define min(x, y) ((x) #define max(x, y) ((x) >? (y))
但是新版本的GCC文件中宣稱：現在這兩個運算操作符已經過時了，建議大家不要使用。
附錄2、C++中使用template的解決方法
template
type min(type a, type b)
{
return a < b ? a : b;
}
來源： http://www.chinaunix.net/jh/23/934870.html
add linux kernel min, max define:
include/linux/kernel.h
/*
* min()/max() macros that also do
* strict type-checking.. See the
* "unnecessary" pointer comparison.
*/
#define min(x,y) ({ /
typeof(x) _x = (x); /
typeof(y) _y = (y); /
(void) (&_x == &_y); /
_x < _y ? _x : _y; })
#define max(x,y) ({ /
typeof(x) _x = (x); /
typeof(y) _y = (y); /
(void) (&_x == &_y); /
_x > _y ? _x : _y; })
Min和Max巨集：
/*
* min()/max() macros that also do
* strict type-checking.. See the
* "unnecessary" pointer comparison.
*/
#define min(x,y) ({ typeof(x) _x = (x); typeof(y) _y = (y); (void) (&_x == &_y); _x < _y ?_x : _y; })
#define max(x,y) ({ typeof(x) _x = (x); typeof(y) _y = (y); (void) (&_x == &_y); _x > _y? _x : _y; })
/*
* ..and if you can't take the strict
* types, you can specify one yourself.
*
* Or not use min/max at all, of course.
*/
#define min_t(type,x,y) ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })
#define max_t(type,x,y) ({ type __x = (x); type __y = (y); __x > __y ? __x: __y; })
不是感覺跟我們用的有些不一樣啊:
(void) (&_x == &_y);
(void) (&_x == &_y)這句話本身都執行程式來講完全是一句廢話，它的作用在於，本身我們無法做這樣的操作typeof(_x)==typeof(_y)，所以故意判斷他們2個的地址指標是否相等，顯然是不可能相等，但是如果_x和_y的型別不一樣，其指標型別也會不一樣，2個不一樣的指標型別進行比較操作，會丟擲一個編譯警告。也就是說char *p; int *q; 然後p==q;，這個判斷因為一個是char*一個是int*，會在編譯時產生一個warning。巧妙就巧妙在這裡。
由於核心是很多開發著一起開發的，其中還有一些其他的實現，就跟我們平常用的一樣：
#define min(a,b) (((a) < (b)) ? (a) : (b))
試想：
min(++a,++b) ==> ((++a)<(++b))?(++a):(++b)
是不是就有問題了，傳入的引數被加了兩次。