•\ކ / Ž©ìƒ\ƒtƒg / “ú‹L / •ó”  / ƒTƒCƒgî•ñ / ŒŸõ
ˆê”Ê / V‚bŒ¾Œê / ‘Ê•¶

ƒvƒƒOƒ‰ƒ~ƒ“ƒOŒ¾Œê C ‚̐V‹@”\


b©‘O•łցb•\ކ‚ցbŽŸ•łց¨b
 
 

1. ŠT—ª
1.1 ‚Í‚¶‚ß‚É
1.2 V‚µ‚¢—\–ñŒê
1.3 V‚µ‚¢ƒwƒbƒ_ƒtƒ@ƒCƒ‹
2. C ƒvƒŠƒvƒƒZƒbƒT
2.1 V‚µ‚¢ƒRƒƒ“ƒg•\‹L•û–@
2.2 ‹óˆø”‚ð‹–‚³‚ꂽŠÖ”Œ^ƒ}ƒNƒŒÄo‚µ
2.3 ‰Â•ό”ˆø”‚ðŽ‚Âƒ}ƒNƒ’è‹`
2.4 ‚ ‚ç‚©‚¶‚ß’è‹`‚³‚ê‚Ä‚¢‚éƒ}ƒNƒ–¼
2.5 ƒvƒƒOƒ‰ƒ~ƒ“ƒOŒ¾Œê C •W€ƒvƒ‰ƒOƒ}
2.6 ’P€‰‰ŽZŽq _Pragma
2.7 ƒvƒŠƒvƒƒZƒbƒTŽ®‚É‚¨‚¯‚鐮”Œ^
2.8 •¶Žš—ñ’萔‚ƃƒCƒh•¶Žš—ñ’萔‚ÌŒ‹‡
3. Žš‹å
3.1 ƒ†ƒjƒo[ƒTƒ‹ƒLƒƒƒ‰ƒNƒ^–¼
3.2 Šg’£‚³‚ê‚½Ž¯•Ê–¼Žg—p•¶Žš
3.3 •‚“®¬”“_’萔‚Ì 16 i”•\‹L
4. ”z—ñ
4.1 ‰Â•Ï’·”z—ñ
4.2 \‘¢‘Ì’†‚Ì 0 ’·”z—ñƒƒ“ƒo
4.3 ”z—ñ—v‘f’†‚Ì‹L‰¯/Œ^CüŽq
5. ®”Œ^
5.1 _Bool Œ^
5.2 long long int Œ^
5.3 long long int Œ^‚̒萔
5.4 ®”œŽZ
6. •¡‘f”Œ^
6.1 _Complex Œ^
6.2 _Imaginary Œ^
6.3 •¡‘f”‚ÉŠÖ‚·‚éŽl‘¥‰‰ŽZ
7. •¶–@ˆê”Ê
7.1 ˆÃ–ق̊֐”éŒ¾
7.2 éŒ¾Žž‚̈Öق̌^
7.3 ‘O’è‹`ޝ•Ê–¼ __func__
7.4 enum éŒ¾‚ł̗]•ª‚ȃJƒ“ƒ}
7.5 inline ŠÖ”’è‹`
7.6 restrict ƒ|ƒCƒ“ƒ^
7.7 •ϐ”éŒ¾‚ÆŽÀsƒR[ƒh‚̈ʒuŠÖŒW
7.8 Žwަ•t‚«‚̏‰Šú‰»Žq (Designated Initializer)
7.9 •¡‡ƒŠƒeƒ‰ƒ‹ (Compound Literal)
7.10 ‘I‘ð•¶‚Æ”½•œ•¶‚̃uƒƒbƒN‰»
8. •W€ƒ‰ƒCƒuƒ‰ƒŠ(Šg’£)
8.1 ctype.h
8.2 float.h
8.3 math.h
8.4 stdarg.h
8.5 stdio.h
8.6 stdlib.h
8.7 wchar.h
8.8 wctype.h
9. •W€ƒ‰ƒCƒuƒ‰ƒŠ(V‹K)
9.1 complex.h: •¡‘f”
9.2 fenv.h: •‚“®¬”“_ŠÂ‹«
9.3 inttypes.h
9.4 stdbool.h
9.5 stdint.h
9.6 tgmath.h: Œ^‘Ì”ŠwŠÖ”
A. •t˜^
A.1 strftime ‘Ž®Žw’èŽq
A.2 printf ‚̏‘Ž®

7. •¶–@ˆê”Ê
@‚±‚ÌÍ‚Å‚Í C Œ¾Œê‚ɐV‚½‚ɉÁ‚¦‚ç‚ꂽŽwަ•t‚«‚̏‰Šú‰»Žq‚â•¡‡ƒŠƒeƒ‰ƒ‹‚Æ‚¢‚Á‚½•¶–@‚âAˆÃ–ÙŽž‚̐錾‚ÉŠÖ‚·‚é•ύX‚Æ‚¢‚Á‚½A•ύX‚³‚ꂽ•¶–@‚ɂ‚¢‚Äà–¾‚µ‚Ü‚·B

7.1@ˆÃ–ق̊֐”éŒ¾
@Œ»Ý‚Ì C Œ¾Œê‚Ì‹KŠi‚ł́A‚ ‚éŠÖ”‚©‚瑼‚̊֐”‚ðŒÄ‚яo‚·ŽžA‚Æ‚­‚É‚»‚̊֐”‚̃vƒƒgƒ^ƒCƒv‚ðéŒ¾‚µ‚È‚­‚Ä‚àŽg—p‚·‚邱‚Æ‚ª‚Å‚«‚Ü‚µ‚½B—Ⴆ‚Î stdio.h ‚ð“ǂݍž‚Ü‚¸‚ɁAprintf ‚ðŽg—p‚·‚邯‚¢‚Á‚½‚±‚Ƃł·B‚µ‚©‚µA¡“x‚Ì C Œ¾Œê‚ł͂»‚̂悤‚ȏꍇA‚»‚̊֐”‚̌Ăяo‚µ‚Í‹KŠiã–¢’è‹`‚Ì“®ì‚ƂȂè‚Ü‚·B‚½‚¾ŽÀÛ‚ɂ͑½‚­‚̏ˆ—Œn‚ł͌x‚ðo‚µ‚ăRƒ“ƒpƒCƒ‹‚·‚邿‚¤ŽÀ‘•‚³‚ê‚邱‚Ƃłµ‚傤B‚±‚̕ӂ̋@”\‚Í C++ ‚ɋ߂­‚È‚Á‚Ä‚¢‚Ü‚·‚ˁB

7.2@éŒ¾Žž‚̈Öق̌^
@Žè‘±‚«Œ^Œ¾Œê‚ł́Aˆê”Ê“I‚ɕϐ”‚âŠÖ”‚ȂǂðéŒ¾‚µ‚ÄŽg—p‚·‚é•K—v‚ª‚ ‚è‚Ü‚·B‚à‚¿‚ë‚ñ C Œ¾Œê‚à—áŠO‚ł͂ ‚è‚Ü‚¹‚ñB‚µ‚©‚µ C Œ¾Œê‚ł͓Á‚ÉŒ^–¼‚ðŽw’肹‚¸‚ɕϐ”‚ȂǂðéŒ¾‚·‚邱‚Æ‚ª‚Å‚«‚Ü‚µ‚½B‚»‚̏ꍇAŒ^‚ª‚È‚¢•ϐ”‚ªéŒ¾‚³‚ꂽ‚Æ‚¢‚¤‚킯‚ł͂Ȃ­AŽ©“®“I‚É int Œ^‚Æ‚µ‚ďˆ—‚³‚ê‚Ü‚µ‚½B—á‚ð‹“‚°‚ê‚΁AŽŸ‚̂悤‚ȃvƒƒOƒ‰ƒ€‚Å‚·B

func(p1,p2)
{
@const three=3;
@return (p1+p2)*three;
}

‚±‚̏ꍇAŠÖ” func ‚Ì–ß‚èŒ^‚Í int Œ^Ap1, p2, three ‚ÌŒ^‚Í int Œ^‚Å‚·B ‚±‚̂悤‚È‹Lq‚ª‚Å‚«‚邯‚¢‚¤‚±‚Æ‚ª C Œ¾Œê‚̐«Ž¿‚ð‚æ‚­‚ ‚ç‚킵‚Ä‚¢‚Ü‚·B ‚µ‚©‚µ‚È‚ª‚çAV‚µ‚¢ C Œ¾Œê‚ł́A‚±‚̂悤‚ÈˆÃ–Ù‚Ì int Œ^‚ÌŽg—p‚Í‹KŠiã‚Å‚«‚È‚¢‚±‚ƂɂȂè‚Ü‚µ‚½B‚µ‚½‚ª‚Á‚āAí‚ÉŽŸ‚̂悤‚ɏ‘‚­•K—v‚ª‚ ‚è‚Ü‚·B

int func(int p1,int p2)
{
@const int three=3;
@return (p1+p2)*three;
}


7.3@‘O’è‹`ޝ•Ê–¼ __func__
@‚¨‘Ò‚½‚¹‚µ‚Ü‚µ‚½B‘Ò–]‚Ì‹@”\‚̈ê‚‚ª“ü‚è‚Ü‚µ‚½B‚»‚ꂪ‘O’è‹`ޝ•Ê–¼ __func__ ‚Å‚·B
@‚³‚Ä‚³‚āA¡‚܂ŊF‚³‚ñ‚̓vƒƒOƒ‰ƒ€‚ð‚ǂ̂悤‚ɃfƒoƒbƒO‚ð‚µ‚Ä‚«‚Ü‚µ‚½‚©H‰½HƒfƒoƒbƒK‚ðŽg‚Á‚Ä‚¢‚½H‚»‚̂悤‚ȍ‹‰Ø‚Ȋ‹«‚É‚ ‚él‚́A‚±‚Ì‹@”\‚Ì‚ ‚肪‚½‚³‚ðŽÀŠ´‚·‚邱‚Æ‚ª“‚¢‚©‚à‚µ‚ê‚Ü‚¹‚ñB
@ƒvƒƒOƒ‰ƒ€‚̃fƒoƒbƒO‚É‚ ‚½‚Á‚Ă܂¸‘厖‚È‚±‚Ƃ́A‚¢‚Á‚½‚¢ƒvƒƒOƒ‰ƒ€‚͂ǂ̕”•ª‚ð‘–‚Á‚Ä‚¢‚é‚Ì‚©‚Æ‚¢‚¤‚±‚Æ‚ð’m‚邱‚Ƃł·B—Ⴆ‚΁AðŒ•ªŠò‚ð‚µ‚½‚Æ‚«‘z’肵‚½ƒR[ƒh‚Ì•û‚ð‚¿‚á‚ñ‚Æ’Ê‚Á‚½‚Ì‚©‚ð’m‚é•K—v‚ª‚ ‚è‚Ü‚·B‚»‚̂悤‚ȂƂ«‚É‚Í printf ‚𖄂ߍž‚ñ‚¾‚肵‚āA³‚µ‚¢•ûŒü‚ɃvƒƒOƒ‰ƒ€‚ªŽÀs‚µ‚Ä‚¢‚é‚©‚ðŒŸ¸‚·‚é•K—v‚ª‚ ‚è‚Ü‚µ‚½B‚µ‚©‚µAprintf ‚𖄂ߍž‚ñ‚¾•”•ª‚ª‘½‚­‚È‚Á‚Ä‚­‚邯A‚¾‚ñ‚¾‚ñ‚Ç‚±‚Ì printf ‚̏o—͂ł ‚é‚Ì‚©‚ª‚í‚©‚ç‚È‚­‚È‚é‚Æ‚¢‚Á‚½–â‘肪‚ ‚è‚Ü‚µ‚½B
@‘O’è‹`ޝ•Ê–¼‚Í‚±‚̂悤‚ÈŽžŒø‰Ê‚ð”­Šö‚µ‚Ü‚·B—Ⴆ‚΁A¡‰ñ“±“ü‚³‚ꂽ‘O’è‹`ޝ•Ê–¼‚Ɖ•ϒ·ƒ}ƒNƒ‹@”\‚ð‘g‚ݍ‡‚킹‚é‚ÆŽŸ‚̂悤‚È‚±‚Æ‚ª‚Å‚«‚Ü‚·B

‘O’è‹`ޝ•Ê–¼ __func__ Žg—p—á
/*
 * ‘O’è‹`ޝ•Ê–¼ __func__ Žg—p—á (c)1999 seclan
 * ver1.00 1999/05/16 Å‰‚̃o[ƒWƒ‡ƒ“
 */
#define dbg(...)@\
@(printf("%s %u @%s:",__FILE__,__LINE__,__func__), \
@printf(" "__VA_ARGS__))

int foo_bar(int i)
{
@@//static const char __func__[] = "foo_bar";@//(1)
@@if(i != 3){
@@@@dbg("i=%d", i);
@@@@i *= i;
@@}
@@return i;
}

@¡“x‚Ì C Œ¾Œê‚ł́A‚±‚Ì—á‚Ì (1) ‚ÅŽ¦‚µ‚Ä‚¢‚邿‚¤‚ɁAŠeŠÖ”‚Ì“ü‚èŒû‚Å __func__ ‚Æ‚¢‚¤Ž¯•Ê–¼‚ª‚ ‚½‚©‚àŽ©“®“I‚ɐ錾‚³‚ꂽ‚©‚̂悤‚ɂȂè‚Ü‚·B‚µ‚½‚ª‚Á‚āA‚±‚̊֐”‚̃XƒR[ƒv’† __func__ ‚ðŽQÆ‚·‚邱‚Æ‚ª‚Å‚«‚Ü‚·B__func__ ‚Í‚»‚̊֐”‚̊֐”–¼‚ª“ü‚è‚Ü‚·B‚±‚̏ꍇAŠÖ”–¼‚ª foo_bar ‚Ȃ̂Š__func__ ‚Í "foo_bar" ‚ð‚ ‚ç‚í‚·‚±‚ƂɂȂè‚Ü‚·B—á‚Ì’†‚Å‚Í i ‚ª 3 ‚ł͂Ȃ¢‚ƃfƒoƒbƒOƒR[ƒh‚ðŽÀs‚µ‚Ü‚·B¡ i ‚ª 5 ‚Å‚ ‚邯l‚¦‚邯Autest.c 13 @foo_bar: i=5v‚̂悤‚È•\ަ‚ª‚È‚³‚ê‚Ü‚·B
@‚±‚̂悤‚ɁA¡‰ñ‚Ì C Œ¾Œê‚Ì‹@”\‚ðŽg‚¤‚±‚Ƃɂæ‚èAƒfƒoƒbƒOƒR[ƒh‚ð‚æ‚èŠÈ’P‚É”ü‚µ‚­‹Lq‚Å‚«‚邿‚¤‚ɂȂ邱‚Æ‚ª‚í‚©‚è‚Ü‚·‚ˁB

7.4@enum éŒ¾‚ł̗]•ª‚ȃJƒ“ƒ}
@”z—ñ‚ð‰Šú‰»‚·‚鎞‚́Aint i[ ] = { 1, 2, 3, } ‚̂悤‚ɍŌã‚Ì—]•ª‚ȃJƒ“ƒ}‚Í‹–‚³‚ê‚Ä‚¢‚Ü‚µ‚½B‚µ‚©‚µAenum éŒ¾‚Å‚Í enum { a, b, c,} ‚̂悤‚ɍŌã‚É—]•ª‚ȃJƒ“ƒ}‚ð“ü‚ê‚邯ƒGƒ‰[‚ɂȂÁ‚Ä‚¢‚Ü‚µ‚½B¡‰ñ‚Ì C Œ¾Œê‚ł́A‚±‚̂悤‚È enum éŒ¾‚ł̗]•ª‚ȃJƒ“ƒ}‚ª‹–‚³‚ê‚邿‚¤‚ɂȂè‚Ü‚µ‚½B

