•\Ž† / Ž©ìƒ\ƒ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.