C言語＠便利なマクロ

Ｃ言語、Ｃ＋＋の便利なマクロを紹介すれ。

とりあえず、頭は簡単な

#define PI 3.141592f
#define DEG_2_RAD(n) (n * PI / 180.0f)

から。

×　>>1 とりあえず、頭は簡単な
○　>>1 俺はゴミマクロ。
○　　　　　さあ早く優秀なマクロおくれよ〜〜（クレクレクレクレ

#define TRUE 1
#define FALSE 0

#define FALSE 0
#define TRUE ~FALSE

>>1
#define DEG_2_RAD(n) ((n) * PI / 180.0f)

の方が良くない？

#define STATIC_ASSERT(expr) { char dummy[(expr) ? 1 : 0]; }

定番。

// 配列の要素数を戻す
#define numberof(v) (sizeof (v) / sizeof *(v))
// VC++ 6.0 で、for () 内で定義した変数のスコープをC++標準に
#define for if (0); else for

>>5
×　の方が良くない？
○　とするべき。

#define DQN ">>1"

#define NOP 0

>>6
初めて知りました。
が、これだと偽でもコンパイル通っちゃわない?
　#define STATIC_ASSERT(expr) { char dummy[(expr) ? 1 : -1]; }
ではないかと思うんだけど…

C言語でstatic assertなぞ滅多に使わないから、コンパイルとおっても大丈夫

#define SWAP(a,b) { int temp; temp = a; a = b; b = temp;}

VC8.0でMSCRTに_countofマクロ追加されたよな。

hoge.h
#ifndef HOGE_H
#define HOGE_H
/*******/
#endif

#define offsetof(s,m) (size_t)&(((s *)0)->m)


#define __STR2__(x) #x
#define __STR1__(x) __STR2__(x)
#define __LOC__ __FILE__ "("__STR1__(__LINE__)") : "

>>14
offsetof って標準C にあるんだけどね。C99 からだっけ？

>>14
__LOC__ マクロすごいな
__STR1__、__STR2__ と2段にしないといけないのは、どういう仕組みになってるんだろう？
わかる人いる？

__LOC__が意図どおりになるかはコンパイラによる。
__LINE__はマクロの皮を剥いでも、数字にならない場合がある。

定数はenumつかおうぜー

>>18なんで？

enumならデバッガが拾ってくれるからとかどうたらこうたら

enumだと整数縛りだから…

enumはenum以外の何者でもなさげ

あ、C++じゃなくてCだから安心して整数扱いできるのか。

おいコラ、どっからC++の話が出てくるんだよ

>>1を読む限りC++も含めてネタ出しOKのようだが

Boost.Preprocesser

ホントだ。ｽﾏｿ

#define iskanji(c) ((c)>=0x81 && (c)<=0x9F || (c)>=0xE0 && (c)<=0xFC)
#define iskanji2(c) ((c)>=0x40 && (c)<=0xFC && (c)!=0x7F)

ShiftJISは死んでほしい。

よし、Unicodeだ！

将来的にはSJISは無くなるから大丈夫。

何十年後だろう

#define _LABEL(X,Y) __##X##__##Y##__
#define BLOCK(L) if (0) _LABEL(BREAK,L):; else _LABEL(CONTINUE,L):
#define BREAK(L) goto _LABEL(BREAK,L)
#define CONTINUE(L) goto _LABEL(CONTINUE,L)

int main()
{
BLOCK(X) {
BLOCK(Y) {
BREAK(X); /* Great! */
}
printf("end of Y\n");
}
printf("end of X\n");

CONTINUE(Y); /* Oops! */

return 0;
}