7.5@inline ŠÖ”’è‹`
@C++ ‚É‚à‚ ‚é‹@”\‚ª C ‚É‚à“±“ü‚³‚ê‚Ü‚µ‚½B‚»‚Ì‹@”\‚Í inline ŠÖ”’è‹`‚Ì‹@”\‚Å‚·B¡‚Ü‚Å‚Ì C Œ¾Œê‚ł́AŠÖ”‚̂悤‚É‹Lq‚Å‚«A‚µ‚©‚à‚‘¬‚ɌĂяo‚¹‚邿‚¤‚É‚µ‚½‚¢ê‡‚ɂ́AŠÖ”Œ^ƒ}ƒNƒ‚ðŽg—p‚·‚é•K—v‚ª‚ ‚è‚Ü‚µ‚½B‚µ‚©‚µAŠÖ”Œ^ƒ}ƒNƒ‚ł͌^ŒŸ¸‚ª‚Å‚«‚È‚¢ãAŽg‚¢•û‚ɂ͂æ‚Á‚Ă͗\‘ª‚Å‚«‚È‚¢Œ‹‰Ê‚𓱂­‚±‚Æ‚à‚ ‚è‚Ü‚µ‚½B
@¡‰ñ“±“ü‚³‚ê‚é inline ‹@”\‚ðŽg‚¤‚ƁAŒ^ŒŸ¸‚à‚³‚êA‚³‚ç‚ɒʏí‚̊֐”‚Æ“¯‚¶•]‰¿‚ª‚È‚³‚êA‚©‚‚‘¬‚ÉŽÀs‚Å‚«‚éŠÖ”‚ð’è‹`‚·‚邱‚Æ‚ª‚Å‚«‚Ü‚·BŽg‚¢•û‚́A‚½‚¾’P‚Ɋ֐”‚ð inline ƒL[ƒ[ƒh‚ðŽg‚Á‚ďCü‚·‚邾‚¯‚Å‚·B—Ⴆ‚΁Ainline void swap(int *a1, int *a2){...} ‚Å‚·B‚½‚¾‚µŠO•”ƒŠƒ“ƒP[ƒW‚ðŽ‚ÂŠÖ”‚ɑ΂µ‚ẮAinline •t‚«‚̊֐”éŒ¾‚ðs‚Á‚½‚ç‚»‚Ì’è‹`‚𓯂¶–|–ó’PˆÊ’†‚Å‚µ‚È‚­‚Ă͂Ȃç‚È‚¢AC³‰Â”\‚ȐÓI‹L‰¯Žõ–½‚ðŽ‚Â’è‹`‚ð‚Ó‚­‚ñ‚ł͂Ȃç‚È‚¢A“à•”ƒŠƒ“ƒP[ƒW‚ðŽ‚ÂŽ¯•Ê–¼‚Ö‚ÌŽQÆ‚ð‚Ó‚­‚ñ‚ł͂Ȃç‚È‚¢A‚Æ‚¢‚¤§–ñ‚ª‚ ‚è‚Ü‚·B‚Ü‚½ main ŠÖ”‚Í inline Cü‚ð‚·‚é‚±‚Æ‚ª‚Å‚«‚Ü‚¹‚ñB
@inline ’è‹`‚̓Rƒ“ƒpƒCƒ‰‚ɑ΂·‚éƒqƒ“ƒg‚Å‚ ‚èAƒRƒ“ƒpƒCƒ‰‚Í•K‚¸‚µ‚à‚‘¬ŒÄ‚яo‚µƒR[ƒh‚𐶐¬‚·‚邯‚ÍŒÀ‚è‚Ü‚¹‚ñB

7.6@restrict ƒ|ƒCƒ“ƒ^
@C Œ¾Œê‚͍‚‹‰Œ¾Œê‚Æ‚µ‚Ă̓|ƒCƒ“ƒ^‚ð‚©‚È‚èŽ©—R‚ÉŽg‚¦‚錾Œê‚Å‚·B‚»‚ÌŒ‹‰ÊAƒvƒƒOƒ‰ƒ}‚ªƒ|ƒCƒ“ƒ^‚ðãŽè‚ÉŽg‚¦‚Α‚¢ƒvƒƒOƒ‰ƒ€‚ð‘‚¯‚邿‚¤‚ɂȂè‚Ü‚µ‚½B‚µ‚©‚µ‚»‚̈ê•û‚ŁAƒ|ƒCƒ“ƒ^‚̕ʖ¼‚ðŠÈ’P‚ɍì‚邱‚Æ‚ª‚Å‚«‚邿‚¤‚ɂȂÁ‚Ä‚µ‚Ü‚Á‚½‚̂ŁAƒRƒ“ƒpƒCƒ‰‚ªƒf[ƒ^‰ðÍ‚âÅ“K‰»ƒR[ƒh‚𐶐¬‚·‚鎞‚̏áŠQ‚ɂȂÁ‚Ä‚«‚Ü‚µ‚½B—Ⴆ‚΁AŽŸ‚Ì—á‚ðŒ©‚Ä‚­‚¾‚³‚¢B


//(1)
void sumup(int n, int *array1, int *array2)
{
@@assert((n % 4)== 0);
@@for(int i = 0; i < n; i++)@array1[i] += array2[i];
}

//(2)
trymore:
@r1 © array1[i+0]:[i+1]:[i+2]:[i+3]
@r2 © array2[i+0]:[i+1]:[i+2]:[i+3]
@r1 += r2
@array1[i+0]:[i+1]:[i+2]:[i+3] © r1
@i += 4
@if( i < n )@goto trymore

@(1)‚Ì•”•ª‚Ìsumup ŠÖ”‚Í array1 ‚É array2 ‚Ì“à—e‚ð n ŒÂ•ª‘«‚µž‚ފ֐”‚Å‚·B‚½‚¾‚µ‚±‚±‚Å‚±‚̃vƒƒOƒ‰ƒ€’†‚Å‚Í n ‚Ì’l‚ª 4 ‚Ì”{”‚Å array1 ‚Æ array2 ‚Í“¯‚¶“à—e‚ðŽw‚µ‚Ä‚¢‚È‚¢ŒÄ‚яo‚µ‚µ‚©‚µ‚È‚¢‚Ɖ¼’è‚Å‚«‚邱‚ƂƂµ‚Ü‚·B‚·‚邯‚»‚ê‚ɑΉž‚µ‚Ä SIMD –½—ß‚ðŽg—p‚Å‚«‚é CPU ã‚̃AƒZƒ“ƒuƒ‰‚̃R[ƒh‚̃‹[ƒv•”•ª‚Í (2) ‚̂悤‚ɍœK‰»‚·‚邱‚Æ‚ª‚Å‚«‚Ü‚·B‚Ü‚¸ array1 ‚Ì 4 —v‘f•ª‚ð r1 ƒŒƒWƒXƒ^‚ÉŠi”[‚µ‚Ü‚·B‚»‚µ‚Ä“¯—l‚É array2 ‚Ì 4 —v‘f•ª‚ð r2 ƒŒƒWƒXƒ^‚É“ü‚êA‚»‚ê‚ð r1 ‚ƉÁŽZ‚µ‚āAŒ‹‰Ê‚ƂȂé r1 ‚ð array1 ‚ɏ‘‚«–ß‚µ‚Ü‚·B‚½‚Á‚½ˆê–½—á‚Å”z—ñ 4 —v‘f•ª‚̉ÁŽZ‚ª‚Å‚«A‚Ü‚½Œ‹‰Ê‚Æ‚µ‚Ä n/4 ‰ñ‚̃‹[ƒv‚ÅŒvŽZ‚Å‚«‚é‚̂ł±‚̃R[ƒh‚ÍŒø—¦“I‚Å‚·B
@‚µ‚©‚µŒ»ŽÀ‚ɂ̓Rƒ“ƒpƒCƒ‰‚Í‚±‚̂悤‚ÈŒø—¦“I‚ȃR[ƒh‚𐶐¬‚·‚邱‚Ƃ͂ł«‚Ü‚¹‚ñ‚Å‚µ‚½B‚È‚º‚È‚ç‚΁AƒRƒ“ƒpƒCƒ‰‚Í array1 ‚Æ array2 ‚ª“¯‚¶“à—e‚ðŽw‚µ‚Ä‚¢‚È‚¢‚Ɖ¼’肵‚Ă悢‚±‚Ƃ͂܂Á‚½‚­’m‚è‚Ü‚¹‚ñB‚µ‚½‚ª‚Á‚āA(3) ‚̂悤‚ȌĂяo‚µ‚É‚à‘Ήž‚·‚é (2) ‚æ‚è‚à—ò‚éƒR[ƒh (4) ‚𐶐¬‚·‚é•K—v‚ª‚ ‚è‚Ü‚·B(4) ‚Í”z—ñ‚Ì—v‘fˆê‚‚¸‚‰ÁŽZ‚µ‚Ä‚¢‚­‚̂Šn ‰ñ‚̃‹[ƒv‚ƉÁŽZ‚ªs‚í‚ê‚邱‚ƂɂȂè‚Ü‚·B


//(3)
@@int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, }
@@sumup(4, array+2, array);

//(4)
trymore:
@r1 © array1[i]
@r2 © array2[i]
@r1 += r2
@array1[i] © r1 
@i ++
@if( i < n )@goto trymore

(3) ‚̌Ăяo‚µŒã‚̐³‚µ‚¢ array ‚Ì’l‚́A‚‚܂è (4) ‚ÅŒvŽZ‚µ‚½Œ‹‰Ê‚Í { 1, 2, 4, 6, 9, 12, } ‚ɂȂé‚Í‚¸‚Å‚·B‚µ‚©‚µA(2) ‚̃R[ƒh‚ł́A‚±‚Ì’l‚́A{ 1, 2, 4, 6, 8, 10, } ‚ɂȂÁ‚Ä‚µ‚Ü‚¢A(4) ‚ÅŒvŽZ‚µ‚½Œ‹‰Ê‚Ì’l‚ƈقȂÁ‚½’l‚ð•Ô‚·‚±‚ƂɂȂè‚Ü‚·B‚±‚̂悤‚ɁAŒ»Ý‚Ì C Œ¾Œê‚ł̓Rƒ“ƒpƒCƒ‰‚É‚æ‚é‰ðÍ‚âƒR[ƒh¶¬‚ð–W‚°‚é—vˆö‚ªŠÜ‚Ü‚ê‚Ä‚¢‚Ü‚·B
@¡‰ñ‚Ì C Œ¾Œê‚©‚ç—˜—p‚Å‚«‚邿‚¤‚ɂȂé restrict CüŽq‚́A‘Oq‚µ‚½‚悤‚ȃ|ƒCƒ“ƒ^‚ª“¯‚¶“à—e‚ðŽw‚µ‚Ä‚¢‚È‚¢‚Æ‚¢‚¤î•ñ‚ðƒRƒ“ƒpƒCƒ‰‚É’ñ‹Ÿ‚·‚邱‚Æ‚ª‚Å‚«‚Ü‚·Brestrict ‚̓|ƒCƒ“ƒ^‚¾‚¯‚ðCü‚·‚邽‚߂ɗ˜—p‚·‚邱‚Æ‚ª‚Å‚«‚Ü‚·B(1) ‚É restrict Cü‚µ‚½ƒR[ƒh‚ð (5) ‚ÉŽ¦‚µ‚Ü‚·B


//(5)
void sumup(int n, int * restrict array1, int * restrict array2)
{
@@assert((n % 4)== 0);
@@for(int i = 0; i < n; i++)@array1[i] += array2[i];
}

//(6)
@@sumup(4, array+4, array);

//(7)
@@sumup(4, array+2, array);

@(5) ‚ł͌vŽZ’†‚É array1 ‚Æ array2 ‚ª‚¯‚Á‚µ‚Ä“¯‚¶“à—e‚ðŽw‚µ‚Ä‚¢‚È‚¢‚Æ‚¢‚¤î•ñ‚ðƒRƒ“ƒpƒCƒ‰‚É—^‚¦‚Ä‚¢‚Ü‚·B‚µ‚½‚ª‚Á‚āAƒRƒ“ƒpƒCƒ‰‚Í‚±‚̏î•ñ‚ðŒ³‚É (2) ‚̂悤‚ȃR[ƒh‚𐶐¬‚·‚邱‚Æ‚ª‚Å‚«‚Ü‚·B‚±‚̂悤‚È‚±‚Æ‚©‚çA(6) ‚̂悤‚ȌĂяo‚µ‚͐³‚µ‚­“®ì‚µ‚Ü‚·‚ªA(7) ‚̂悤‚ȌĂяo‚µ‚ð‚µ‚½ê‡‚ɂ́AŒ¾Œê“I‚ɂ͖¢’è‹`‚Ì“®ì‚ɂȂèA‚½‚Ô‚ñ³‚µ‚¢Œ‹‰Ê‚ðŽc‚³‚È‚¢‚Å‚µ‚傤B
@‚È‚¨Aƒ‰ƒCƒuƒ‰ƒŠ‚Ì’†‚̃|ƒCƒ“ƒ^‚ðˆø”‚ÉŽ‚•¡”‚̊֐”ƒvƒƒgƒ^ƒCƒv‚ª restrict CüŽq•t‚«‚̐錾‚ɕύX‚³‚ê‚Ü‚µ‚½B

7.7@•ϐ”éŒ¾‚ÆŽÀsƒR[ƒh‚̈ʒuŠÖŒW
@•ϐ”‚ðŽg‚¤‚ɂ́AŽQÆ‚·‚é‘O‚ɐ錾‚ð‚·‚é•K—v‚ª‚ ‚è‚Ü‚·B‚±‚Ì‚½‚ߏ]—ˆ‚Ì C Œ¾Œê‚ł́A‚»‚̃R[ƒh‚ðŠÜ‚ÞƒuƒƒbƒN‚̐擪‚ł܂Ƃ߂čs‚í‚È‚¯‚ê‚΂Ȃè‚Ü‚¹‚ñ‚Å‚µ‚½B¡‰ñ‚̐V‚µ‚¢ C Œ¾Œê‚ł́AC++ Œ¾Œê‚Æ“¯‚¶‚悤‚ɁAƒuƒƒbƒN‚̐擪‚Æ‚¢‚¤ˆÊ’u‚É”›‚ç‚ê‚邱‚ƂȂ­AŽQÆ‚·‚é‘O‚ɂǂ±‚Å‚àéŒ¾‚µ‚Ă悢‚Æ‚¢‚¤‚±‚ƂɂȂè‚Ü‚µ‚½BƒXƒR[ƒv‚́A‚»‚̐錾‚³‚ꂽ’¼Œã‚©‚çŠJŽn‚³‚ê‚Ü‚·B
@•ϐ”‚ª‰Šú‰»•t‚«‚Ő錾‚³‚ê‚Ä‚¢‚éê‡(—Ⴆ‚΁Aint i = 3)A§Œä‚ª‚»‚̐錾•”‚ð’ʉ߂·‚éê‡‚ɂ̂ݏ‰Šú‰»‚³‚ê‚Ü‚·B‚à‚µ§Œä‚ª’ʉ߂µ‚È‚¢ê‡‚»‚Ì’l‚Í•s’è‚Å‚·B‚Ü‚½‘O‰ñ‚»‚±‚ð’ʉ߂µ‰Šú‰»‚³‚ꂽŒãAÄ‚у‹[ƒv‚©‰½‚©‚Å“¯‚¶éŒ¾•”‚É‚â‚Á‚½—ˆ‚½‚¯‚ê‚Ç‚àA‚»‚̐錾•”•ª‚ð”ò‚щz‚¦‚½ê‡‚Å‚àAˆÈ‘O‘ã“ü‚³‚ꂽ’l‚Í–Y‚ê‚ç‚ê‚Ä‚¨‚èA•s’è’l‚ƂȂè‚Ü‚·B
@‚Ü‚½‰Â•Ï’·”z—ñ‚ðéŒ¾‚µ‚½ê‡A‚»‚̐錾‚ð”ò‚щz‚·‘O•ûƒWƒƒƒ“ƒv‚͋֎~‚³‚ê‚Ä‚¢‚Ü‚·B‚È‚º‚È‚ç‚΁A”ò‚щz‚³‚ê‚邯AŠm•Û‚·‚ׂ«•K—vƒƒ‚ƒŠ—Ê‚ª‚í‚©‚ç‚È‚¢‚©‚ç‚Å‚·B
@‚³‚ç‚ɁAfor •¶‚àŠg’£‚³‚ê‚Ü‚µ‚½Bfor •¶‚́Afor( [1]; ...; ...) { ... } ‚̂悤‚ɒʏí—p‚¢‚Ü‚·‚ªA‚È‚ñ‚Æ [1] ‚Ì•”•ª‚ɐ錾‚ª‚¨‚¯‚邿‚¤‚ɂȂè‚Ü‚µ‚½B‚‚܂è C++ Œ¾Œê‚ł̂Ɠ¯—l‚ɁAfor(int i = 0; i < 100; i++){ ... } ‚̂悤‚É‹Lq‚·‚邱‚Æ‚ª‚Å‚«‚邿‚¤‚ɂȂè‚Ü‚µ‚½B‚È‚¨‚±‚Ì i ‚ª—LŒø‚Ȃ̂͂±‚̃‹[ƒv‚Ì”ÍˆÍ“à‚¾‚¯‚Å‚·B‚Ü‚½Žg‚¦‚é•ϐ”‚́Aauto •ϐ”‚© register •ϐ”‚¾‚¯‚ŁAstatic •ϐ”‚Ȃǂ͎g—p‚Å‚«‚Ü‚¹‚ñB

7.8@Žwަ•t‚«‚̏‰Šú‰»Žq (Designated Initializer)
@‚¢‚æ‚¢‚æAŽwަ•t‚«‚̏‰Šú‰»Žq (Designated Initializer) ‚Ì“oê‚Å‚·BŒ»Ý‚Ì C Œ¾Œê‚ł͍\‘¢‘Ì‚â”z—ñ‚ð‚ ‚ç‚©‚¶‚ߏ‰Šú‰»‚·‚é‚ɂ́AŽn‚߂̗v‘f‚©‚ç‚·‚ׂĎw’肵‚ú‰»‚·‚é•û–@‚µ‚©‚ ‚è‚Ü‚¹‚ñ‚Å‚µ‚½B‚»‚ÌŒ‹‰Ê‚Æ‚µ‚āA“ü—͔͂ñí‚É‘å•ςŁA‚©‚ÂŒ©‚Â炭‚È‚è‚Ü‚·B


#define ERRMES_NOERROR@@0
#define ERRMES_FILEREAD@ 20
#define ERRMES_FILEWRITE@21
const char *errmessage[] = {
@@"no error",
@@NULL,
@@... —Ⴆ‚΂±‚±‚É 20 ŒÂ‹ó‚«‚ª‚ ‚é ...
@@"file read error",
@@"file write error",
};

struct largestruct {
@@int size;
@@... —Ⴆ‚΂±‚±‚Ƀƒ“ƒo‚ª 10 ŒÂˆÊ‚ ‚é ...
@@int cx, cy;
} sls = {
@@sizeof(struct largestruct),
@@... ‚±‚±‚É–¾Ž¦“I‚ȏ‰Šú‰»‚µ‚È‚­‚Ä‚à‚¢‚¢ƒƒ“ƒo‚ª 10 ŒÂˆÊ‚ ‚é ...
@@640,
@@480,
};

@‚»‚±‚Å‚±‚̐V‹@”\‚ª“oê‚Å‚·B‚±‚Ì‹@”\‚ðŽg‚Á‚ď‘‚«’¼‚·‚ÆŽŸ‚̂悤‚ɂȂè‚Ü‚·B


#define ERRMES_NOERROR@@0
#define ERRMES_FILEREAD@ 20
#define ERRMES_FILEWRITE@21
const char *errmessage[] = {
@@[0]@@@@@@@@= "no error",
@@[ERRMES_FILEREAD]@= "file read error",
@@[ERRMES_FILEWRITE] = "file write error",
};

struct largestruct {
@@int size;
@@... ‚±‚±‚Ƀƒ“ƒo‚ª 10 ŒÂˆÊ‚ ‚é ...
@@int cx, cy;
} sls = {
@@sizeof(struct largestruct),
@@.cx = 640,
@@.cy = 480,
};


@”ñí‚É‚·‚Á‚«‚èAŒ©‚â‚·‚­‚È‚è‚Ü‚µ‚½B‚±‚̂悤‚ɁAŽwަ•t‚«‚̏‰Šú‰»Žq‚͏‰Šú‰»Žž‚É”z—ñ‚Ì—v‘f‚⃁ƒ“ƒo–¼‚ðŽw’è‚·‚邱‚ƂŁA‚í‚©‚è‚â‚·‚­‰Šú‰»‚ðs‚¦‚邿‚¤‚É‚·‚é‚à‚̂ł·B‚»‚±‚ł܂¸A”z—ñ‚ÌŽwަ•t‚«‚̏‰Šú‰»Žq‚ðŽg‚¤Žž‚ɂ́A—v‘f‚ðŽw’肵‚ú‰»‚µ‚Ü‚·B—Ⴆ‚΁A”z—ñ‚Ì 3 ”Ô–Ú‚Ì—v‘f‚ð‰Šú‰»‚µ‚½‚¢Žž‚ɂ́A [3] = ..., ‚Æ‚¢‚¤‚悤‚É‹Lq‚µ‚Ü‚·B‚Ü‚½\‘¢‘̂⋤—p‘Ì‚ð‰Šú‰»‚µ‚½‚¢Žž‚ɂ́A.ƒƒ“ƒo–¼ = ..., ‚̂悤‚ÉŽw’è‚·‚邱‚Ƃŏ‰Šú‰»‚ðs‚¦‚Ü‚·B‚È‚¨Astatic ‚łȂ¢•ϐ”‚ð‰Šú‰»‚·‚éê‡‚ɂ́A‰Šú’l‚Æ‚µ‚Ē萔‚ł͂Ȃ¢’lA—Ⴆ‚Α¼‚̕ϐ”‚ðŽQÆ‚µ‚½Ž®‚ðŽw’è‚·‚éA‚Æ‚¢‚Á‚½‚±‚Æ‚ª‚Å‚«‚Ü‚·B

7.9@•¡‡ƒŠƒeƒ‰ƒ‹ (Compound Literal)
@‚‚¢‚É‚±‚Ì‹@”\‚Ì“oê‚Å‚·BŠF‚³‚ñ‚ÍŽŸ‚̂悤‚È‹Lq‚ð‚·‚éŽž‚ɁA‚±‚ê‚Í–Ê“|‚¾‚ÆŽv‚Á‚½‚±‚Ƃ͂Ȃ¢‚Å‚µ‚傤‚©?

typedef struct { int x, y; } point_t ;
void PutPixel(const point_t *p)
{
@@...
}

@@...
@@point_t p;
@@p.x = 640, p.y = 480;
@@PutPixel(&p);
@@...

@ŠÖ” PutPixel ‚̈ø”‚É’P‚È‚é’萔‚Æ‚µ‚Ä point_t Œ^‚Ì’l‚ð“n‚µ‚½‚¢B‚µ‚©‚µŒ»Ý‚Ì C Œ¾Œê‚ł͂»‚Ì‚½‚߂ɕϐ”‚ðéŒ¾‚µ‚Ä‚³‚ç‚É’l‚ð‘ã“ü‚·‚é•K—v‚ª‚ ‚è‚Ü‚·B‚µ‚©‚µA‚±‚̐V‹@”\‚ðŽg‚¦‚΂±‚ê‚ÍŽŸ‚̂悤‚ɏ‘‚«’¼‚·‚±‚Æ‚ª‚Å‚«‚Ü‚·B

typedef struct { int x, y; } point_t ;
void PutPixel(const point_t *p)
{
@@...
}

@@...
@@PutPixel(&(point_t){640, 480});
@@//‚Ü‚½‚Í
@@PutPixel(&(point_t){.x=640, .y=480});
@@//‚ ‚é‚¢‚Í
@@int pos_x, pos_y;
@@... 
@@pos_x = 640, pos_y = 480;
@@...
@@PutPixel(&(point_t){pos_x, pos_y});
@@...

@ƒIƒuƒWƒFƒNƒgŒ^‚Ü‚½‚͑傫‚³‚ÌŽw’è–³‚µ‚Ì”z—ñ‚ð ( ) ‚Ì’†‚É‹Lq‚µ‚ÄŽŸ‚É { } ‚ð‹Lq‚·‚邱‚Ƃŕ¡‡ƒŠƒeƒ‰ƒ‹ (Compound Literal) ‚ðì‚邱‚Æ‚ª‚Å‚«‚Ü‚·B{ } ‚Ì’†‚Í—á‚É‚ ‚邯‚¨‚èŽwަ•t‚«‚̏‰Šú‰»Žq‚ðŽg‚Á‚½‰Šú‰»‚à‰Â”\‚Å‚·B‚Ü‚½ (int[ ]){1, 2, 3, 4} ‚̂悤‚È”z—ñ’萔‚ðì‚è’¼ÚŠÖ”ˆø”‚Æ‚µ‚Ä“n‚·‚±‚Æ‚à‰Â”\‚Å‚·B‚½‚¾‚µ‰Â•Ï’·”z—ñ‚̒萔‚Í•¡‡ƒŠƒeƒ‰ƒ‹‚ōì‚邱‚Ƃ͂ł«‚Ü‚¹‚ñB

7.10@‘I‘ð•¶‚Æ”½•œ•¶‚̃uƒƒbƒN‰»
@¡“x‚Ì C Œ¾Œê‚ł́A•¡‡ƒŠƒeƒ‰ƒ‹ (Compound Literal) ‚Ì“±“ü‚É”º‚¢A‘I‘ð•¶(if •¶‚È‚Ç)A”½•œ•¶(for •¶‚È‚Ç)‚̈µ‚¢‚ª•ύX‚ɂȂè‚Ü‚µ‚½B‹ï‘Ì“I‚ɂ͂»‚ê‚ç‚Ì•¶‚Í { } ‚ň͂܂ê‚Ä‚¢‚邯‚µ‚Ĉµ‚í‚ê‚邱‚ƂɂȂè‚Ü‚µ‚½B‚Ç‚¤‚¢‚¤ˆÓ–¡‚Å‚µ‚傤? —á‚ðŽ¦‚µ‚Ü‚·B


//(1)•¡‡ƒŠƒeƒ‰ƒ‹‚ðŠÜ‚ñ‚¾ŠÖ”
int f(int par)
{
@@int *a, *b;
@@if( *(b = (int[]){par,1}) == 0)
@@@a = (int[])(par,2,4,8,16,32);
@@else
@@@a = (int[])(1,3,5,7,9);
@@//(*)‚±‚±‚Å a ‚Æ b ‚ªŽw‚µ‚Ä‚¢‚é‚Ì‚à‚͉̂½‚©?
@@return *a;
}

//(2) C99 ‚ł̎ÀÛ‚̈µ‚¢
int f(int par)
{
@@int *a, *b;
@@{
@@@if( *(b = (int[]){par,1}) == 0) {
@@@@a = (int[])(par,2,4,8,16,32);
@@@} else {
@@@@a = (int[])(1,3,5,7,9);
@@@}
@@}
@@//“š‚¦Fa ‚à b ‚àŽw‚µ‚Ä‚¢‚é‚Ì‚à‚̂̕ۏ؂͂Ȃ¢
@@return *a;
}

@(1)‚̂悤‚É if •¶‚Å•¡‡ƒŠƒeƒ‰ƒ‹‚ðŽg—p‚µ‚āAƒ|ƒCƒ“ƒ^•ϐ”‚É‚»‚ê‚ð‘ã“ü‚µ‚Ä‚¢‚Ü‚·B‚³‚āA(*) ‚ÅŽw‚µ‚Ä‚¢‚é‚à‚̂͂¢‚Á‚½‚¢‚È‚ñ‚Å‚µ‚傤BŽÀ‚́A¡“x‚Ì C Œ¾Œê‚Å‚Í (2) ‚̂悤‚ɁAÔŽš‚ÅŽ¦‚³‚ꂽƒuƒƒbƒN‚ªˆÃ–Ù“I‚É‚¨‚¬‚È‚í‚ê‚Ü‚·B‚»‚ÌŒ‹‰Ê‚Æ‚µ‚āAa ‚à b ‚àŽw‚µ‚Ä‚¢‚é‚à‚̂̕ۏ؂ª–³‚¢‚±‚Æ‚ª•ۏ؂³‚ê‚Ü‚·B‚±‚ê‚́A«—ˆ‚ÌŒ¾Œê‚ÌŽg—p‚ð‰ü’肵‚½ŽžˆÓ}‚µ‚È‚¢Œ‹‰Ê‚ðŠª‚«‹N‚±‚³‚È‚¢‚悤‚É“±“ü‚µ‚½‚»‚¤‚Å‚·B
@‚½‚¾‚±‚ê‚Ì“±“ü‚É‚æ‚èAŠù‘¶‚̃vƒƒOƒ‰ƒ€‚̈Ӗ¡‚ª•Ï‚í‚Á‚Ä‚µ‚Ü‚¤ê‡‚ª‚ ‚è‚Ü‚·B(3) ‚ðŒ©‚Ä‚­‚¾‚³‚¢B


//(3) ‚±‚̕ύX‚ª‹N‚±‚·–â‘è
enum {a, b};
int g(void)
{
@@if(sizeof(enum{b,a}) != sizeof(int))
@@@return a;
@@return b; //b ‚̕Ԃ·’l‚͉½‚©?
}
//C89 ‚̏ꍇFg() == 0
//C99 ‚̏ꍇFg() == 1

(3) ‚ł͎n‚ß‚É a==0, b==1 ‚Æ‚µ‚Ä enum éŒ¾‚ð‚µ‚Ä‚¢‚Ü‚·BŠÖ” g ‚Ì’†‚ł́Asizeof ‚̃Iƒyƒ‰ƒ“ƒh‚Ì’†‚Å b==0, a== 1 ‚Æ‚µ‚Ä enum éŒ¾‚ð‚µ‚Ä‚¢‚Ü‚·B‚µ‚½‚ª‚Á‚ď]—ˆ‚Ì C Œ¾Œê‚ł́Aenum{b,a} ‚̃XƒR[ƒv‚Í‚¸‚Á‚ÆŽ‘±‚µ‚Ä‚¢‚é‚̂ŁAŠÖ” g ‚Í 0 ‚ð•Ô‚·‚±‚ƂɂȂè‚Ü‚·B‚µ‚©‚µ¡“x‚Ì C Œ¾Œê‚ł́Aif •¶‘S‘Ì‚ªƒuƒƒbƒN‚Æ‚µ‚Ä•¢‚í‚ê‚Ä‚¢‚Ü‚·B‚µ‚½‚ª‚Á‚āAenum{b,a} ‚Í if •¶‚ªI‚í‚Á‚½Œã‚ÍŒ©‚邱‚Æ‚ª‚Å‚«‚Ü‚¹‚ñB‚µ‚½‚ª‚Á‚āAƒOƒ[ƒoƒ‹‚È enum{a,b} ‚ªŒ©‚¦AŒ‹‰Ê‚Æ‚µ‚Ċ֐” g ‚Í 1 ‚ð•Ô‚µ‚Ä‚µ‚Ü‚¢‚Ü‚·B

b©‘O•łցb•\ކ‚ցbŽŸ•łց¨b
 
 
•\ކ - ’˜ìŒ  - ’ˆÓŽ–€ - ƒŠƒ“ƒN‚ɂ‚¢‚Ä - 404 ƒGƒ‰[‚ɂ‚¢‚Ä
(c)1999-2014 seclan. All rights reserved.