　　　　[ ﾟдﾟ]y-~~~　ﾃﾞﾌﾗｸﾞｶﾞｶﾝﾘｮｳｼﾏｼﾀ
　　　　/[へへ
!!""""############(((((((((((((((())))))))))))))))
****,,,,,////00::;;;;;;AAAAAAAAABBBBBBBBBBBBCCCCCCCEEEEEEEEEEEEEGIIIIKKKKKKKLLLLLLLL
LLLLLLLLLLLLNNNNNNNNOOOOOOOORRRRTTTTUUUUXXXXXYYYYY\\___________aaddddddeeeeeeeee
eeeeefffffffffggiiiiiiiiilmnnnnnnnnnnnnnoooooooppprrrrrsstttttttu{{{}}}

マクロでtry-catch実装するやつ。使える。

age

#define begin {
#define end }

>>36
絶対誰かが書くと思っていた

#define until while!(
#define ifn if!(
#define loop for(;;){

ところで define でググると「#define」って同人サークルのサイトがトップに来るのな。
予約語をサークル名（サイト名）にするとは考えたな。
俺もなんかの予約語でWebサイト作ればウハウハかな？

おっと loop は for(;;) だけでよかった

C/C++のマクロってホントださいよね
Lispサイコー

インライン関数じゃだめ？


ところでこのスレタイは「便利なマクロ＠C言語」が正しいんじゃないかと思うんだが。。。

基本だけど
#if 0
#else
でコメントアウト。
/* */と違ってネストできる。

for(;;)よりwhile(1)が好きだな

最適化されないコンパイラだといちいち1が0以外であることを比較してしまいそうだ

>>38
>if!(
>while!(
(　´,_ゝ｀)
初心者がマクロを使うとろくな結果にならない典型ですね。

>>45-46
バカにつっこむバカの典型

>>46は自虐的だな

#define loop for(;;){
の一行も怪しくないか？
loop{sum++;}にしたらとっても美味しくないぞ

#define if if(rand()%3) if

>>49
とっても便利だ

何に使うの？

嫌がらせ

C言語＠糞マクロ にタイトル変えろ

ここは実践で使えない糞マクロを上げるスレでつねｗ

能無しが噛み付いてるｗ

static assert

static void SASSERT_(void *) { }
#define SASSERT(b) SASSERT_(!(b))

b が静的な真値定数なら
引数が 0 になってヌルポインタとして扱えるため
コンパイルが通る。
何も処理しないため、最適化で削除される。

b が静的な偽値定数なら
引数が 1 になってポインタとして扱えないため
コンパイルに失敗する。

>>56
>>6

>>57
>>56 はコンマ演算子で繋げば式中で使える。
値に置換されるようなマクロの
引数チェックに使ったりできる。

>>6 は文としてしか使えないから、
>>56 より適用範囲が狭い。

>>58
確かに式として使えるけど
コンパイルエラーを検出したいだけなのに
そんなにメリットがあるの？
if(SASSERT(CHAR_BIT==8)) {
}
のようにifで囲っても見辛くなるだけだし、
コンマ演算子で繋げるっていっても
SASSERT(sizeof(int)==4),SASSERT(sizeof(void*)==4),・・・;
とかしても可読性が下がるだけような…（いずれも自分的には）
何か良い使い方があるなら教えて。

>>59
#define BIT(n)　(1u << (n))

というマクロがあるとする。
これを、n を静的な定数に制限する代わりに
静的に n の値をチェックしてくれるようにしたいとする。
こういう場合にこのタイプの SASSERT が使える。

#define SBIT(n)　(SASSERT(0 <= (n) && (n) < CHAR_BIT * sizeof (unsigned)), 1u << (n))

静的だから n に副作用はないから
n が複数出る事に問題は無い。

>>60
それは(・∀・)ｲｲ!!
と思ったけど自分の環境だと
例えば
int x=SBIT(-1);
int y=SBIT(16);
int z=SBIT(100);
として、
Cソースとしてコンパイルすると
警告が出るだけでコンパイルが通っちゃうし、
C++ソースとしてコンパイルすると
どれもboolからvoid*へ変換できないって
エラーが出てしまう。(;´Д｀)

Cはvoid*に対する扱いが緩すぎて、こういう用途には向かないな。
全環境に-Wallを付けさせるわけにもいかないし…
C++は逆にvoid*に厳しすぎて使えない。
C++ならtemplateを使って実現出来るから、そっちを使った方が
エラーメッセージの質から考えてもいいだろうけど。

静的と言いながら引数に変数を指定できてしまうのも問題だな。
>>6なら変数を指定しても標準C/C++ならエラーになるし。

>>3-4

TRUEとかFALSEとか定義せずに、そのまんま数値を使えよって、最近は思うようになった。

>>64
つ[stdbool.h]

>>61
>C++
なるほど。確かに bool になっちゃうね。

#define SASSERT(b) SASSERT_((b) ? 0 : 1)

にすればＯＫか。

>>63
変数入れれば警告はされる。
エラーじゃないのは・・・仕方が無い。

C は結構緩いんだな。
ポインタに int 代入して警告ですむなんて。
というわけで、折衷案を考えた。

void SASSERT_(int(*p)[1]) { }
#define SASSERT(b) SASSERT_((int(*)[(b) ? 1 : -1])0)

キャストだけでもいいんだけど、
単独で使うと、意味の無い式だっていう警告が出てウザいから、
ダミーの関数を通すようにした。

×意味の無い式
○意味の無い文

間違えた。

あげ

#define block if(1)for(int i=0;i<1;i++)

void main()
{
block
{
printf("foo\n");
break;
printf("bar\n");
}
}

実行結果：
>foo
>

>>70
必要性をまったく感じないんだが…

breakで抜けられる、continueでblockの頭に戻れる、ぐらいかなあ。
既存のgoto使ったコードからむりやりgoto排除するには使えるかも。
でもC++じゃあねえ、そもそもそんなことしないか。

というかif(1)の意味がわからない。
カビの生えたコンパイラ対策ならif(0){}else ifだろうし
>>72
continueしても++iで結局脱出

>>73
おー、そうでした。
ますます>>70の真意が分からない…

俺ならこう定義する。

#define block switch(0) default:

どっちゃにしろ使わんと思うけど。

このスレタイは「C言語＠不便なマクロ」の間違いなんじゃないだろうか

C言語＠時代遅れのマクロ

なら便利なマクロを投下すればいい。

マクロならできて、インライン関数とテンプレートでできないことを教えてくれ。

>>79
#ifでの利用。

#define FOO 1
#if FOO
...;
#else
...;
#endif

>>79
>>75 こういう系統のマクロ。

>>80
const int FOO = 1;
if(FOO){...;}else{...;}
じゃだめなの？
実行されない側のブロックは最適化によって除去されるから容量面でも速度面でも変わらない気がするんだけど

お前は何を言ってるのかと小一時間・・・
それだと関数内の処理でしか使えんじゃないのよ。

ああそうか、#if〜#endif内で関数の宣言とかしたいってことか。じゃあ

const FOO;
template <int FOO> class{...};
template <0> class{...};

でどうだろ？ だめかな？

おっと名前付けるの忘れた。

template <int FOO> class foo{...};
template <0> class foo{...};

んー、FOOとfooで名前を2個登場するのがちょっと嫌だな。

何それ？テンプレートの特殊化のつもり？

何でこんなに使用状況を限定するのか理解できんな。
#ifdef 使った事ないのかね。

ごめん特殊化ってどうやるんだっけ。
なれない事はするもんじゃないね。
えーと

const FOO;
template <int FOO> class foo{...};
template<> foo<0>{...};

こうだっけ？

まあとにかく、C++ならマクロは使わないでもいけるんじゃないかなーと言いたかったのです。
すまん、がんばって勉強すっから許して。

#ifdefはさすがに無理だな。

とりあえず二重インクルードガードを
マクロ無しで書けるもんなら書いてみろ。
ただし、コンパイラ固有の方法での二重インクルードガードは無しな。

#ifdef _DEBUG
とか結構使いどころ多いと思うが

予約語置き換えとかも無理だね。
#define local static
みたいなやつ

__FILE__ や __LINE__ を自動で引数に入れたい時とかもマクロ必須だな。
inline だとそっちのファイル名と行番号が使われてしまう。

>>88
クラスとか関数だけならその方法でもいける。

enum { FOO = 0 };
template <int FOO> class foo{...};
template<> foo<0>{...};

foo<FOO> food;
こんな感じかな？

__RAND__とかあったら便利なんだけど、
乱数生成するマクロ。
誰か作ってよ

#define __RAND__ rand()

ほれ

>>96そういうんじゃなくて
静的に乱数を生成したいってことなんだけどｗｗｗ

ネタをネタと（ry

#define __RAND_NEXT__(next) (((next * 1103515245L + 12345) / 65536L) % 32768U)
#define __RAND__ (__RAND_NEXT__(__RAND_NEXT__(__RAND_NEXT__(__LINE__))))

同一行で使えないが

コンパイルごとに違う値が出るものといえば __DATE__ マクロと __TIME__ マクロがあるから、
「コンパイルごとに違う値が出る」というのだけを実現する事は可能。
ただし、こいつらどっちも文字列だから、
そこから得た値を使って配列のサイズに指定したりとか、そういうのは無理だけど。

>>100
文字列を数値に変換するマクロって無かったっけ？

文字列化ならできるけれど、数値化はﾐﾘ

擬似2進数ﾏｸﾛ。　たまーに欲しくなる

#define HEX_0000 0x00
#define HEX_0001 0x01
　　...
#define HEX_1111 0x0f
/* ｾﾞﾛｻﾌﾟﾚｽを面倒みるなら
　#define HEX_0 0x00
　#define HEX_1 0x01
　#define HEX_10 0x02
　#define HEX_11 0x03
とかも追加な
*/
#define BIN4(a) (HEX_ ## a)
#define BIN8(a, b) ((HEX_ ## a) << 4 + ((HEX_ ## b))

もっといい方法があるよ。

ヒントは 0x##n とビット演算

GEMのｺｰﾄﾞっしょ？　＜ 0x ## n ﾀｲﾌﾟ

それと例の静的 ASSERT を組み合わせれば
引数チェックもできるってぇ寸法だ。

>>106
自分で考えた。
GEM は知らんが、あるというのならあるんだろうね。

数値リテラルを記述するのに
0 <digits> や 0x <digits> があるのに
0b <digits> が無いは何か理由があるのだろうか・・・

0b00100100101000000100000010011000

とか書かれても困るからじゃね？
D 言語ではそこのところを、
区切りを入れられるようにして解決してる。

>>110
確かに連続して書くと見難いな。
D言語での区切り文字は 空文字(TAB/SPC/改行) ?

0b00100100101000000100000010011000
　↑等価↓
0b 0010 0100 1010 0000
　　0100 0000 1001 1000

確かアンダースコアだったと思う。

0b__0010_0100__1010_0000__0100_0000__1001_1000

こんな感じ。

herumi氏のHPにtemplateでやる方法が書いてあったな。

boostでそんなマクロなかったっけ？

「C言語:2進数表記マクロ」はがいしゅつ？
ttp://homepage1.nifty.com/aok2/004/c02.html

>>115
>>103-107

昔その逆パターンに着手した

#define bit(i)　( ( i & 1 ) \
　　　　　　　| ( i & 1 << 1 ) << 0x2 \
　　　　　　　| ( i & 1 << 2 ) << 0x4 \
　　　　　　　| ( i & 1 << 3 ) << 0x6 \
　　　　　　　| ( i & 1 << 4 ) << 0x8 \
　　　　　　　| ( i & 1 << 5 ) << 0xa \
　　　　　　　| ( i & 1 << 6 ) << 0xc \
　　　　　　　| ( i & 1 << 7 ) << 0xe )

printf("%o\n", bit(255));
11111111

使う場皆無

関数でやる仕事って気もするけどなあ。

展開後が即値になるからマクロにする意義がある。

俺も初心者の頃、2進数の表記がないのを不思議に思った。
処理系の拡張機能で 0b1010 とか書けるのもあるが、一般性がない。
マクロを作ろうと考えたが、当時の俺では無理だった。
何年も後になって、>>115 で紹介されてるマクロを知ったときには感激したよ。

つーか脳内で2進⇔16進変換しろよ

組み込み分野とかではビットのON/OFFに意味があるケースが頻出する。
そんなときは2進数で書くと可読性が向上するんだよ。

とてもそうは思えんが・・・
具体例を書いて欲しいところ。

俺はレジスタにビットフィールドでアクセスしたりするが。
レジスタアクセスは機種依存なので、移植性は気にしない。
どのようにコードに落ちるかわからなければ、割り込み関連のレジスタ等の
ちょっと特殊なものではバグを出す可能性が高くなるのでおすすめはしない。

ただ、コンパイラによっては、char等のビットフィールドでもintでアクセスする。
そういう生真面目な実装をしているコンパイラは、コンパイル時に
ビットフィールドはint以外はダメよと教えてほしい。

＞char等のビットフィールド
すまん、詳しく教えてくれ。Cのビットフィールドに種類があるとは初耳なもんで。

>>124
生真面目だな。規格オタか？

皮肉っているだけだろ。

ビットフィールドを定義したヘッダーファイルが用意されてない場合、
マイコンのレジスタを初期化するためだけに自分でビットフィールドを定義するのも面倒。
どうせ暗号みたいな名前しか付けられないから、それほど読みやすくもならない。
そんなときは直接16進数で代入しちゃうわけだが、2進数で書けるならその方がいい。

>>124
ビットフィールドは処理系依存だ。最上位ビットから詰めるか最下位ビットから詰めるか
それすら決まってない。int境界をまたぐ場合なんかも注意が必要。

>127
> そんなときは直接16進数で代入しちゃうわけだが

飛びすぎ。
まずレジスタの各flagごとにアクセスマクロを定義しないか

そう来ると思ったｗ
余裕があればそうする。
仕様変更で数値が変わりそうな部分は面倒でもマクロとか使うよ。

Windowsでﾘｿｰｽ使わずに bitmap を作るのに使ったな

2値のグラフィックデータを自作する場合に便利だね。
モノクロ液晶表示器に描画するアイコンとかフォントを定義するのに使ったことある。

分かち書き無しの 64bits ２進数なんてみたくねー

int mask = 0b0110000101000110010011000110001000011001000101101000010110001001;

int じゃなかった・・・。

INLINE( FunctionName ) と書いて
#pragma inline FunctionName
に置き換わるマクロを書きたいのですがどのように定義したらいいでしょうか？

>>134
環境によってはintが64bitかも

>>135
Ｃ言語の範疇じゃ無理。
どうしても対応したいなら
自分でプリプリプロセッサでも作って
コンパイル前にソースに手を加えるしかない。

C99だと_Pragmaが使えると思う。

#define A 1
#define B 2
と定義されているときに
func_1_2 という識別子を生成するマクロはどのように定義すればよいでしょうか？
VC では
#define X(n) n
#define Y() _
#define FUNC() func
#define FUNC_A_B FUNC()Y()X(A)Y()X(B)
のように定義できるのですが GCC ではできませんでした。

>>139
こんなんでできね？
#define FUNC_2(x, y) func_##x##_##y
#define FUNC_A_B FUNC_2(A, B)

>>140
GCC で確認したら func_1_2 ではなく func_A_B になってしまいました。

エラーチェック無しプロパティマクロ

#define GET_FUNC(name,type,var) type Get##name(){return var;}
#define SET_FUNC(name,type,var) void Set##name(type new){var=new;}
#define DEF_FUNC(name,type,var) GET_FUNC(name,type,var)\
SET_FUNC(name,type,var)

>>139
#define FUNC_2_(x, y) func_##x##_##y 
#define FUNC_2(x, y) FUNC_2_(x,y) 
#define FUNC_A_B FUNC_2(A, B) 

この手の中継マクロはなんで必要なんだろ

>>144
昔のプリプロセッサの仕様との後方互換性。
負の遺産とも言う

相続拒否してえ…

#define FUNC_2(x, y) func_##x##_##y
#define FUNC_A_B FUNC_2(A, B)

FUNC_A_B → FUNC_2(A, B) → func_A_B


#define FUNC_2_(x, y) func_##x##_##y
#define FUNC_2(x, y) FUNC_2_(x,y)
#define FUNC_A_B FUNC_2(A, B)

FUNC_A_B → FUNC_2(A, B) → FUNC_2_(1,2) → func_1_2


となるからだな。

##の引数として使われるマクロ引数は展開（評価）されないってこと？

引数にマクロ名を渡した場合、
実際にそのマクロが展開されるのは一段階遅れる。
func_1_2 じゃなくて func_A_B ってのを実際に作りたい時とか、
すぐ展開されると困るっしょ？

>>39
foreverって有名だろ
世代差？

俺はforever使うよ。

forever と定義した事もあるが、
別に for(;;) で困る事ないので定義しなくなった。

あげます

#define forever for(;;)
#define unless(cond) if(!(cond))
#define until(cond) while(!(cond))

>>150-152
forever/for(;;)は知ってるけど、キモイから
俺はwhile(true)/while(1)を使う。

ANSIから見放されるやつ乙

同僚から見放されるコード書くよりマシｗ

for (;;)を書いて見放されるような同僚なら、こっちから願い下げだ。

while(1) はマジックナンバーがあってキモい。
while(true) はかろうじて許せる。

while(1)はマジックナンバーなのか？？

>>158
馬鹿でも読めるコードを日頃から心がけておかないと、
いつまでたっても自分でメンテしなきゃいけなくて
コードの手離れが悪くなるぞ。

古めのｺﾝﾊﾟｲﾗだと警告になることあるね 　while(1)

lint の類も while(1) には警告出るよ。
for(;;) で書けって言っても気持ち悪いと感じるやつも多いらしい。
だから forever を定義して統一させている。

>>154
俺も同じことしてるよｗ

while(1) は while(2) でも while(829344) でもいいのが気持ち悪い。

while(42)

>>164
個人的には、文と左括弧の間に空白がない方がよっぽど気持ち悪いけどな。

while ("∀")

むしろ、

while ( 'A') {

while ('A' ) while ('q' ) while ( 'o') while ( '3')

こんどから、これで遊ぼうかな

for (;;)

Boostの普通に使えるんじゃないの
というかCの方がC++より進化してるよな

Boost.PreProcesserは確かにCでも使えるだろうな

>>166
while(...) { ... } の全体で一つの文なんだが

http://sourceforge.net/projects/chaos-pp
これか
Boostには世話になってるが正直理解不能
マクロでgenericsかよ

>>173
これダウンロードできなくない？CVSにもアクセスできないし

>>172
そうか。では while/switch/if 各キーワードとその後の左括弧、と訂正しよう。
ところで、
>while(...) { ... } の全体で一つの文なんだが
それは間違い。

そんなことはない

>>175
ジョークだよね？

誰か「式」と「文」の意味を教えてやれ

技術者なら規格書くらい嫁、としか言えません。
ドカタなら…お悔やみ申し上げます。

#define MY_STATUS (*v*)

//整数の絶対値を求める
#define abs(a) ((a xor (a>>31))-(a>>31))

64bitでしねる

マクロ使わんでもちゃんと最適化されるがな。

//割り算の余剰を求める
#define mod(a,b) (-(b*(a/b))+a)

#define mod(a,b) (-((b)*((a)/(b)))+(a))

>>184>>185
mod演算子の存在意義を否定するろくでもないマクロだな。
実数なら関数があるんだし。
>>181
>183じゃないが、下手すりゃ普通に書いたほうが速いぞ。

C89 の「負数の商・剰余は処理系依存」解消マクロかと思えば
-1/2が0になる処理系 (-1%2 = -1) で mod(-1, 2) → -1
-1/2が-1になる処理系 (-1%2 = 1)  mod(-1, 2) → 1
そのまんまじゃねーかよｗ

#define HELLOWORLD (puts("Hello World"));

#define fib(n) (n>2)?fib(n-1)+fib(n-2):1

#define l i
#define retrun return
#define mail main

これでもうtypoも怖くない。
ってか、数日前に部下が素でやってたのを見たとき、
バカはバカなりに頭を使うものだと感動した。

mianならよくあるな。

C++＠便利なテンプレート
ならもっと色々出てきたろうに。普通にクイックソートとか書けるからなぁ。

#define NELEMS(array) (sizeof(array)/sizeof(*(array)))
#define MEMBER_NELEMS(type, name) (NELEMS(((type*)NULL)->name))
#define END_OF_ARRAY(array) (array + NELEMS(array))

プレーンCの仕事したとき、地味に便利だった。

#define return main();

>>192
その実装で異なる名前のついたマクロ１０種類くらい見たな。
せめて一番上だけでも標準化しろ。

->
を使ったプログラムを作れ

/*->*/

>>194
有名なところで、XtNumber, nuberof,辺りか?

>>194
おれはNARRAYという名前にした

>>192 >>194
最もよく使うであろう一番目が標準化されない理由は知らんが、
二番目のは offsetof として標準化されている。

#define Rem /##/

>>199
俺も最初offsetofかと思ったけど、よく見ると違うぞ。
名前どおり、メンバに対するNELEMSになっている。

長さの不明な配列っぽいものに適用して嵌る連中がでるからな。

2番目の意味が分からんのですが、誰か教えてくだされ

>>203
offsetofでぐぐれ。

最近ボツにしたマクロを晒してみる。

#define CREATE_IF(pred, type, name, params) \
std::auto_ptr<type> name; \
if (pred) { \
std::auto_ptr<type> temp##name(new type params); \
name = temp##name; \
}

こんなふうに使う。

CREATE_IF(isMultiThreading, scoped_lock, lock, (this->mutex_));

>>167-168
これいいなあ

俺が使ってる便利マクロ
D言語のscope(exit)とか便利そうだよね

#define SCOPE_EXIT(var,iroiro) \
typedef BOOST_TYPEOF(var) BOOST_PP_CAT(_scopeexit_var_type,__LINE__); \
struct BOOST_PP_CAT(_scopeexit_kokodake_type,__LINE__) { \
　　BOOST_PP_CAT(_scopeexit_kokodake_type,__LINE__) \
　　　(BOOST_PP_CAT(_scopeexit_var_type,__LINE__) v):var(v){} \
　　~BOOST_PP_CAT(_scopeexit_kokodake_type,__LINE__)(){iroiro} \
　　BOOST_PP_CAT(_scopeexit_var_type,__LINE__) var; \
}BOOST_PP_CAT(_scopeexit_kokodake,__LINE__)(var);

使い方：
HANDLE handle = ...;
SCOPE_EXIT(handle,
　::CloseHandle(handle); // スコープ抜けたら勝手に閉じられる
)

C++じゃねぇかｗｗ

ほんとだ。それだったらboost::shared_ptrから
参照カウントを取り除いたようなものを作れば十分だよ。マクロ要らない。

NELEMSはプログラミング作法に同じ名前で載ってたな。
ぐぐったらこのスレがヒットしたｗ

finallyが欲しいな。

やってみた。

// ストレートに
#define UNWIND_PROTECT(block, finally_block) \
　{ try { block } catch (...) { finally_block throw; } finally_block }

// finallyブロックの複製を避けてみる
class unwind_protect_no_error {};
#define UNWIND_PROTECT(block, finally_block) \
　try {\
　　block\
　　throw unwind_protect_no_error();\
　} catch (...) {\
　　finally_block;\
　　try {\
　　　 throw;\
　　} catch (const unwind_protect_no_error&) {}\
　}

// ノンケでも構わず喰っちまう使い方なんだぜ
// デストラクタでどうにかする方が良いと思うけど…こういう遊び、好きですから…
UNWIND_PROTECT({
　if (!dynamic_cast<GachiHomo*>(boy)) {
　　throw UnexpectedExperienceException();
　}
}, {
　boy->insert(this);
});

…あれ？
C言語って例外あったの？

いいえ、それはCではありません。

linuxのcontainer_ofよりも凄いマクロを見たことがない
あれはC言語の限界を超えてるぜ

限界超えちゃったらコンパイルできないやん

container_ofはoffsetofを知ってるなら自然な発想じゃないか？
個人的にはBoost.PPとかorder-ppの方が燃える

>>216
だからプロプロセッサなのさ

>>217
だから、offsetofが奇抜でかっこいいんじゃないか

プロプロ吹いたwwwww
コンパイラ通さないのかよwww

素人が使うANSIのプリプロセッサじゃなくて、
プロ仕様のgcc様だからこそ前処理出来ると言いたかったのでは？

#ifdef DEBUG
#define dbg(format, arg...) \
printk(KERN_DEBUG "%s: " format "\n" , __FILE__ , ## arg)
#else
#define dbg(format, arg...) do {} while (0)
#endif

#define hlist_for_each_safe(pos, n, head) \
for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
pos = n)

可変個引数のマクロなら、VC++でもC99仕様のが導入されている。VC++ 2005から。

最近の offsetof は組み込み演算子に置き換えられてるので少し寂しい。

#define offsetof(a, b) __builtin_offsetof(a, b)　　/* by gcc */

ああ、悲しい現実。

#ifdef WIN32
#error this compiler is not supported.
#endif

#ifdef UNIX
#pragma comment ( "いいえケフィアです" );
#endif

#define forever while("無限ループ")

>>226
なかなか面白いな、それ。

#ifdef _MSCVER
#error this is no standard C/C++ compiler
#endif

>>228
それは対応環境を狭めすぎ、せいぜい

#if defined(_MSC_VER) && (_MSC_VER < 1310)
#error this is no standard C/C++ compiler
#endif

>>229
バージョンだけでも決められないんじゃないの？
で、結局はこうなる。

#if !defined(__STDC__)
#error this is no standard C/C++ compiler
#endif

>>230
そこはthis is no standard C compilerだろ。
C++標準は__STDC__の定義するかどうかを処理系定義としている。

いいえ、これはペンはありません

保守

例えばだけど、オレこんな使い方したりするよ。

例：ソース名：myfopen.c
#include <stdio.h>
#include <stdlib.h>
#define myfopen(DF,DM) _myfopen(DF,DM,__FILE__,__LINE__)//このマクロでファイル名と行番号を与える
FILE *_myfopen(char *f,char *m,char *s,int l)
{
FILE *fp=fopen(f,m);
if(NULL == fp){
printf("「%s」の%d行目でコールした関数で、「%s」がオープンできなかったから終了するよ。\n",s,l,f);
exit(EXIT_FAILURE);
}
return fp;
}
int main()
{
FILE *a=myfopen("nyan.txt","r");
return 0;
}

実行結果：
$ ./a.exe
「myfopen.c」の18行目でコールした関数で、「nyan.txt」がオープンできなかったから
終了するよ。

‥みたいな感じで。

#define SWAP(x, y) do { x^=y; y^=x; x^=y; } while (0)

>>235
型がビット演算可能でないと・・・
同じ値だと・・・

値は同じでもいいな
アドレスが同じだと不味い

>>237
>>237
>>237
>>237
>>237

だれか237の言っている意味を解説してくれ、
とりあえず、このマクロがダメということでおk？

>>236
なら、これで
#define SWAP(x, y) while (x != y) { x^=y; y^=x; x^=y; }
用途限定でよろ

×while
○if

orz

>>240->>241
それはぶら下がりでだめだろう

#define SWAP(x, y) do{ if ( x != y ) { x ^= y; y ^= x; x ^= y; } }while(0)

>>242
cool

条件分岐挟むなら、 >>12でいいやってなるかも。

>>238-239
237の言ってることって意味不明か?
aとbが整数型なら、a!=bならaとbの値が交換されて、
a==bなら変化無し、&a==&bだと0になるってことだろ?
これって環境依存だっけ?

>>237 は正しいよ
やってみりゃ分かる

SWAP(a,a) とやると aの値は常に0になってしまう

デバッグ用マクロ
DEBUG_MODEを0にすると無効化。コンパイラオプションとかで切り替えると便利そうだけど、書いただけで使った事が無い。

#define DEBUG_MODE 1
#define debug_msg_str(str) \
(DEBUG_MODE && printf("debug %+16s %+16d %+16s ; %s\n",__FILE__,__LINE__,__func__,str))
#define debug_msg_num(num) \
(DEBUG_MODE && printf("debug %+16s %+16d %+16s ; %d\n",__FILE__,__LINE__,__func__,num))

NDEBUG使えよカス

>>242
http://www.dd.iij4u.or.jp/~okuyamak/Information/xor_fixed_swapping.html

swapマクロは危険性を理解した上で使えば問題ないと思うけど。

#define swap(x, y) (x ^= y, y ^= x, x ^= y)

注意すべきは　swap(a, a)　になってしまう場合。
直接こう書く人はいないが、マクロ展開後にこうなってしまうかも。
その場合はコンパイル時に警告も出てくれない。

>>251
>250

WTL って、どーなのよ

なんだ、sys/queue.h とかの紹介スレかと思ったら違うみたいだな

#define CHECK(chk) do{ \
　if(!(chk)){ \
　　fprintf(stderr,"CHECK:%s , file %s, line %d.\n", \
　　　　　　　　(#chk), __FILE__, __LINE__); \
　　return;\
　}\
}while(0)

どのように便利なのかわからないのだが
assertっぽくてそうでもないし、return ;って、voidを返す(何も返さない)関数以外では使えないじゃないか

assertだと終了しちゃうじゃん
パラメータで渡された戻り値を返すマクロもあるよ

#define CV_8U 0
#define CV_32F 1
#define CV_64F 2
みたいなのがあって、
if( type == CV_8U )
   unsigned char data = array[0];
else if ( type == CV_32F )
   float data = array[0];
else if (type == CV_64F )
   double data = array[0];
のようなコードがあるのですが、これの if 文をなくして、
ELEMTYPE(type) data = array[0];
のように書きたい。
こんなマクロ関数って作れますか？

ここは「Ｃ言語、Ｃ＋＋の便利なマクロを紹介する」スレッドであって、質問をする所ではない。

swapなんてマクロにする意味はない。
inlineでいい。

回答が便利なマクロになれば、スレの意図にあってるんちゃう？

>>260
質疑応答を、ここで延々とやられると面倒。
他のスレでゴニョゴニョした結果、できたマクロが便利そうだったら、ここに貼ってくれ。

ちなみに、>257 だが、マクロ化したら逆に面倒になると思われる。
こういう処理はC++のテンプレートを使うべきだろう。
（これがCのコードなら、>257は言語仕様を理解してない初心者って事になる。）

むしろ話題を分散させられる方が面倒なんだが

>（これがCのコードなら、>257は言語仕様を理解してない初心者って事になる。）
型が静的に決まらないといけないのはCもC++も同じだから、それは関係ないんじゃね

>>257
そのtypeはプリプロセッサからみて定数？
そうじゃないなら無理

例えば
ELEMTYPE(CV_8U) ...
みたいに使えるマクロなら書けるけど、
void f(int type) { ELEMTYPE(type) ... }
みたいなのは不可能

>>262
｜型が静的に決まらないと
　それ以前の、変数のスコープの話。　マクロ内で変数定義した場合、if文抜けたら消えるよね。

# 変数名をマクロの引数に入れてないから汎用性もない。　不便なマクロだね。

>>263
>マクロ内で変数定義した場合、if文抜けたら消えるよね。
どこから「マクロ内で変数定義」なんて話が出てきたんだ？
たとえば
ELEMTYPE(CV_8U) data = array[0];
が
unsigned char data = array[0];
に展開されるようなマクロじゃないのか？

>>264
　>257

解釈の相違だな