CŒ¾Œê“ü–å

‰¡“c@šæ

 

CŒ¾Œê‚ŋꂵ‚ñ‚Å‚¢‚él‚ð‘ΏۂɁACƒvƒƒOƒ‰ƒ~ƒ“ƒO‚ðŠw‚ԏã‚Å•K—v‚ȍŒáŒÀ‚ÌŽ–•¿‚ðŽû‚ß‚½Bà–¾‚ð“Ç‚ñ‚ŁA—á‘èA—ûK–â‘è‚ð‚±‚È‚µ‚čs‚­‚¤‚¿‚ɁAŽ©‘R‚ÉCŒ¾Œê‚ªƒ}ƒXƒ^[‚Å‚«‚é‚悤‚É‚µ‚½‚‚à‚è‚Å‚ ‚éB‚µ‚©‚µAC‚ÍŒ¾Œê‚Å‚·BŠF‚³‚ñ‚àŒoŒ±‚µ‚Ä‚¢‚é‚悤‚ɁAŒ¾Œê‚ðK“¾‚·‚éÅ—Ç‚Ì•û–@‚́AgK‚¤‚æ‚芵‚ê‚ëh‚¾BˆÍ‚ñ‚Å‚ ‚éƒvƒƒOƒ‰ƒ€‚Í‚·‚ׂĎ©•ª‚Å‘Å‚¿ž‚ñ‚ŁAŽÀs‚µ‚Ă݂悤B


–ÚŽŸ


CŒ¾Œê“ü–å, 1 

              ‰æ–ʂւ̏o—́@’萔@•\‹L

•Ï”‚ƕϐ”–¼, 59

              ƒf[ƒ^éŒ¾‚̏‘Ž®@Šî–{Œ^@printf‚̏‘Ž®@—ñ‹“Œ^

‘ã“ü‚Æ“ü—Í, 142

’l‚Ì“ü‚ê‘Ö‚¦@ƒL[ƒ{[ƒh‚©‚ç‚Ì“ü—́@ƒRƒ}ƒ“ƒhƒ‰ƒCƒ“ˆø”@scanf‚̏‘Ž®

§Œä\‘¢, 245

’Pƒ‚È•ªŠò@˜_—‰‰ŽZŽq@if•¶@if-else•¶@while•¶@ƒ‹[ƒv‚©‚ç‚Ì’Eo@Max-Min@ Switch•¶@else-if•¶@‚¤‚邤”N‚Ì”»’è@‚QŽŸ•û’öŽ®‚̉ð@‚R€‰‰ŽZŽq

ŒJ‚è•Ô‚µ•¶, 466

              ‚Qæ‚̘a@‘fˆö”•ª‰ð

”z—ñ, 547

              ”z—ñ‚ÌŠT”O@”z—ñ‚ð—p‚¢‚éŠî€@•½‹ÏE•ªŽUE•W€•Î·@‚QŽŸŒ³”z—ñ@s—ñ‚̉ÁŽZ@

s—ñ‚̐Ï

ƒ|ƒCƒ“ƒ^‚ÌŠî‘b, 658

              ƒAƒhƒŒƒX@ƒ|ƒCƒ“ƒ^‚Ƃ́@ƒAƒhƒŒƒX‰‰ŽZŽq@ƒ|ƒCƒ“ƒ^•Ï”@ƒ|ƒCƒ“ƒ^‚Æ”z—ñ

           ƒ|ƒCƒ“ƒ^‚Ɗ֐”ˆø”@swapŠÖ”@‘I‘ð–@ƒ\[ƒg

ŠÖ”‚̍ì‚è•û, 807

              ˆø”‚Ì‚È‚¢ŠÖ”@’lŒÄ‚яo‚µ–@@ŽÀˆø”‚Ɖ¼ˆø”@”z—ñ‚̈ø“n‚µ@ŽQÆ‚É‚æ‚éŒÄ‚яo‚µ

              •¶Žš—ñ‘€ìŠÖ”@strlenŠÖ”

\‘¢‘Ì‚Æ‹¤—p‘Ì, 901

              \‘¢‘̃ƒ“ƒo‚ÌŽQÆ@\‘¢‘̂̃lƒXƒg@‹¤—p‘́@\‘¢‘̂ւ̃|ƒCƒ“ƒ^@“ú•t‚ÆŽžŠÔ

ƒtƒ@ƒCƒ‹‚ÌŠT”O, 1037

              ƒtƒ@ƒCƒ‹‚©‚ç‚Ì“ü—́@ƒtƒ@ƒCƒ‹–¼‚ðŽw’肵‚½“ü—́@ƒtƒ@ƒCƒ‹‚ւ̏‘‚«ž‚݁@

              ƒtƒ@ƒCƒ‹‚ւ̒ljÁ‘‚«ž‚݁@ƒŠƒ_ƒCƒŒƒNƒVƒ‡ƒ“

 


 

CŒ¾Œê“ü–å

‚Ü‚¸ACƒvƒƒOƒ‰ƒ€‚ÌŒ`‚ðŒ©‚Ä‚Ý‚æ‚¤B

 

ˆê”Ê“I‚ÈC‚̃vƒƒOƒ‰ƒ€‚ÍŽŸ‚ÌŒ`‚ð‚µ‚Ä‚¢‚éB

/***************************************************************************

*Program nameFfundamental.c

*AuthorFHisashi Yokota

*DateFDec 1,2000

*PurposeFintroduce how to write C program

****************************************************************************/

‘Oˆ—‹åi—Ⴆ‚Î#include <stdio.h>j‚ª‚Ps–Ú‚É‚­‚é

ƒvƒƒgƒ^ƒCƒvéŒ¾iƒvƒƒOƒ‰ƒ€‚ÅŽg—p‚·‚éŠÖ”‚ÌŒ^A–¼‘OAˆø”‚ð‘‚­j

@@@@@@@@/*‚Ps‚ ‚¯‚éB/*‚©‚ç*/‚܂ł̓Rƒƒ“ƒg‚Æ‚È‚é*/

void main(void)@( gcc for win32‚̏ꍇ@int main(void)@‚Ü‚½‚Í’P‚Émain( )‚Ə‘‚­)

{  @@@@@@@/*mainŠÖ”‚ÌŽn‚Ü‚è*/

éŒ¾•”‚¨‚æ‚Ñ’è‹` (‚±‚ê‚©‚ç—p‚¢‚é•Ï”‚ÌŒ^éŒ¾‚ð‚·‚é)

ƒƒCƒ“ƒvƒƒOƒ‰ƒ€ (d—v‚È•”•ª‚ŁA‚±‚±‚̏‘‚«•û‚ðŠw‚ñ‚Å‚¢‚­)

}

ŠÖ”Œ^@ŠÖ”–¼i‰¼ˆø”j

{

éŒ¾•”‚¨‚æ‚Ñ’è‹`

ŠÖ”‚̃vƒƒOƒ‰ƒ€

}

 

‚±‚̃eƒLƒXƒg“à‚̃vƒƒOƒ‰ƒ€‚ɂ́AŽ†–Ê‚Ì“s‡ãƒvƒƒOƒ‰ƒ€‚̍ŏ‰‚É‚­‚éƒRƒƒ“ƒg‚Í•t‚¯‚Ä‚¢‚È‚¢‚ªAŽ©•ª‚̃vƒƒOƒ‰ƒ€‚É‚Í•K‚¸ƒRƒƒ“ƒg‚ð‚‚¯‚é‚悤‚É‚·‚éB

 

ŽÀÛ‚ɃvƒƒOƒ‰ƒ€‚ð‘‚¢‚ÄŽÀs‚µ‚Ă݂悤BŽg‚Á‚Ä‚¢‚éƒGƒfƒBƒ^‚âƒRƒ“ƒpƒCƒ‰‚É‚æ‚èì‹ÆƒXƒeƒbƒv‚ªˆÙ‚È‚é‚̂ŁA‚±‚±‚ł́ADJGPP‚Ìgcc‚ÆVisualC++‚Å‚Ì‘€ì•û–@‚ð‹“‚°‚éB

 

—á‘è‚PD‚P@‰æ–ʂւ̏o—Í

Hello@world@

              ‰‚ß‚Ä‚ÌC

‚Ɖæ–Ê‚É•\Ž¦‚µ‚Ă݂悤B

ŽÀsŒ‹‰Ê

          

l‚¦•û

CŒ¾Œê‚É‚Íprintf‚Æ‚¢‚¤‰æ–Ê‚É•\Ž¦‚·‚邽‚ß‚Ì•W€ŠÖ”‚ª—pˆÓ‚³‚ê‚Ä‚¢‚éBŽg‚¢•û‚Íprintf(g  g);‚Ń_ƒuƒ‹ƒNƒH[ƒgh“à‚Ì•¶Žš‚Í‚»‚Ì‚Ü‚Ü•\Ž¦‚³‚ê‚éB‰üs‚·‚é‚É‚Í\n‚ƃ_ƒuƒ‹ƒNƒH[ƒg“à‚ŏ‘‚­B‚Ü‚½A’i—Ž‚ðŽæ‚é‚É‚Í\t‚Ə‘‚¯‚΂悢B

 

‰ð“š@C‚ŏ‘‚­‚ÆŽŸ‚̂悤‚É‚È‚éB

/* hello.c*/

#include <stdio.h>@/* •W€ƒ‰ƒCƒuƒ‰ƒŠ‚̏î•ñ‚ðŽæ‚荞‚Þ*/

void main(void)    /* Å‰‚Ìvoid‚Í‚±‚̊֐”‚͉½‚à•Ô‚³‚È‚¢‚±‚Æ‚ðˆÓ–¡‚µAvoid‚͈ø”i‘¼‚̊֐”‚É“n‚·’lj‚ª‚È‚¢‚±‚Æ‚ðˆÓ–¡‚·‚éBvoid‚Ƃ͉pŒê‚Å–³*/

{                  /* main‚Ì•¶‚͑劇ŒÊ‚ň͂Þ*/

printf(gHello world\n\t‰‚ß‚Ä‚ÌC\nh);

}

 

‚±‚̃vƒƒOƒ‰ƒ€‚ðƒGƒfƒBƒ^‚ðŽg‚Á‚ď‘‚«Ahello.c‚Æ‚¢‚¤–¼‘O‚ð•t‚¯‚Ä•Û‘¶‚·‚éBŽŸ‚ɁAhello.c‚ðƒRƒ“ƒpƒCƒ‹‚·‚éB

DJGPP‚̏ꍇFƒRƒ}ƒ“ƒhƒvƒƒ“ƒvƒg‚©‚玟‚̂悤‚É‘Å‚¿ž‚Þ

gcc hello.c –o hello.exe

Visual c++‚̏ꍇFVisual c++‚𗧂¿ã‚°Aƒtƒ@ƒCƒ‹‚ðŠJ‚­‚Åhello.c‚ðŠJ‚«Aƒrƒ‹ƒh‚̉º‚É‚ ‚éƒRƒ“ƒpƒCƒ‹‚ðƒNƒŠƒbƒN‚·‚éB

‚±‚Ì‘€ì‚É‚æ‚èAhello.exe‚Æ‚¢‚¤ŽÀsƒtƒ@ƒCƒ‹‚ª‚Å‚«‚é‚̂ŁAŽÀs‚³‚¹‚é‚Ɖæ–Ê‚É

Hello@world@

              ‰‚ß‚Ä‚ÌC

‚Æ•\Ž¦‚³‚ê‚é‚Í‚¸‚Å‚ ‚éB

gcc hello.c -o‚Ì-o‚̓IƒuƒWƒFƒNƒgƒtƒ@ƒCƒ‹‚̐¶¬‚ðˆÓ–¡‚µ‚Ä‚¢‚éB

 

ƒLƒƒƒbƒ`

Windows‚ð—p‚¢‚Ä‚¢‚éê‡Aƒƒ‚’ ‚ðŽg‚Á‚ď‘‚­‚Æhello.c.txt‚Æ•Û‘¶‚³‚ê‚Ä‚µ‚Ü‚¤‚̂őΏˆ‚ª•K—v‚Å‚ ‚éBƒXƒ^[ƒgi‰EƒNƒŠƒbƒNj¨ƒGƒNƒXƒvƒ[ƒ‰¨•\Ž¦¨ƒtƒHƒ‹ƒ_ƒIƒvƒVƒ‡ƒ“¨ƒtƒ@ƒCƒ‹ƒ^ƒCƒv¨V‹K‚ÅŠg’£Žq‚ÌŠÖ˜A•t‚¯‚ðs‚¤

 

hello.c‚Ìà–¾

#include <stdio.h>‚Í•W€“üo—͂̃wƒbƒ_[ƒtƒ@ƒCƒ‹‚ðŒÄ‚эž‚ß‚Æ‚¢‚¤–½—ß‚Å‚ ‚éB‚±‚̃wƒbƒ_[ƒtƒ@ƒCƒ‹‚́Aprintf‚Æ‚¢‚¤ŠÖ”‚ð—p‚¢‚邽‚ß‚É•K—v‚Æ‚È‚éB

void main(void)‚ÍmainŠÖ”‚Ì–ß‚è’l‚ƈø”‚ª‰½‚à‚È‚¢‚±‚Æ‚ð•\‚µ‚Ä‚¢‚éB

o‚©‚çp‚Ü‚Å‚ªmainŠÖ”‚Ì’†g‚Å‚ ‚éB

printf‚Æ‚Í•W€o—́iƒfƒBƒXƒvƒŒƒCj‚֏o—Í‚³‚¹‚邽‚߂̊֐”‚Å‚ ‚èAƒ_ƒuƒ‹ƒNƒH[ƒgh‚©‚çh‚܂ł́A‘‚¢‚½‚à‚Ì‚ª‚»‚̂܂܏o—Í‚³‚ê‚éB

printf“à‚Ì\n‚͍s‚ð•Ï‚¦‚ë‚Æ‚¢‚¤‚±‚Æ‚ðˆÓ–¡‚µA\t‚̓^ƒu‚ðŽæ‚ê‚Æ‚¢‚¤‚±‚Æ‚ðˆÓ–¡‚·‚éB‚±‚ê‚ç‚ðƒGƒXƒP[ƒvƒV[ƒNƒGƒ“ƒXiescape sequencej‚Æ‚¢‚¢A

ƒ_ƒuƒ‹ƒNƒH[ƒg“à‚©‚ç‚Ì’Eo‚ð‚¢‚Ý‚·‚éB‚æ‚­Žg‚¤ƒGƒXƒP[ƒvƒV[ƒNƒGƒ“ƒX‚ð‚ ‚°‚é‚ƁA

\n‚͉üsA\t‚̓^ƒuA\a‚̓xƒ‹A\b‚̓oƒbƒNƒXƒy[ƒXA\h‚́h‚Ì•\Ž¦A\f‚Í f‚Ì•\Ž¦‚È‚Ç‚ª‚ ‚éB

ƒLƒƒƒbƒ`

printf‚Í•K‚¸ÅŒã‚ɃZƒ~ƒRƒƒ“;‚ð‚‚¯‚éB

 


—ûK–â‘è‚PD‚P@ŽŸ‚̃vƒƒOƒ‰ƒ€‚Ìà–¾‚¨‚æ‚уvƒƒOƒ‰ƒ€‚ð“Ç‚ñ‚ŁAÝ–â‚É“š‚¦‚æB

uƒvƒƒOƒ‰ƒ€‚Ìà–¾v

ŽŸ‚̃vƒƒOƒ‰ƒ€‚ðŽÀs‚·‚é‚ƁAˆÈ‰º‚̂悤‚É‚È‚éB

ƒŽÀs—၄

Main‚͍ŏ‰‚É“®‚­ŠÖ”B

printf‚Í•\Ž¦‚·‚邽‚߂̊֐”B

uÝ–âvƒvƒƒOƒ‰ƒ€‚Ì’†‚́ ‚𖄂߂āAƒvƒƒOƒ‰ƒ€‚ðŠ®¬‚¹‚æB‚½‚¾‚µAŽÀs—á‚Ì2s–ڂ̐擪•¶Žš‚́A…•½ƒ^ƒu‚Ì‚ ‚Æ‚Å•\Ž¦‚³‚ê‚é‚à‚Ì‚Æ‚·‚éB

#include <stdio.h>

/* ‚Ps‚ ‚¯‚é*/

void main(void)

{

@@printf(gMain‚͍ŏ‰‚É“®‚­ŠÖ”B@@@printf‚Í•\Ž¦‚·‚邽‚߂̊֐”B\nh)G

}

 

‰ð“š@‰üs‚µ‚ă^ƒu‚ðÝ‚¯‚ê‚΂悢‚̂ŁA\n\t‚ª ‚É“ü‚éB

 

’萔

C‚ł͐”’l‚ðŽÀ”‚Ɛ®”‚Å‹æ•Ê‚·‚éB‚à‚Á‚Əڂµ‚­‚¢‚¤‚ƁA1/2‚Æ1/2.0‚Å‚Í‚Ü‚Á‚½‚­ˆá‚¤’l‚É‚È‚éB1/2‚Í0‚É‚È‚èA1/2.0‚Í0.5‚É‚È‚éB

 

—ûK–â‘è‚PD‚Q@ˆÈ‰º‚̍€–ڂŁAŽÀ”’萔‚Å•\‚·•K—v‚Ì‚ ‚é‚à‚Ì‚Í‚Ç‚ê‚©B

‰ð“šŒQ

ƒA@‘̏d‚Ì•½‹Ï‚ðŒvŽZ‚·‚éB

ƒC@l”‚̍‡Œv‚ðƒJƒEƒ“ƒg‚·‚éB

ƒE@ŽÀs‰ñ”‚ðƒJƒEƒ“ƒgƒAƒbƒv‚·‚éB

 

‰ð“š@‘̏d‚Ì•½‹Ï‚͏¬”“_‚ðŠÜ‚Þ‚Ì‚ÅŽÀ”’萔

 

•\‹L

C‚Å‚Í‚P‚Oi”idecimaljA‚Wi”(octagonal)A‚P‚Ui”(hexagonal)AŽw”‚Ì•\‹L‚ª‰Â”\‚Å‚ ‚éB‚Wi”‚Ì•\‹L‚É‚Í0‚𐔎š‚Ì‘O‚É•t‚¯A‚P‚Ui”‚Å‚Í0x‚ð•t‚¯‚éB—Ⴆ‚΁A‚P‚Oi”‚S‚O‚ð‚P‚Ui”‚É’¼‚·‚Æ

‚S‚O = ‚Q~‚P‚U{‚W

‚Æ‚È‚é‚Ì‚Å0x28‚Æ‚È‚éB

Žw”•\‹L‚Å‚Í‚PD‚Q~‚P‚O‚P‚T‚ð1.2e15‚Æ•\‚·B

 


—ûK–â‘è‚PD‚R@ˆÈ‰º‚Ì‹ó—“‚ð–„‚ß‚æB

10i”

16i”

8i”

‚P‚W

ƒA

ƒC

ƒE

0x25

ƒG

ƒI

ƒJ

012

8

ƒL

ƒN

 

‰ð“š@iƒAj0x12 iƒCj022 iƒEj37 iƒGj045 iƒIj10iƒJj0xa iƒLj0x8

iƒNj010

‚P‚W‚ð‚P‚Ui”‚Å•\‚·‚Æ

18 = 1~16 + 2

‚æ‚è0x12. ‚Wi”‚Å•\‚·‚Æ

18=2~8 + 2

‚æ‚è022.B

0x25‚ð‚P‚Oi”‚Å•\‚·‚Æ

2~16+5=37

‚æ‚è37B‚R‚V‚ð‚Wi”‚Å•\‚·‚Æ

37=4~8+5

‚æ‚è045B

012‚ð‚P‚Oi”‚Å•\‚·‚Æ

1~8+2=10

‚æ‚è10B‚P‚O‚ð‚P‚Ui”‚Å‚ ‚ç‚í‚Æ0xaB

8‚ð‚P‚Ui”‚Å•\‚·‚Æ

8 = 0~16 + 8

‚æ‚è0x8A‚Wi”‚Å•\‚·‚Æ

8=1~8+0

‚æ‚è010‚Æ‚È‚éB

•\‹L•û–@‚É’ˆÓB”’l‚̐擪‚Ɂu0xv‚ª•t‚­‚Æ‚P‚Ui”Au0v‚ª•t‚­‚Æ‚Wi”‚É‚È‚éB

 

—ûK–â‘è‚PD‚S@ˆÈ‰º‚É‚bŒ¾Œê‚Ì‹L–@‚Å•\‚µ‚½”Žš‚ª‚ ‚éB“¯‚¶’l‚Ì‚à‚Ì‚Ç‚¤‚µ‚̃Oƒ‹[ƒv‚É•ª‚¯‚æB

.25e2, 0x25, 25, 012, 37, 8, 1, e1, 8.e0

 

‰ð“š@.25e2=.25~1025 =25   0x25=37   012=1.e1  8=8.e0

ŽÀ”‚́Aue2vue1v‚̂悤‚ɁAŽw”•”‚ð‚‚¯‚Ä•\‚·BuEv‚Å‚à‚æ‚¢B

 

•Ï”‚ƕϐ”–¼

C‚ł͕ϐ”‚Í’l‚ðŽ‚Á‚½” ‚Æ—‰ð‚·‚é‚Æ•ª‚©‚è‚â‚·‚¢B” ‚Ì–¼‘O‚ª•Ï”–¼‚ŁA” ‚Ì’†g‚ª’l‚ƍl‚¦‚éB•Ï”–¼‚É‚Í‚È‚é‚ׂ­’†g‚ª•ª‚©‚è‚â‚·‚¢–¼‘O‚ð•t‚¯‚éB—Ⴆ‚΃eƒXƒg‚Ì•½‹Ï‚ð“ü‚ê‚é” ‚É‚Ítest_ave‚Æ‚¢‚¤–¼‘O‚ð‚‚¯‚éB‚½‚¾‚µAŠô‚‚©‚̐§–ñ‚ª‚ ‚é‚Ì‚Å‹C‚ð‚‚¯‚éB—Ⴆ‚΁A•Ï”–¼‚̍ŏ‰‚Ì•¶Žš‚͉pŽš‚©‰ºü( _ )‚Å‚È‚¯‚ê‚΂Ȃç‚È‚¢‚Æ‚©ƒL[ƒ[ƒhi—\–ñŒêj‚Å‚ ‚Á‚Ä‚Í‚È‚ç‚È‚¢‚È‚Ç‚Å‚ ‚éB

 

ƒf[ƒ^éŒ¾‚̏‘Ž®

C‚ł͕ϐ”‚ð“ü‚ê‚é” ‚ÌŒ^‚ðŒˆ‚ß‚é•K—v‚ª‚ ‚éB‚à‚µA•Ï”test_times‚ªƒeƒXƒg‚̉ñ”‚ð•\‚·‚Æ‚µ‚悤B‚±‚̏ꍇAƒeƒXƒg‚̉ñ”‚Í1,2,3c‚Æ‚¢‚¤®”‚Ȃ̂ŁA®”‚ð‚µ‚Ü‚Á‚Ä‚¨‚­” ‚͐®”Œ^‚Å‚ ‚é‚Ɛ錾‚·‚éB—Ⴆ‚΁A

              int test_times;

‚Ə‘‚­B‚Ü‚½Atest_ave‚ªƒeƒXƒg‚Ì•½‹Ï‚¾‚Æ‚·‚é‚ƁA¬”‚É‚È‚é‰Â”\«‚ª‚ ‚é‚̂ŁAtest_ave‚ð‚µ‚Ü‚Á‚Ä‚¨‚­” ‚ÍŽÀ”Œ^‚Å‚ ‚é‚Ɛ錾‚·‚éB—Ⴆ‚΁A

              float test_ave;

‚Ə‘‚­B

‚µ‚©‚µAƒeƒXƒg‚̉ñ”‚ª‚Q‚Ì‚P‚Tæ‚ð’´‚¦‚é‚悤‚Å‚ ‚ê‚΁Aint‚Å‚Í‚Ü‚¸‚¢B‚»‚Ì‚Æ‚«‚Ílong‚ð—p‚¢‚éB‚±‚̂悤‚ɁA” ‚É“ü‚é’†g‚É‚æ‚Á‚Ä‚»‚ê‚ÉŒ©‡‚Á‚½” ‚ð—pˆÓ‚Å‚«‚é‚悤‚É‚È‚Á‚Ä‚¢‚éB‰º‚ÉC‚Å—p‚¢‚é” ‚ÌŒ^‚ð‹“‚°‚Ä‚¨‚­BŽæ‚荇‚¦‚¸AŠî–{Œ^‚ðƒ}ƒXƒ^[‚µ‚Ä‚¨‚±‚¤B

 

Œ^

Šî–{Œ^

i•¶ŽšŒ^‚Ɛ®”Œ^‚É‚Íunsigned‚ª‚ ‚éj

 

 

\‘¢‚ðŽ‚ÂŒ^

ƒ|ƒCƒ“ƒ^Œ^

 

 

•¶ŽšŒ^

®”Œ^

ŽÀ”Œ^

Œ^‚È‚µ@@@

—ñ‹“Œ^@

”z—ñŒ^

\‘¢‘Ì

‹¤—p‘Ì

 

char

short

int

long

float

double

long double

void

enum

[ ]

struct

union

*

 

—á‘è‚QB‚P@Šî–{Œ^

@@@ char ‚ƒ;@@      /* •¶ŽšŒ^•„†•t*/

@@@ int i;@@         /* ®”•„†•t*/

@@@ unsigned int u;@ /* ®”•„†‚È‚µ*/

@@@ long l;@@       /* ’·‚¢®”•„†•t*/

@@@ float f;@@       /* ŽÀ”•„†•t*/

@@@ double d;@@    /*”{¸“xŽÀ”•„†•t*/

char‚Ícharacteri•¶Žšj‚Ì—ªAint ‚Íintegeri®”j,float‚Ífloat(•‚“®¬”“_)Avoid‚Ívoid(–³)‚Ì‚±‚Æ‚Å‚ ‚éB

ƒLƒƒƒbƒ`

@Žg‚Á‚Ä‚¢‚éƒRƒ“ƒpƒCƒ‰‚âƒRƒ“ƒsƒ…[ƒ^‚É‚æ‚Á‚Đ®”Œ^‚Ìshort , int, long, float,double‚ªˆµ‚¦‚é”͈͂ªˆÙ‚È‚éB

–ÚˆÀ‚Æ‚µ‚āAƒpƒ\ƒRƒ“‚ðŽg‚Á‚Ä‚¢‚él‚Íshort,int‚Æ‚à‚É-32768~32767,long‚Å-2147483648~2147483647,float‚Å‚S

ƒoƒCƒgAdouble‚Å‚WƒoƒCƒgAlong double‚Å‚P‚OƒoƒCƒgB

 

printf‚̏‘Ž®

printf‚̏‘Ž®§Œä•¶Žšˆê——

–¼Ì

•¶Žš

ˆÓ–¡

”õl

•‰‹L†

\

¶‹l‚ß‚ðŽw’è

È—ª‰Â

o—Í•‚P

®”

•¶Žš—ñ‚ÌŒ…”‚̍ŏ¬’l‚ðŽw’è

È—ª‰Â

o—Í•‚Q

®”

•‚“®¬”“_‚̏ꍇ‚ɂ͏¬”“_ˆÈ‰º‚ÌŒ…”

È—ª‰Â

CüŽq

 

‚ˆ

ˆø”‚ÌŒ^d,i,o,u,x‚ðCü‚µˆø”‚ªshortŒ^

È—ª‰Â

‚Œ

Œ^d,i,o,u,x‚ðCü‚µˆø”‚ªlongŒ^

‚Œ

Œ^e,f,g‚ðCü‚µˆø”‚ªdoubleŒ^

L

Œ^e,f,g‚ðCü‚µˆø”‚ªlong doubleŒ^

ˆø”‚ÌŒ^

 

 

d,i,o,x

‚P‚Oi”A‚P‚Oi”A‚Wi”A‚P‚Ui”

È—ª•s‰Â

u

•„†‚È‚µ‚P‚Oi”

c

‚P•¶Žš

s

•¶Žš—ñ‚¨‚æ‚Ñ•¶Žš”z—ñ

e,f,g

•‚“®¬”“_

p

ƒ|ƒCƒ“ƒ^’l

Žg‚¢•û

a=123.e-8;@

printf(g%3.10lfh,a);

‚Ə‘‚­‚Æ0.0000012300‚Æ•\Ž¦‚³‚ê‚éB

 

—ûK–â‘è‚QD‚P@ˆÈ‰º‚̃vƒƒOƒ‰ƒ€‚ÌŽÀsŒ‹‰Ê‚ª‚Ç‚¤‚È‚é‚©l‚¦‚æB

#include <stdio.h>

void main(void)

{

                 char  c;

                 int    i;

                 c = eAf;

                 printf(g\nc=%ch,c);

                 i = (int)c;

                 printf(g\ni=%dh,i);

                 printf(g\ni=0x%xh,i);

                 i= 66;

                 printf(g\ni=%dh,i);

                 printf(g\ni=0x%xh,i);

                 c=(char)i;

                 printf(g\nc=%ch,c);

}

‰ð“š@c=A, i=65, i=0x41, i=66, i=0x42, c=B

•¶Žš’萔A‚ð“ü—Í‚·‚é‚ɂ́fAf‚Ə‘‚­B‚Ü‚½A•¶ŽšA‚ÍASCIƒR[ƒh‚Å’l65‚ð•\‚·B

 

—ûK–â‘è‚QD‚Q@ˆÈ‰º‚̕ϐ”‚ɐ錾‚ð•t‚¯‰Á‚¦‚ăvƒƒOƒ‰ƒ€‚ðŠ®¬‚¹‚æB‚½‚¾‚µA•¡”‚̉𓚂ªl‚¦‚ç‚ê‚é‚Æ‚«‚Í‚¢‚¿‚΂ñ¬‚³‚¢ƒTƒCƒY‚ð‘I‚ԁB

#include <stdio.h>

 

void main(void)

{

ƒA

ƒC

ƒE

ƒG

ƒI

ƒJ

@@@ ‚ƒG@@/* •¶ŽšŒ^•„†•t*/

@@@  iG@@/* ®”•„†•t*/

@@@  uG@@/* ®”•„†‚È‚µ*/

@@@  lG@@ /* ’·‚¢®”•„†•t*/

@@@  fG@@/* ŽÀ”•„†•t*/

@@@  dG@@/*”{¸“xŽÀ”•„†•t*/

          

                          c = e–fG

                     i = |32768G

                     u = 65535G

                     l = |2147483648G

                     f = 0D1234567G

                     d = 123.234567G

             

                     printf(g“ch,c)G

                     printf(g“dh,i)G

                     printf(g“uh,u)G

                     printf(g“ldh,l)G

                     printf(g“fh,f)G

                     printf(g“lfh,d)G

}

‰ð“š@iƒAjchar iƒCjint iƒEjunsigned iƒGjlong iƒIjfloat iƒJjdouble

iƒEj‚Ì“š‚¦‚Íunsigned int‚Å‚à‚æ‚¢B

 

—ñ‹“Œ^ienumerationj

‚ ‚é•Ï”‚ÌŽæ‚蓾‚é”͈͂𖾎¦“I‚ÉŽw’è‚Å‚«‚éŒ^‚ð—ñ‹“Œ^‚Æ‚¢‚¤B—Ⴆ‚΁A

              enum Boolean@{Female,Male} sex;

‚Ə‘‚­‚Æ‚«ABoolean‚́AŽ¯•ÊŽq‚Å‚ ‚èAFemale,Male‚Í—ñ‹“ŽqƒŠƒXƒg(enumerator-list)‚ƌĂ΂êAsex‚Í‚±‚Ì—ñ‹“Œ^‚ðŽ‚Á‚½—ñ‹“•Ï”‚Ì–¼‘O‚Æ‚È‚éB

 

‘ã“ü‚Æ“ü—Í

a=13G

‚Ə‘‚­‚ƁAa‚Æ‚¢‚¤•Ï”–¼‚ª‚‚¢‚½” ‚Ì’†‚É‚P‚R‚Æ‚¢‚¤’l‚ª‹L˜^‚³‚ê‚éBCŒ¾Œê‚Ɛ”Šw‚̈Ⴄ‚Æ‚±‚ë‚́AŽ®•¶‚̍Ōã‚ɁuGv‚ð‚‚¯‚邱‚ƂƁA•Ï”‚ÌŒ^‚ðˆÓŽ¯‚µ‚È‚¯‚ê‚΂¢‚¯‚È‚¢“_‚Å‚ ‚éB

ƒLƒƒƒXƒg

ƒLƒƒƒXƒg‚́A•Ï”‚à‚µ‚­‚͒萔‚Ì‘O‚ɂ‚¯‚邱‚Æ‚ÅŒ^‚Ì•ÏŠ·‚ðs‚¤B

iŒ^j•Ï”@iŒ^j’萔

—Ⴆ‚΁A(int)n‚Ə‘‚­‚ƁAn‚Í‚»‚̏ꂾ‚¯®”Œ^‚É‚È‚éB

 

Œ^•ÏŠ·‚𔺂¤‘ã“ü‚Ì–â‘è“_

¬‚³‚È•‚ÌŒ^‚©‚ç‘å‚«‚È•‚ÌŒ^‚É‘ã“ü‚·‚é‚Ì‚Í–â‘è‚È‚¢‚ªA‘å‚«‚ÈŒ^‚©‚珬‚³‚ÈŒ^‚Ö‘ã“ü‚·‚éê‡‚́A‚Ü‚Á‚½‚­ˆÙ‚Ȃ鐔’l‚ɕω»‚·‚é‰Â”\«‚ª‚ ‚éB‚Ü‚½A•„†•t‚«‚Æ•„†‚È‚µ‚̕ϐ”‚Ç‚¤‚µ‚Å‚à’l‚ª•Ï‚í‚邨‚»‚ꂪ‚ ‚éB

 

—ûK–â‘è‚RD‚P@’l‚Ì“ü‚ê‘Ö‚¦

‘ã“ü‚ðŽg‚Á‚āA•Ï”a‚Æ‚‚‚Ì“à—e‚ð‰ó‚³‚¸‚ɁA“ü‚ê‘Ö‚¦‚éƒvƒƒOƒ‰ƒ€‚ðŠ®¬‚¹‚æB‚½‚¾‚µA•Ï”a‚Æ‚‚ˆÈŠO‚ɍì‹Æ—p‚Æ‚µ‚ĕϐ”‚—‚ð—p‚¢‚邱‚Æ‚Æ‚·‚éB

#include <stdio.h>

void main(void)

{

              int a,b,w;

              a=10;

              b=20;

              printf(g\na=%dh,a);

              printf(g\nb=%dh,b);

              /*“ü‚ê‘Ö‚¦*/

(ƒA)

iƒCj

iƒEj

              printf(g\na=%dh,a);

              printf(g\nb=%dh,b);

}

 

ƒŽÀsŒ‹‰Ê„

a=10

b=20

a=20

b=10

‰ð“š

iƒAjw = a;

iƒCja = b;

iƒEjb = w;

 

 

 

 

 

 

‰ðà@•Ï”w‚Éa‚Ì’l‚ð“ü‚ê‚éB‚±‚Ì’iŠK‚ŕϐ”a‚É‚Ía‚Ì’l‚ª“ü‚Á‚Ä‚¢‚éBŽŸ‚ɁA•Ï”a‚ɕϐ”‚‚‚Ì’l‚ð“ü‚ê‚éBÅŒã‚ɕϐ”‚‚‚É‚—‚Ì’l‚ð“ü‚ê‚éB‚±‚ÌŒ‹‰Êa‚É‚Í‚‚‚Ì’lA‚‚‚É‚Ía‚Ì’l‚ª“ü‚邱‚Æ‚É‚È‚éBƒvƒƒOƒ‰ƒ€‚ÌŠî–{‚Ȃ̂Őg‚É•t‚¯‚悤B


—á‘è‚RD‚P@ƒL[ƒ{[ƒh‚©‚ç‚Ì“ü—Í

ƒL[ƒ{[ƒh‚©‚ç‚Ì“ü—́i•W€“ü—́j‚ðŽæ‚荞‚Þ‚Ì‚É•Ö—˜‚È‚à‚̂ɁAscanf‚Æ‚¢‚¤ŠÖ”‚ª‚ ‚éB—Ⴆ‚΁AƒRƒ}ƒ“ƒhƒvƒƒ“ƒvƒgã‚ÅŽ©•ª‚Ì–¼‘O‚ð‘Å‚¿ž‚ñ‚¾‚玟‚̍s‚Ɂh‚±‚ñ‚É‚¿‚Í’NX‚³‚ñh‚Æ•\Ž¦‚·‚éƒvƒƒOƒ‰ƒ€‚ðl‚¦‚Ă݂悤B‚¿‚å‚Á‚Ɠ‚¢B

 

l‚¦•û

ƒL[ƒ{[ƒh‚©‚ç“ü—Í‚µ‚½•¶Žš—ñ‚ð•Û‘¶‚·‚é‚ɂ́A”z—ñname[ ]‚ð—p‚¢‚éB‚±‚Ì’iŠK‚Å‚Í”z—ñ‚ª‰½‚©•ª‚©‚ç‚È‚¢l‚ª–w‚Ç‚ ‚邪A•¶Žš—ñ‚Í”z—ñ‚É“ü‚ê‚é‚ñ‚¾‚Æ—‰ð‚·‚ê‚΂悢B‚Ü‚½AŽæ‚荞‚Þ‚Æ‚«‚ɁA”z—ñ–¼name‚Ì‘O‚É&‚Í•t‚¯‚È‚¢BÚ‚µ‚¢à–¾‚Í‚UÍ‚¨‚æ‚Ñ‚WÍ‚ðŽQÆ‚Ì‚±‚Ɓ@‚ł́AƒvƒƒOƒ‰ƒ€‚ð‘‚¢‚Ă݂悤B

 

‰ð“š

#include <stdio.h>

void main(void)

{

char name[8];@/*name[8]‚Íname‚Æ‚¢‚¤” ‚É‚W‚‚̕¶Žš‚ð“ü‚ê‚éêŠ‚ðŠm•Û*/

printf(g–¼‘O‚Í‚È‚ñ‚Å‚·‚© ?\nh);

scanf(g%sh, name); //‚±‚̏ꍇ‚Í&‚ð‘‚©‚È‚¢B

printf(g‚±‚ñ‚É‚¿‚Í%s‚³‚ñh,name);

}

 

‚±‚Ì—á‘è‚ł́A–¼‘O‚ðƒRƒ}ƒ“ƒhƒ‰ƒCƒ“‚©‚ç“ü—Í‚µ‚½B‚»‚ê‚ɑ΂µ‚āAŽŸ‚Ì—á‘è‚Å‚Í•\Ž¦‚³‚¹‚é‚à‚Ì‚ðƒRƒ}ƒ“ƒhƒ‰ƒCƒ“ˆø”‚Æ‚µ‚ÄŽg‚¤B

‚b{{‚ÌmainŠÖ”‚Ímain(int argc, char *argv[])‚Ə‘‚¯AÅ‰‚Ìint argc‚͈ø”‚̌”‚ð•\‚µAchar *argv[]‚͈ø”‚ƂȂ镶Žš—ñ‚ðˆÓ–¡‚·‚éB‘æ1ˆø”‚Íargv[1]‚Æ‚È‚éB

—á‘è‚RD‚Q@ƒRƒ}ƒ“ƒhƒ‰ƒCƒ“ˆø”

Ž©•ª‚Ì–¼‘O‚ðˆø”‚Æ‚µ‚Ä‘Å‚¿ž‚ñ‚¾‚玟‚̍s‚Ɂh‚±‚ñ‚É‚¿‚Í’NX‚³‚ñh‚Æ•\Ž¦‚·‚éƒvƒƒOƒ‰ƒ€‚ðl‚¦‚Ă݂悤B

 

ŽÀs—á

          

l‚¦•û

main(int args, char *argv[])‚É‚¨‚¢‚Ä‘æ‚Pˆø”A‰¡“c‚́Aargv[1]‚É‘ã“ü‚³‚ê‚éB‚ł́AƒvƒƒOƒ‰ƒ€‚ð‘‚¢‚Ă݂悤B

 

‰ð“š

#include <stdio.h>

void main(int argc, char *argv[])

{

printf(g‚±‚ñ‚É‚¿‚Í%s‚³‚ñh,argv[1]);

}

argv[0]‚ɂ́A‚±‚̃vƒƒOƒ‰ƒ€‚̃fƒBƒŒƒNƒgƒŠ‚ª“ü‚éB

 

scanf‚̏‘Ž®

scanf‚̏‘Ž®§Œä•¶Žšˆê——

–¼Ì

•¶Žš

ˆÓ–¡

”õl

•‰‹L†

\

¶‹l‚ß‚ðŽw’è

È—ª‰Â

o—Í•‚P

®”

•¶Žš—ñ‚ÌŒ…”‚̍ŏ¬’l‚ðŽw’è

È—ª‰Â

o—Í•‚Q

®”

•‚“®¬”“_‚̏ꍇ‚ɂ͏¬”“_ˆÈ‰º‚ÌŒ…”

È—ª‰Â

CüŽq

 

‚ˆ

ˆø”‚ÌŒ^d,i,o,u,x‚ðCü‚µˆø”‚ªshortŒ^

È—ª•s‰Â

‚Œ

Œ^d,i,o,u,x‚ðCü‚µˆø”‚ªlongŒ^

‚Œ

Œ^e,f,g‚ðCü‚µˆø”‚ªdoubleŒ^

L

Œ^e,f,g‚ðCü‚µˆø”‚ªlong doubleŒ^

ˆø”‚ÌŒ^

 

 

d,i,o,x

‚P‚Oi”A‚P‚Oi”A‚Wi”A‚P‚Ui”

È—ª•s‰Â

u

•„†‚È‚µ‚P‚Oi”

c

‚P•¶Žš

s

•¶Žš—ñ‚¨‚æ‚Ñ•¶Žš”z—ñ

e,f,g

•‚“®¬”“_

p

ƒ|ƒCƒ“ƒ^’l

 

ƒLƒƒƒbƒ`

@scanf‚ð—p‚¢‚é‚Æ‚«‚É‚æ‚­‹N‚«‚éƒGƒ‰[‚͈ø”‚Ì‘O‚Ɂ•‚ð–Y‚ê‚邱‚Æ‚Å‚ ‚éB‚½‚¾‚µAˆø”‚ª”z—ñ‚̏ꍇ‚Í&‚ð•t‚¯‚È‚¢BÚ‚µ‚¢‚±‚Ƃ̓|ƒCƒ“ƒ^‚ÌÍ‚Åà–¾‚·‚éBˆø”‚Ì‘O‚́•‚̓AƒhƒŒƒX‚ðˆÓ–¡‚µ‚Ä‚¨‚èA‰ŠwŽÒ‚É‚Í•ª‚©‚è‚Â炢‚̂ŁAC‚̃oƒCƒuƒ‹R•K‚Ì–{‚Å‚Ígetchar‚ð—p‚¢‚Ä‚¢‚éB‚P•¶Žš‚•¶‚̍Ōã‚܂œǂݍž‚Þ‚É‚Í

int c;

while(c = getchar( ) != EOF)

‚Ə‘‚¯‚΂悢BEOF‚Íend of file‚Ì—ª‚Å‚ ‚éB

 

—ûK–â‘è‚RD‚Q@ŽŸ‚̃vƒƒOƒ‰ƒ€‚ŁAo—ÍŽž‚É’l‚ª•Ï‰»‚·‚é‰Â”\«‚ª‚ ‚é‚Ì‚Í‚Ç‚ê‚©B

1  #include <stdio.h>

2  void main(void)

3  {

4            int i,j;

5            long l;

6            float f;

7            double d;

8            scanf(g%dh,&i);

9            scanf(g%ldh,&l);

10          scanf(g%fh,&f);

11          scanf(g%lfh,&d);

12          j=1;

13          i=(int)l;

14          l=(long)f;

15          f=(float)l;

16          l=(long)i;

17          i=j;

18          printf(g%d %ld %fh,i,l,f);

19       }

20        

‰ð“š@longŒ^‚Ìl‚́A13s–Ú‚ÅintŒ^‚Ìi‚É‹­§•ÏŠ·‚µ‚Ä‘ã“ü‚³‚ꂽŒãA‚P‚Us–Ú‚ÅlongŒ^‚É–ß‚³‚ê‚邪A‚P‚Rs–Ú‚ÅŒ…”‚ª—Ž‚¿‚é‰Â”\«‚ª‚ ‚éBfloatŒ^‚Ì‚†‚́A‚P‚Ss–Ú‚ÅlongŒ^‚Ì‚Œ‚É‹­§•ÏŠ·‚µ‚Ä‘ã“ü‚³‚ꂽŒãA‚P‚Ts–Ú‚ÅfloatŒ^‚É–ß‚³‚ê‚邪A‚P‚Ss–ڂŏ¬”•”•ª‚ª—Ž‚¿‚é‰Â”\«‚ª‚ ‚éB

 

—ûK–â‘è‚RD‚R@ŽŸ‚̃vƒƒOƒ‰ƒ€‚ðŽÀs‚µ‚½Œ‹‰Ê‚𐔒l‚Å“š‚¦‚æB

ƒƒvƒƒOƒ‰ƒ€„

#include <stdio.h>

void main(void)

{

              int a,b;

              a=9;

              b=2;

              printf(ga/b‚ÌŒ‹‰Ê=%d\nh,a/b);@/*®”‚Ç‚¤‚µ‚ÌŠ„‚èŽZ‚ðs‚¤‚ƁAŒ‹‰Ê‚͐®”‚Å•\

‚³‚ê‚éB*/

              printf(ga%%b‚ÌŒ‹‰Ê=%d\nh,a%b); /* a%b‚Ía‚ð‚‚‚ÅŠ„‚Á‚½‚ ‚Ü‚è‚ðo‚·*./

}

‰ð“š@a/b‚ÌŒ‹‰Ê=‚SAa%b‚ÌŒ‹‰Ê‚P

a,b‚ªintŒ^‚Ì‚Æ‚«Aa/b‚͐®”‚̏¤‚ð•\‚·Ba%b‚Í‚ ‚Ü‚è‚ð•\‚·B

 

§Œä\‘¢

‚PD’Pƒ‚È•ªŠò@|@“™‰¿‰‰ŽZŽqAŠÖŒW‰‰ŽZŽq

’Pƒ‚È•ªŠò‚Ƃ́AðŒŽ®‚É‚P‚‚̎®‚¾‚¯‚ðŽg‚Á‚½‘I‘ð\‘¢‚Å‚ ‚éB

‚¨‚à‚ÉŽ®‚Æ‚µ‚ẮA“™‰¿‰‰ŽZŽqijAŠÖŒW‰‰ŽZŽqiƒ „j‚ªŽg—p‚³‚ê‚éB•Ï”‚⎮‚ª’P“ƂŐݒ肳‚ê‚邱‚Æ‚à‚ ‚éB‚»‚̏ꍇ‚́A‚»‚Ì•]‰¿’l‚ª‚O‚È‚ç‚΋UA‚OˆÈŠO‚È‚ç‚ΐ^‚Æ‚¢‚¤”»’è‚É‚È‚éB

 

—á@•Ï”‚̏ꍇ

a = 0;

if(a)

{

 printf(ga‚Í‚O‚Å‚Í‚ ‚è‚Ü‚¹‚ñB\nh);

}

else

{

printf(ga‚Í‚O‚Å‚·B\nh);

}

ƒŽÀsŒ‹‰Ê„

a‚Í‚O‚Å‚·B

 

 

 

 

 

—á@Ž®‚̏ꍇ

a=0,b=1;

if(a*b)

{

printf(ga*b‚Í‚O‚Å‚Í‚ ‚è‚Ü‚¹‚ñB\nh);

}

else

{

 printf(ga*b‚Í‚O‚Å‚·B\nh);

}

ƒŽÀsŒ‹‰Ê„

a*b‚Í‚O‚Å‚·B

 

 

 

 

 


‚QD•ªŠòðŒ‚Ì‘g‚ݍ‡‚킹@|@˜_—‰‰ŽZŽq

•ªŠò‚ÌðŒ‚Í”ÍˆÍ‚ÌŽw’è‚È‚Ç‚Ì‚Æ‚«‚ɁA•¡”‘g‚ݍ‡‚킹‚ç‚ê‚éB‚»‚Ì‘g‚ݍ‡‚킹‚ɂ́AŽå‚ɘ_—Ï••‚ƁA˜_—˜abb‚̉‰ŽZ‚ª—p‚¢‚ç‚ê‚éB

—á@˜_—Ïi••j‚̏ꍇF‚˜‚ªa‚©‚ç‚‚‚ÌŠÔ‚É‚ ‚éê‡

a =1;x=2;b=3;

if(a <=x && x <=b)

{

printf(gx‚Ía‚Æ‚‚‚ÌŠÔ‚É‚ ‚éB\nh);

}

else

{

printf(gx‚Ía‚Æ‚‚‚ÌŠÔ‚É‚È‚¢B\nh);

}

 

ƒŽÀsŒ‹‰Ê„

x‚Ía‚Æ‚‚‚ÌŠÔ‚É‚ ‚éB

 

 

 

 

˜_—˜aibbj‚̏ꍇF‚˜‚ªaˆÈ‰º‚Ü‚½‚Í‚‚ˆÈã‚É‚ ‚éê‡

a=1;b=2;x=3;

if(x < a|| b < =x)

{

printf(gx‚Ía‚Æ‚‚‚ÌŠÔ‚É‚È‚¢B\nh);

}

else

{

printf(gx‚Ía‚Æ‚‚‚ÌŠÔ‚É‚ ‚éB\nh);

}

ƒŽÀsŒ‹‰Ê„

x‚Ía‚Æ‚‚‚ÌŠÔ‚É‚È‚¢B

 

 

 

 

 

 

 


if•¶F‚à‚µ`‚È‚ç‚΁`‚·‚é

‚±‚̃_ƒCƒAƒOƒ‰ƒ€‚ðƒtƒ[ƒ`ƒƒ[ƒg‚Æ‚¢‚¤Bƒtƒ[ƒ`ƒƒ[ƒg‚ÍJIS‹KŠi‚Æ‚µ‚Ä‚«‚Ä‚¢‚³‚ê‚Ä‚¢‚邪AƒvƒƒOƒ‰ƒ€‚̍ì‚è•û‚ÌŒ¤‹†‚ªi‚ނɂ‚ê‚āA‚»‚ÌŒ‡“_‚ªŽw“E‚³‚êAŒ»Ý‚Å‚Í‚ ‚Ü‚èŽg‚í‚ê‚Ä‚¢‚È‚¢Bƒtƒ[ƒ`ƒƒ[ƒg‚É•Ï‚í‚é‚à‚Ì‚Æ‚µ‚āANSƒ`ƒƒ[ƒg‚âHCPƒ`ƒƒ[ƒg‚È‚Ç‚ªŠJ”­‚³‚ê‚Ä‚¢‚éB‚Æ‚Í‚¢‚Á‚Ä‚à‚¢‚Ü‚¾‚ÉJIS‹KŠi‚̃tƒ[ƒ`ƒƒ[ƒg‚ð—p‚¢‚Ä‚¢‚éê‡‚ª‚ ‚é‚̂ŁA‘½­‚̉ðà‚ð‚µ‚Ä‚¨‚­Bƒtƒ[ƒ`ƒƒ[ƒg‚Ƃ́AƒAƒ‹ƒSƒŠƒYƒ€‚ÌŠe’iŠK‚̏ˆ—‚ð” ‚Ì’†‚É‹Lq‚µAŠe” ‚ðü‚â–îˆó‚ÅŒ‹‚ñ‚ŁAŒvŽZ‡˜‚ðŽ¦‚·‚à‚Ì‚Å‚ ‚éB

 

—á‘è‚SD‚P@if•¶‚Ì—á@‚Q”‚Ì”äŠr

‚Q‚‚̐”Žš‚ð“Ç‚ÝŽæ‚Á‚Ä”äŠr‚µA‘å‚«‚¢•û‚ð‹‚ß‚éƒvƒƒOƒ‰ƒ€iif•¶‚¾‚¯‚ðŽg‚Á‚āj‚ðì¬‚µ‚悤B

 

l‚¦•û

•Ï”a‚Æb‚ɌĂэž‚ñ‚¾’l‚ð“ü‚ê‚éB‚‚¬‚ɁAa‚Æ‚‚‚Ì’l‚ª‚Ç‚¿‚炪‘å‚«‚¢‚©‚Ì”äŠr‚ð‚·‚éB

‚à‚µa‚ª‚‚‚æ‚è‘å‚«‚¢‚È‚ç‚Îmax‚Ía‚Å‚ ‚éB

‚à‚µb‚ªa‚æ‚è‘å‚«‚¢‚È‚ç‚Îmax‚Í‚‚‚Å‚ ‚éB‚Æ‚È‚éB‚ł́AƒvƒƒOƒ‰ƒ€‚ð‘‚¢‚Ă݂悤B

 

#include <stdio.h>

void main (void)

{

              int max,get_a, get_b;

printf(g2‚‚̐®”‚ð“ü—Í\nh);

              scanf(g%d %dh,&get_a,&get_b);

              if (get_a > get_b) {

              max = get_a;

              printf(g‘å‚«‚¢•û‚Í%d\nh,max);

              }

              if (get_b > get_a) {

              max = get_b;

              printf(g‘å‚«‚¢•û‚Í%d\nh,max);

              }

}

if-else •¶F‚»‚¤‚Å‚È‚¯‚ê‚΁`‚·‚é

ã‚Ì—á‘è‚Åget_a > get_b‚ª³‚µ‚¯‚ê‚΁Amax‚Íget_aB‚»‚¤‚Å‚È‚¯‚ê‚Îmax‚Íget_b‚Æ’¼‚¹‚éB‚‚܂èif-else•¶‚ð—p‚¢‚ď‘‚¢‚½‚Ù‚¤‚ª•ª‚©‚è‚â‚·‚¢B

 


—á‘è‚SD‚Q@if-else •¶‚Ì—á@‚Q”‚Ì”äŠr

‚Q‚‚̐”Žš‚ð“Ç‚ÝŽæ‚Á‚Ä”äŠr‚µA‘å‚«‚¢•û‚ð‹‚ß‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚悤B

 

l‚¦•û

‚à‚µa‚ª‚‚‚æ‚è‘å‚«‚¢‚È‚ç‚Îmax‚Ía‚ŁA‚»‚¤‚Å‚È‚¯‚ê‚Îmax‚Í‚‚‚Å‚ ‚éB

 

‰ð“š

#include <stdio.h>

void main (void)

{

              int max,get_a, get_b;

printf(g2‚‚̐®”‚ð“ü—Í\nh);

              scanf(g%d %dh,&get_a,&get_b);

              if (get_a > get_b) {

              max = get_a;

              printf(g‘å‚«‚¢•û‚Í%d\nh,max);

              }

              else {

             max = get_b;

              printf(g‘å‚«‚¢•û‚Í%d\nh,max);

              }

}

 

while•¶F`‚̊ԁ`‚·‚é

—á‘è‚SD‚R@‘f””»’è

—^‚¦‚ç‚ꂽ”‚ª‘f”‚©‚Ç‚¤‚©”»’è‚·‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚¹‚æB

 

l‚¦•û

‘f”‚Æ‚Í‚P‚Æ‚»‚̐”Ž©g‚Å‚µ‚©Š„‚邱‚Æ‚ª‚Å‚«‚È‚¢”‚Å‚ ‚éB‚»‚±‚ŁA—^‚¦‚ç‚ꂽ”‚ðn‚Æ‚µAn‚ð‚Q‚©‚珇‚Én-1‚܂ł̐”‚ÅŠ„‚Á‚Ä‚¢‚«AŠ„‚èØ‚ê‚È‚¯‚ê‚Αf”‚Å‚ ‚邱‚Æ‚ªŽ¦‚¹‚éBi=‚Q‚©‚珇‚ÉŠ„‚Á‚Ä‚¢‚­‚Æ‚¢‚¤‚±‚Æ‚ðƒvƒƒOƒ‰ƒ€‚ŏ‘‚­‚ƁAi‚ªn‚æ‚菬‚³‚¢ŠÔ‚ÍŽÀs‚·‚é‚Æ‚È‚é‚Ì‚Åwhile(i < n)‚Æ•\‚킹‚éBŽŸ‚ɁAwhileƒ‹[ƒv‚ðŽÀs’†‚ ‚Ü‚è(remainder)‚̍ŏ¬’l(min_remainder)‚ð‹‚ß‚éB‚₪‚āAi‚ªn‚É“ž’B‚µwhileƒ‹[ƒv‚ªI—¹‚·‚éB‚»‚ÌŒãA‚ ‚Ü‚è‚̍ŏ¬’l(min_remainder)‚Ì’l‚ª‚O‚©‚OˆÈŠO‚©‚𒲂ׂê‚΁An‚ª‘f”‚©‚Ç‚¤‚©‚Ì”»’肪‚Å‚«‚éBƒvƒƒOƒ‰ƒ€‚ɏ‘‚­‚ÆŽŸ‚̂悤‚É‚È‚éB


‰ð“š

/*‘f””»’è*/

#include <stdio.h>

 

void main(void)

{

              int get_num,min_remainder=1,remainder,index=2;

              printf("®”‚ð“ü—Í‚µ‚Ä‚­‚¾‚³‚¢\n");

              scanf("%d",&get_num);

@@@@if(get_num==1)

        {

            min_remainder=0;

        }

              while(index < get_num)

              {

                  remainder = get_num%index;

                  if(remainder < min_remainder)

                  {

                      min_remainder=0;

                  }

                  index++;

              }

              if(min_remainder !=0)

              {

                  printf("%d‚Í‘f”‚Å‚·",get_num);

              }

              else

{

            printf("%d‚Í‘f”‚Å‚Í‚ ‚è‚Ü‚¹‚ñ",get_num);

  }

}

‚à‚¤­‚µ‚æ‚­l‚¦‚Ă݂悤B‚Q‚ÅŠ„‚èØ‚ê‚鐔i‹ô”j‚Í‚QˆÈŠO‘f”‚Å‚Í‚È‚¢B‚Ü‚½A‘f”‚Å‚È‚¢”i‡¬”j‚Ì–ñ”‚͑΂ɂȂÁ‚Ä‚¢‚é‚̂ŁAn‚Ì•½•ûª‚܂ł̐”‚ðƒ`ƒFƒbƒN‚·‚ê‚΂悢‚±‚Æ‚ª•ª‚©‚éB‚±‚̍l‚¦‚ð—p‚¢‚āA‚à‚¤ˆê“xƒvƒƒOƒ‰ƒ€‚ð‘‚¢‚Ă݂悤B


 

#include <stdio.h>

void main(void)

{

              int get_num,index=2,remainder,min_remainder=1;

              printf("®”‚ð“ü—Í‚µ‚Ä‚­‚¾‚³‚¢\n");

              scanf("%d",&get_num);

              if (get_num==1)

              {

                            min_remainder=0;

              }

              if(get_num > 2 && get_num%2 == 0)

              {

                            min_remainder=0;

              }

              while (index*index <= get_num) /* =‚ª•K—v‚Æ‚È‚é*/

              {

                            remainder = get_num%index;

                            if(remainder < min_remainder)

                            {

                               min_remainder=0;

                            }

                            index++;

              }

              if(min_remainder != 0)

              {

                            printf("%d‚Í‘f”‚Å‚·\n",get_num);

              }

              else

              {

                            printf("%d‚Í‘f”‚Å‚Í‚ ‚è‚Ü‚¹‚ñ\n",get_num);

              }

}

 

‚±‚¤‚¢‚¤ƒvƒƒOƒ‰ƒ€‚ðŽÀs‚³‚¹‚é‚Æ‚«A‚»‚Ì“s“xƒGƒOƒ[ƒtƒ@ƒCƒ‹iŽÀsƒtƒ@ƒCƒ‹j‚𗧂¿ã‚°‚È‚¯‚ê‚΂Ȃ炸A–Ê“|‚Å‚ ‚é‚ÆŠ´‚¶‚½l‚͏­‚È‚­‚È‚¢‚¾‚낤B‚»‚±‚ŁAD‚«‚ȉñ”‚¾‚¯ŽÀs‚³‚¹‚ç‚ê‚é•û–@‚ðŽ¦‚·B

              int choice=0;

              do

              {

              choice =1;

              printf ("‘±‚¯‚éê‡‚Í0‚ð‚â‚ß‚é‚Æ‚«‚Í0ˆÈŠO‚̐”ŽšƒL[‚ð‰Ÿ‚µ‚Ä‚­‚¾‚³‚¢");

              scanf(g%dh,&choice)

              }while(choice==0);‚Æ“ü‚ê‚Ä‚¨‚­B‚±‚ê‚É‚æ‚è0‚ð‰Ÿ‚¹‚Α±s‚Å‚«‚邵AŽ~‚ß‚½‚¯‚ê‚Î0ˆÈŠO‚̃L[‚ð‰Ÿ‚¹‚΂悢B

 

ƒ‹[ƒv‚©‚ç‚Ì’Eo

while,for,do-while•¶‚ð—p‚¢‚é‚Æ‚«A‹C‚ð‚‚¯‚È‚¯‚ê‚΂Ȃç‚È‚¢‚̂́A–³ŒÀƒ‹[ƒv‚É‚¨‚¿‚¢‚è‚â‚·‚¢‚±‚Æ‚Å‚ ‚éB‚±‚̂悤‚È‚±‚Æ‚ð”ð‚¯‚é‚½‚߂ɁAƒ‹[ƒv‚ÌðŒ‚Í“_‚Å‚Í‚È‚­A‹æŠÔ‚Æ‚·‚é‚ׂ«‚Å‚ ‚éB“Á‚ɁAwhile(1),for(;;)‚È‚Ç‚Ì–³ŒÀƒ‹[ƒv‚Å‚Í‚¶‚ß‚él‚ª‚¢‚邪ACtrl+C‚Å’Eo‚ð}‚é‚悤‚ȃvƒƒOƒ‰ƒ€‚͐â‘΂ɏ‘‚­‚ׂ«‚Å‚Í‚È‚¢B

‚³‚āAƒ‹[ƒv‚©‚ç‚Ç‚¤‚µ‚Ä‚à’Eo‚·‚é•K—v‚ª‚ ‚é‚Æ‚«‚ɂ́Aif•¶‚Æbreak•¶‚ð—p‚¢‚éB—Ⴆ‚΁AƒL[ƒ{[ƒh‚©‚çƒf[ƒ^‚ð“ü—Í‚µ‚āA‚O‚ð“ü—Í‚µ‚½‚çI—¹‚µ‚½‚¢ê‡‚ðl‚¦‚悤B‚±‚Ì‚Æ‚«‚́A

while(scanf(g%dh,&data))

{

              if (data == 0)

              {

                            break;

              }

}

‚Ə‘‚¯‚΂悢Bwhileƒ‹[ƒv‚ÌðŒ‚Íscanf(g%dh,&data)‚Å‚ ‚邪Ascanf‚͌Ăэž‚݂ɐ¬Œ÷‚·‚é‚Æ‚P‚ð•Ô‚µAŽ¸”s‚·‚é‚Æ‚O‚ð•Ô‚·ŠÖ”‚Ȃ̂ŁA‚±‚̃‹[ƒv‚Í“ü—Í‚ª‚ ‚éŒÀ‚葱s‚³‚ê‚éBŽŸ‚ɁA“ü—Í‚ª‚O‚Ì‚Æ‚«Aif•¶‚ÌðŒ‚ª^‚Æ‚È‚é‚̂ŁAŽŸ‚Ìbreak•¶‚É“ž’B‚µA‚±‚±‚ŁAwhileƒ‹[ƒv‚©‚ç’Eo‚·‚éB

 

—á‘è‚SD‚S@(Max-Min) ƒf[ƒ^‚ðƒL[ƒ{[ƒh‚©‚ç“ü—Í‚µA“ü—Í‚µ‚½ƒf[ƒ^‚Ì•½‹ÏAÅ‘å’lAÅ¬’l‚ð‹‚ß‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚悤B‚½‚¾‚µA‚O‚ð“ü—Í‚µ‚½Žž“_‚ŏI—¹‚·‚é‚Æ‚·‚éB

 

l‚¦•û@

‚PD@Å‘å’l‚ƍŏ¬’l‚ðŒ©‚Â‚¯‚é‚ɂ́A‚Ü‚¸A‚PŒÂƒf[ƒ^‚ð“Ç‚ñ‚ŁA‚»‚Ì’l‚ðÅ‘å’l‚ƍŏ¬’l‚É‚µ‚Ä‚¨‚­B‚±‚ê‚ðs‚¤ƒvƒƒOƒ‰ƒ€‚ÍŽŸ‚̂悤‚É‚È‚é
int max,min,ini;
scanf("%d",&ini);
max = min = ini;

‚QD@‚O‚ð“ü—Í‚µ‚½‚çI—¹‚µ‚È‚­‚Ä‚Í‚È‚ç‚È‚¢‚̂ŁAwhile•¶‚Ì’†‚Éif•¶‚Æbreak‚ð
Žg‚Á‚Äwhile‚©‚ç‚Ì’Eo‚ð‚Í‚©‚éBŠÖ”scanf( )‚Í‚¤‚Ü‚­‚¢‚¯‚΂P‚ð•Ô‚µAŽ¸”s‚·‚é
‚Æ‚O‚ð•Ô‚·ŠÖ”‚Ȃ̂ŁAŽŸ‚̂悤‚É‚È‚éB
int data
while(scanf("%d",&data))
{
    if(data == 0)
    {
        break;
    }
‚RD@‚OˆÈŠO‚Ì‚Æ‚«‚́AV‚µ‚­“ǂݍž‚ñ‚¾ƒf[ƒ^‚Æ‚PŒÂ–ڂ̃f[ƒ^‚Æ‚ð”äŠr‚µAV‚µ
‚¢ƒf[ƒ^‚ª‚PŒÂ–Ú‚æ‚è‘å‚«‚¯‚ê‚΁A‚»‚ê‚ðmax‚Æ‚¨‚«A¬‚³‚¯‚ê‚Îmin‚Æ‚¨‚­BŽŸ‚É
ƒf[ƒ^‚ð“ǂݍž‚ñ‚¾‚Æ‚«‚ɁA“ǂݍž‚ñ‚¾ƒf[ƒ^‚Æmax,min‚ð”äŠr‚·‚éBŽŸ‚̂悤‚É‚È
‚éB
int max,min;
if(data > max)
{
    max = data;
}
if(data < min)
{
    min = data;
}
‚SD@•½‹Ï‚͓ǂݍž‚ñ‚¾ƒf[ƒ^‚̘asum‚ð“ǂݍž‚ñ‚¾‰ñ”n‚ÅŠ„‚Á‚Ä‚â‚ê‚΂悢B‚½‚¾
‚µAsum‚àn‚à®”Œ^‚Ȃ̂ŁA•½‹Ï‚ðo‚·‚Æ‚«‚É‚ÍŽÀ”Œ^‚É•Ï‚¦‚Ä‚â‚ç‚È‚¯‚ê‚΂Ȃç‚È
‚¢B‚±‚ê‚̓LƒƒƒXƒg‚ƌĂ΂ê‚é‚à‚Ì‚ðŽg‚Á‚čs‚¤BŽŸ‚̂悤‚É‚È‚éB
sum = sum + data;
n++;
printf("
•½‹Ï‚Í%d",(float)(sum/n));

ˆÈã‚ð‚Ü‚Æ‚ß‚é‚ÆŽŸ‚̂悤‚ȃvƒƒOƒ‰ƒ€‚É‚È‚éB

#include<stdio.h>

void main(void)
{
    int data,sum,n,max,min,ini;
    printf("
”Šw‚̐¬Ñ‚ð“ü—Í‚µ‚Ä‚­‚¾‚³‚¢B\n");
     scanf("%d",&ini);
     sum = ini;
     max = min = ini;
     n = 1;
    while(scanf("%d",&data))
@@{
    if(data == 0)
    {
       break;
    }
    else
    {
        sum=sum+data;
        n++;
        if(data > max)
        {
            max = data;
        }
        if(data < min)
        {
           min = data;
        }
    }
    }
    printf("
•½‹Ï“_‚Í%f\n",(float)(sum/n));
    printf("
Å‚“_‚Í%d\n",max);
    printf("
Å’á“_‚Í%d\n",min);
    printf("
‰ñ”%d",n);
}

 

Switch•¶‚ɂ‚¢‚Ä

CŒ¾Œê‚É‚Íelse-if•¶‚Ì‘ã‚í‚è‚Éswitch•¶‚Æ‚æ‚΂ê‚é‚à‚Ì‚ª‚ ‚邪A‚±‚ê‚̓Rƒ“ƒpƒCƒ‰[‚Ç‚¤‚µ‚ł̈ڐA«‚ªˆ«‚¢‚̂ŁAŽg‚¤‚͍̂T‚¦‚悤Bswitch•¶‚ŏ‘‚¯‚é‚à‚Ì‚Í‚·‚ׂÄelse-if•¶‚ŏ‘‚¯‚éB‚µ‚©‚µA‹t‚͐^‚Å‚Í‚È‚¢B‚Ƃ́AŒ¾‚¤‚à‚̂́Aswitch•¶‚ŏ‘‚©‚ꂽƒvƒƒOƒ‰ƒ€‚ð“Ç‚Þ‚±‚Æ‚à‚ ‚é‚ÆŽv‚¤‚̂ŁAŠÈ’P‚Éswitch•¶‚̏Љî‚ð‚·‚éB

switch (Ž®)

{

              case ’萔Ž®F•¶

              case ’萔Ž®F•¶

              defaultF•¶

}

switch•¶‚Ì“®ì

uƒXƒeƒbƒv‚Pv

              Ž®‚Ì’l‚ð‹‚ß‚é

uƒXƒeƒbƒv‚Qv

              Ž®‚Ì’l‚ª

i‚Pj       case‚̒萔Ž®‚Æ“™‚µ‚¢ê‡A

‚»‚Ìcase‚É‘±‚­•¶‚ɃvƒƒOƒ‰ƒ€‚̐§Œä‚ªˆÚ‚èAŽÀs‚³‚ê‚éB

i‚Qj       ‚Ç‚Ìcase‚Æ‚à“™‚µ‚­‚È‚¢‚ªAdefault‚ª‘¶Ý‚·‚é‚Æ‚«A

default‚É‘±‚­•¶‚ɃvƒƒOƒ‰ƒ€‚̐§Œä‚ªˆÚ‚èAŽÀs‚³‚ê‚éB

i‚Rj@‚Ç‚Ìcase‚Æ‚à“™‚µ‚­‚È‚­Adefault‚ª‘¶Ý‚µ‚È‚¢‚Æ‚«A

ƒvƒƒOƒ‰ƒ€‚̐§Œä‚́Aswitch•¶‚ÌŽŸ‚Ì•¶‚ɈڂéB

 

Šecase‚É‚Í‚P‚ˆȏã‚̐”’l‚ðŽ‚Â’è”‚ ‚é‚¢‚͒萔Ž®‚É‚æ‚é–¼ŽD‚ð•t‚¯‚éBDefault‚Æ‚¢–¼ŽD‚Ì•t‚¢‚½case‚́A‘¼‚Ìcase‚Ì‚Ç‚ê‚à‚ª–ž‘«‚³‚ê‚È‚©‚Á‚½‚Æ‚«‚ÉŽÀs‚³‚ê‚éB

 

—á‘è‚SD‚T@‡ˆÊ‚Ì”»’è

ŽŸ‚̃vƒƒOƒ‰ƒ€‚́A“üÜŽÒ‚Ì”»•Ê‚ðs‚¤ƒvƒƒOƒ‰ƒ€‚Å‚ ‚éB

#include <stdio.h>

 

void main (void)

{

              int rank;

              printf(g‚ ‚È‚½‚̏‡ˆÊ‚́H„„„@g);

              scanf(g%dh,&rank);

 

switch (rank)

{

              case 1:@//case‚Æ‚P‚̊Ԃɂ̓Xƒy[ƒX‚ª“ü‚é

                            printf(g—DŸŽÒ‚ɂ́AŠCŠO—·s‚Å‚·\nh);

                            break;

              case 2:

                            printf(g‚QˆÊ‚Ì‚ ‚È‚½‚ɂ́A‘“à—·s‚Å‚·\nh);

                            break;

              case 3:

                            printf(g3ˆÊ‚Ì‚ ‚È‚½‚ɂ́A}‘Œ”‚Å‚·\nh);

                            break;

              default:

              printf(gƒ^ƒIƒ‹‚ð‚Ç‚¤‚¼\nh);

                            break;

              p

}

 

else-if•¶F‚à‚µ`‚È‚ç‚΁`‚µA‚»‚¤‚Å‚È‚¯‚ê‚΁`‚µA‚»‚¤‚Å‚È‚¯‚ê‚΁`‚µABBB‚»‚¤‚Å‚È‚¯‚ê‚΁`‚·‚éB

—á‘è‚SD‚U@‚¤‚邤”N‚Ì”»’è

¼—ï”N”year‚ð“ü—Í‚µA‚¤‚邤”N‚©‚ð”»’è‚·‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚¹‚æB

 

l‚¦•û@‚¤‚邤”N‚Æ‚Í‚S‚O‚O‚ÅŠ„‚èØ‚ê‚é”N”B‚Ü‚½‚́A‚S‚ÅŠ„‚èØ‚êA‚©‚‚P‚O‚O‚ÅŠ„‚èØ‚ê‚È‚¢”N”‚Ì‚±‚Æ‚Å‚ ‚éB

—Ⴆ‚΂P‚X‚O‚O”N‚Í‚¤‚邤”N‚Å‚Í‚È‚¢B

‚±‚ê‚ðƒvƒƒOƒ‰ƒ€‚É‚·‚é‚ɂ́Aif (year % 400 == 0)‚È‚ç‚΂¤‚邤”NBelse if (year % 4 == 0 && year % 100 != 0)‚È‚ç‚΂¤‚邤”NBelse ‚¤‚é”N‚Å‚Í‚È‚¢B‚ł̓vƒƒOƒ‰ƒ€‚ð‘‚¢‚Ă݂悤B

 

‰ð“š

#include <stdio.h>

void main(void)

{

             int year;

             printf("¼—ï”N‚ð“ü—Í‚µ‚Ä‚­‚¾‚³‚¢\n");

             scanf("%d",&year);

             if(year%400 == 0)

             {

                           printf("%d‚Í‚¤‚邤”N‚Å‚·",year);

             }

             else if(year%4 == 0 && year%100 != 0)

             {

                           printf("%d‚Í‚¤‚邤”N‚Å‚·",year);

             }

             else

             {

                                         printf("%d‚Í‚¤‚邤”N‚Å‚Í‚ ‚è‚Ü‚¹‚ñ",year);

             }

}

if(year%400 == 0)ˆÈ~‚ÍŽŸ‚̂悤‚ɏ‘‚­‚±‚Æ‚à‚Å‚«‚éB

if(year%400 == 0 || (year%4 == 0 && year%100 != 0))

‚â‚Á‚Ă݂悤B

 

—á‘è‚SD‚V@‚QŽŸ•û’öŽ®‚̉ð

ax2 + bx + c = 0‚̉ð‚ð‹‚ß‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚悤B

 

l‚¦•û

”»•ÊŽ®‚ÍD = b2 – 4ac‚Å—^‚¦‚ç‚êA‰ð‚ÌŒöŽ®‚æ‚èA‰ð‚Íx = (-b } ãD)/2a‚Å—^‚¦‚ç‚ê‚éB‚æ‚Á‚Ä

uŒW”a‚ª‚O‚Å‚ ‚èAŒW”‚‚‚ª‚O‚È‚ç‚΁A@iðŒ‚Pj

              ‰ð‚Í‚È‚¢@@@@@@@@@@ i•¶‚Pj

uŒW”a‚ª‚O‚Å‚ ‚èAŒW”‚‚‚ª‚O‚Å‚È‚¯‚ê‚΁iðŒ‚Qj

              ‚˜@= -c/b                       i•¶‚Qj

uŒW”a‚ª‚O‚Å‚È‚­A”»•ÊŽ®‚ª³‚È‚ç‚΁@@iðŒ‚Rj

              ŽÀ”‰ð‚ª‚Q‚@@@@@@@@@@i•¶‚Rj

uŒW”a‚ª‚O‚Å‚È‚­A”»•ÊŽ®‚ª‚O‚È‚ç‚΁@@iðŒ‚Sj

              ŽÀ”‰ð‚Í‚P‚@@@@@@@@@@i•¶‚Sj

uŒW”a‚ª‚O‚Å‚È‚­A”»•ÊŽ®‚ª•‰‚È‚ç‚΁@@iðŒ‚Tj

              •¡‘f”‰ð‚ª‚Q‚@@@@@@@@@i•¶‚Tj

‚±‚ê‚ç‚Í‘S‚Ä•¡”‚Ìif•¶‚ð‘g‚ݍ‡‚킹‚Ä”»’f‚ðs‚í‚È‚¯‚ê‚Î‰ð‚¯‚È‚¢B‚‚܂èswitch•¶‚ł͏‘‚¯‚È‚¢‚Æ‚¢‚¤‚±‚Æ‚Å‚ ‚éB

‚ł̓vƒƒOƒ‰ƒ€‚ð‘‚¢‚Ă݂悤B

 

‰ð“š

#include <stdio.h>

#include <math.h>

 

void main(void)

{

             double a,b,c,D,x1,x2,x3,x4;

             printf("ax^2+bx+c=0‚ÌŽÀ”a,b,c‚ð“ü—Í‚µ‚Ä‚­‚¾‚³‚¢\n");

            

             scanf("%lf %lf %lf",&a,&b,&c);

             D = b*b -4*a*c;

             x1 = (-b + sqrt(D))/(2*a);

             x2 = (-b - sqrt(D))/(2*a);

 

             if(a == 0.0 && b == 0.0)

             {

                           printf("‰ð‚Í‚ ‚è‚Ü‚¹‚ñ\n");

             }

             else if(a == 0.0 && b != 0.0)

             {

                           x1 = -c/b;

                           printf("‰ð‚Í%lf‚Å‚·\n",x1);

             }

             else if (D >0.0)

             {

                           printf("‰ð‚Í%lf‚Æ%f‚Å‚·\n",x1,x2);

             }

             else if(D == 0)

             {

                           printf("‰ð‚͏d‰ð‚Æ‚È‚è%f‚Å‚·\n",x1);

             }

             else

             {

                           x3 = -b/(2*a);

                           x4 = sqrt(-D);

                           printf("‰ð‚Í%lf+i%f‚Æ%lf - i%f‚Å‚·\n",x3,x4,x3,x4);

             }

}

 

—ñ‹“Œ^‚ð—p‚¢‚½if•¶

enum {Female,Male} sex;

 

if(ðŒ= = ^)

{

              sex = Male;

}

else

{

              sex = Female;

}

‚±‚ê‚ŁA—ñ‹“•Ï”sex‚ÍMale‚©Female‚µ‚©Žæ‚ç‚È‚¢‚±‚Æ‚ðA•¶–@“I‚É‚«‚¿‚ñ‚Ɛ錾‚µ‚½B

—ñ‹“•Ï”‚Í—ñ‹“Žq‚É–¾Ž¦“I‚É’l‚ª—^‚¦‚ç‚ê‚È‚¯‚ê‚΁A‘‚©‚ꂽ‡˜‚Ɂu‚Ov‚©‚çŽn‚܂鏇˜”iordinal numberj‚Æ‚È‚éB‚æ‚Á‚āA‚±‚Ì—á‚Å‚ÍFemale‚Í‚OAMale‚Í‚P‚Æ‚È‚é‚̂ŁAðŒ‚ª^‚È‚ç‚΁Asex‚ÍMale‚Æ‚È‚éB

 

—á‘è‚SD‚X—ñ‹“Œ^enum {Female,Male}sex;‚Éscanf‚œǂݍž‚ñ‚¾’l‚ð‘ã“ü‚µAo—Í‚·‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚悤B

 

‰ðà@—ñ‹“Œ^enum {Female,Male}sex;‚É“ü—Í‚·‚é‚ɂ́A‚O‚Ü‚½‚Í‚P‚ðƒL[ƒ{[ƒh‚©‚ç‘łB

o—Í‚·‚é‚É‚Í

printf(g%ch,(self_data.sex = = 0)? eFf:fMf;)‚ð—p‚¢‚éB‚±‚ê‚Í‚R€‰‰ŽZŽq‚ƌĂ΂ê‚é‚à‚̂ŁAŽŸ‚̂悤‚É—p‚¢‚éB

              Ž®‚PHŽ®‚QFŽ®‚R

‚ÌŒ`Ž®‚ð‚Æ‚èAŽ®‚P‚ª^‚È‚ç‚΁AŽ®‚Q‚Ì’l‚ªŽ®‚Ì’l‚Æ‚È‚èA‹U‚È‚ç‚ÎŽ®‚R‚ªŽ®‚Ì’l‚Æ‚È‚éB

‰ð“š@

#include <stdio.h>

#include <string.h>

 

void main(void)

{

             enum {Female,Male}sex;

 

             printf(" «•Ê> \n");

             scanf("%d",&sex);

             printf("\n SEX\n");

             printf("%3c\n",(sex==0)? 'F':'M');

}

 

ŒJ‚è•Ô‚µ•¶

loop‚Æ‚ÍŒJ‚è•Ô‚µ•¶‚Ì‚±‚Æ‚Å‚ ‚éB‘­‚É”½•œˆ—‚ƌĂ΂ê‚Ä‚¢‚ÄCŒ¾Œê‚̍ªŠ²‚ð‚È‚µ‚Ä‚¢‚éB”½•œˆ—‚É‚Íwhile•¶Ado-while•¶‚Æfor•¶‚ª‚ ‚éB

‚»‚̐́AƒRƒ“ƒsƒ…[ƒ^‚̐«”\‚ªˆ«‚©‚Á‚½Žž‘ãA‚Ü‚½A‚µ‚Á‚©‚肵‚½§Œä\‘¢‚¨‚æ‚Ñ”½•œˆ—‚ªƒvƒƒOƒ‰ƒ~ƒ“ƒOŒ¾Œê‚É—pˆÓ‚³‚ꂽ‚¢‚È‚Á‚©‚½Žž‘ãA‘½‚­‚̐l‚ªgoto•¶‚ƌĂ΂ê‚éƒWƒƒƒ“ƒv‚ðŽg‚Á‚ăvƒƒOƒ‰ƒ€‚ð‘‚¢‚Ä‚¢‚½B‚µ‚©‚µA‚P‚X‚U‚O”N‘ãŒã”¼goto•¶‚É‚æ‚Á‚ď‘‚©‚ꂽƒvƒƒOƒ‰ƒ€‚́A‘¼l‚É‚Æ‚Á‚Ă킯‚Ì‚í‚©‚ç‚È‚¢ƒvƒƒOƒ‰ƒ€iƒXƒpƒQƒbƒeƒBƒvƒƒOƒ‰ƒ€j‚É‚È‚èA”ˆ«‚̍ªŒ¹‚Å‚ ‚é‚ÆŒ¾‚í‚êŽn‚ß‚½B‚±‚Ì‚±‚Æ‚æ‚èAƒ\ƒtƒgƒEƒFƒA‚à’ʏí‚̍H‹Æ»•i‚Æ“¯‚¶‚悤‚ɐ¶ŽYŠÇ—‚ª•K—v‚Å‚ ‚é‚Æ‚¢‚¤ŠÏ“_‚©‚çuƒ\ƒtƒgƒEƒFƒAHŠwv‚ª¶‚܂ꂽB‚±‚̂悤‚È—¬‚ê‚Ì’†‚©‚çA•ª‚©‚è‚â‚·‚¢ƒvƒƒOƒ‰ƒ€‚ð‘‚­‚½‚ß‚Ì•û–@˜_‚ª’ñˆÄ‚³‚êA‚»‚Ì’†‚Ì‚P‚‚Ɂu\‘¢‰»ƒvƒƒOƒ‰ƒ~ƒ“ƒOv‚ª‚ ‚éB

\‘¢‰»ƒvƒƒOƒ‰ƒ~ƒ“ƒO‚Ƃ́AŠî–{“I‚É‚R‚‚̍\‘¢‚©‚琬‚è—§‚Á‚Ä‚¢‚éB

‚PDƒvƒƒOƒ‰ƒ€‚͏ォ‚牺‚É—¬‚ê‚éi‡ŽŸj

‚QD§Œä\‘¢

‚RD”½•œˆ—

\‘¢‰»’藝‚É‚æ‚é‚ƁA‚·‚ׂẴAƒ‹ƒSƒŠƒYƒ€‚Í‚±‚Ì‚R‚‚̍\‘¢‚¾‚¯‚Å‹Lq‚Å‚«‚邱‚Æ‚ªØ–¾‚³‚ê‚Ä‚¢‚éB

‚µ‚©‚µA“ú–{Œê‚̍\‘¢‚Ì‚¹‚¢‚È‚Ì‚©A‚Í‚½‚Ü‚½goto•¶¢‘オƒvƒƒOƒ‰ƒ~ƒ“ƒOŒ¾Œê‚ð‹³‚¦‚Ä‚¢‚邹‚¢‚©A“ú–{‚ÌŠw¶‚͍\‘¢‰»ƒvƒƒOƒ‰ƒ~ƒ“ƒO‚ðƒ}ƒXƒ^[‚·‚é‚Ì‚É‘½‘å‚ÈŽžŠÔ‚ð•K—v‚Æ‚µ‚Ä‚¢‚é‚Ì‚ªŒ»ŽÀ‚Å‚ ‚éB

Œ»ÝACŒ¾Œê‚ðŠw‚ñ‚Å‚¢‚éŠw¶‚́Aã‹L‚Ì‚PC‚QC‚R‚¾‚¯‚ŃAƒ‹ƒSƒŠƒYƒ€‚ð‘‚­—ûK‚ð‚µ‚Ä—~‚µ‚¢B

 

—á‘è‚TD‚P@‚Qæ‚̘a

12 + 22 + 32 + 42 + 52 + c + 1002‚ð‹‚ß‚é‚Æ‚¢‚¤ƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚悤B

 

l‚¦•û

‚Š”Ô–Ú‚ª‚Š2‚æ‚è˜a‚Í‚“=s+j2‚Æ•\‚¹‚éB‚±‚ê‚ð‚Š‚ª‚P‚©‚ç‚P‚O‚O‚܂ōs‚¤‚̂ɁAC‚É‚Í‚RŽí—Þ‚ÌŒJ‚è•Ô‚µiloopj‚ª—pˆÓ‚³‚ê‚Ä‚¢‚éBwhile,do while,for ‚Ì‚R‚‚ł ‚éB

ŽŸ‚Ì‚R‚‚̃vƒƒOƒ‰ƒ€‚Í‚·‚ׂē¯‚¶Œ‹‰Ê‚ðo‚µ‚Ä‚­‚ê‚éB

 

/*while loop*/

 

#include <stdio.h>

void main(void)

{

int j=1,s=0;

while(j <=100)

{

s = s + j*j;

j+=1;

}

printf(g%dh,s);

}

/*do while loop*/

 

#include <stdio.h>

void main(void)

{

int j=1,s=0;

do

{

s = s + j*j;

j+=1;

} while(j <=100);

printf(g%dh,s);

}

/*for loop*/

 

#include <stdio.h>

void main(void)

{

int j,s=0;

for(j=1;j<=100;j++){

s = s + j*j;

}

printf(g%dh,s);

}

 

ˆê”Ê“I‚ɁA‚Š”Ô–Ú‚ª‚ ‚éŠÖ”‚†(‚Š)‚Å•\‚¹‚é‚È‚ç‚΁Aã‚ÌŽ®•¶s = s + j*j;‚ðs=s+f(j)‚Ə‘‚«Š·‚¦‚ê‚΂悢B

j++,j+=1,j=j+1‚ÍŠF“¯‚¶‚à‚Ì‚ðˆÓ–¡‚·‚éB

 

—á‘è‚TD‚Q@ŽŸ‚̂悤‚ÈŒ`‚ð•\Ž¦‚·‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚¹‚æB

             

l‚¦•û@ƒŽÀs—á‚P„

printf(g*h);‚Ü‚½‚́A

char aster=f*f;

printf(g%ch,aster);

‚Å‚P‚‚̃AƒXƒ^ƒŠƒXƒN‚ð•\Ž¦‚·‚邱‚Æ‚ª‚Å‚«‚éB‚Å‚Í*****‚Æ•\Ž¦‚·‚é‚É‚Í‚Ç‚¤‚·‚ê‚΂悢‚¾‚낤‚©B@Šm‚©‚Éprintf(g*****h);‚Å‚à‚Å‚«‚邪A‚±‚ê‚ł̓AƒXƒ^ƒŠƒXƒN‚ð”CˆÓ‚̐”‚¾‚¯•\Ž¦‚¹‚æ‚Æ‚È‚é‚ƁA•s‰Â”\‚Å‚ ‚éB‚»‚±‚ŁAprintf(g%ch,aster);‚ð5‰ñŽÀs‚·‚é‚Æ*****‚ª•\Ž¦‚Å‚«‚邱‚Æ‚É‹C‚¯‚΂悢B‚T‰ñŽÀs‚³‚¹‚é‚ɂ́A—Ⴆ‚Îforƒ‹[ƒv‚ð—p‚¢‚é‚Æfor(i=1;i<=5;i++)‚Ə‘‚¯‚΂悢‚±‚Æ‚ð’m‚Á‚Ä‚¢‚éBŽŸ‚ɁA‘æ‚P‰ñ–ڂɂ́A‚P‚‚̃AƒXƒ^ƒŠƒXƒNA‘æ‚Q‰ñ–Ú‚Í‚Q‚‚̃AƒXƒ^ƒŠƒXƒN‚Æ‘‚â‚·‚É‚Í‚Ç‚¤‚·‚ê‚΂悢‚¾‚낤‚©Bi<=5‚Ì5‚Ì‘ã‚í‚è‚ɁAj‚ð—p‚¢‚āAfor(j=1;j<=5;j++){ for(i=1;i<=j;i++)}‚Ə‘‚¯‚΁AŠO‘¤‚̃‹[ƒv‚ª‚P‰ñI—¹‚·‚éŠÔ‚É“à‘¤‚̃‹[ƒv‚ªj‰ñŽÀs‚³‚ê‚邱‚Æ‚É‚È‚éB“à‘¤‚̃‹[ƒv‚ªI—¹‚µ‚½‚çA‰üs‚·‚éB‚ł̓vƒƒOƒ‰ƒ€‚ð‘‚¢‚Ă݂悤B

ƒŽÀs—á‚Q„@ŽÀs—á‚P‚Ƃ̈Ⴂ‚̓AƒXƒ^ƒŠƒXƒN‚ð‰E‹l‚ß‚Å•\Ž¦‚µ‚Ä‚¢‚é‚Æ‚±‚ë‚Å‚ ‚éB‚»‚±‚ŁAƒAƒXƒ^ƒŠƒXƒN‚Ì‘O‚Ƀuƒ‰ƒ“ƒN‚ð‘}“ü‚·‚éƒRƒ}ƒ“ƒh‚ð’ljÁ‚·‚ê‚΂悢B

 

‰ð“š

#include <stdio.h>

 

void main(void)

{

int i,j;

for(j=1;j <= 5;j++)

{

              for(i=1;i<=j;i++)

              {

                  printf("*h);

              }

printf("\n");

}

}

#include <stdio.h>

 

void main(void)

{

int i,j,k;

for(j=4;j >= 0;j--)

{

    for(k=1;k<=j;k++)

    {

    printf(g g);

    }

                 for(i=1;i<=5-j;i++)

                 {

                  printf("*h);

              }

printf("\n");

}

}

 

—ûK–â‘è‚TD‚P@ŽŸ‚̃vƒƒOƒ‰ƒ€‚Ìà–¾‚¨‚æ‚уvƒƒOƒ‰ƒ€‚ð“Ç‚ñ‚ŁAÝ–â‚É“š‚¦‚æB

uƒvƒƒOƒ‰ƒ€‚Ìà–¾v

•W€“üo—Í‚æ‚èƒ^ƒCƒgƒ‹‚Ɛ”’lƒf[ƒ^‚ð“Ç‚ÝŽæ‚èAu–v‚Ì–_ƒOƒ‰ƒt‚ðo—Í‚·‚éƒvƒƒOƒ‰ƒ€‚Å‚ ‚éBƒ^ƒCƒgƒ‹‚Í‚»‚̂܂܃GƒR[ƒoƒbƒN‚·‚éB”’l‚Í“¯”‚́u–v‚É•ÏŠ·‚·‚éB“ü—̓f[ƒ^‚̃^ƒCƒgƒ‹‚Ɛ”’lƒf[ƒ^‚́u,v‚Å‹æØ‚éB

uÝ–âv@ƒvƒƒOƒ‰ƒ€’†‚ÌŠ‡ŒÊ‚𖄂߂āAƒvƒƒOƒ‰ƒ€‚ðŠ®¬‚¹‚æB

#include <stdio.h>

int echo_line(void);@/* ŠÖ”*/

void print_stars(int size); /* ŠÖ”*/

void main(void)

{

              int value;

while(@ƒA@){           /* ƒtƒ@ƒCƒ‹‚̍Ōã‚Ü‚Å“Ç‚Þ*/

              scanf(ƒC,&value);

              print_stars(ƒE);

}

}

int echo_line(void)

{

              int c;

              if(scanf(g%ch,&c) == EOF) return (EOF);

              for( ; ; ƒG) {     /* ‚P•¶Žš‚“ǂݍž‚Þ*/

                            if(@ƒI@)@return( c );

                            else putchar ( c );

              }

}

void print_stars(int size)

{

              int i;

              for( i = 1; ƒJ ; i++) putchar( e*f );

              putchar( ƒL@);

}

‰ð“š@ŠÖ”echo_line( )‚Í•¶Í‚̍Ōã‚ð“ǂނƁAEOF‚ðmainŠÖ”‚É•Ô‚·B‚»‚±‚ŁA•¶‘‚̍Ōã‚܂œǂނɂ̓A‚Éecho_line( ) != EOF‚ª“ü‚éBƒC‚Ívalue‚ð“Ç‚Þ‚½‚߂̏‘Ž®‚È‚Ì‚Å%d‚ª“ü‚éBprint_starŠÖ”‚̈ø”‚́f*f‚̌”‚Å‚ ‚é‚©‚çƒE‚É‚Ívalue‚ª“ü‚éB‹æØ‚蕶Žš‚𔻒肵‚‚‚P•¶Žš‚“ǂނ̂ŃG‚É‚Íc=getchar( )‚ª“ü‚éB‹æØ‚è‚Ì”»’è‚Ȃ̂ŃI‚É‚Íc==f,f‚ª“ü‚éBprint_starŠÖ”‚́A”’l•ªu–v‚ðo—Í‚·‚é‚̂ŁAƒJ‚É‚Íi <=size‚ª“ü‚éBu–v‚̏o—Í‚ÌŒã‚É•K—v‚Ȃ̂́A‰üs‚̏o—Í‚Å‚ ‚é‚̂ŃL‚ɂ́f\nf‚ª“ü‚éB

 

ƒLƒƒƒbƒ`@getchar‚ª‚P•¶Žš‚“ǂݍž‚ނ̂ɑ΂µ‚āAputchar‚Í‚P•¶Žš‚•\Ž¦‚·‚éB

getchar‚Æ‚Íget character‚̈Ӗ¡‚ŁAputchar ‚Íput charcter‚̈Ӗ¡‚Å‚ ‚éB

 

—á‘è‚TD‚R@i‘fˆö”•ª‰ðj®”‚ð“Ç‚ÝŽæ‚Á‚āA‘fˆö”•ª‰ð‚·‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚¹‚æB

ƒˆ——၄

              “ü—Í

              ‚P‚O‚O

              o—Í

              ‚QC‚QC‚TC‚T

l‚¦•û@ƒf[ƒ^n‚ð“Ç‚ÝŽæ‚Á‚āA‚Q‚©‚珇‚ÉŠ„‚Á‚Ä‚¢‚«A‚ ‚鐔m‚ÅŠ„‚ꂽ‚çn/m‚ðV‚½‚Èn‚Æ‚¨‚«A¤‚ª‚P‚É‚È‚é‚Ü‚Å‘±‚¯‚éB‚±‚Ì‚Æ‚«”­¶‚µ‚½Am‚ª‘fˆö”‚Æ‚È‚éB•\Ž¦‚·‚é‚Æ‚«‚ɁAÅŒã‚̐”Žš‚Ì‚ ‚Ƃɂ́uCv‚ð•t‚¯‚È‚¢‚悤‚É‚·‚éB

‚ł́AƒvƒƒOƒ‰ƒ€‚ð‘‚¢‚Ă݂悤B

 

‰ð“š@

#include <stdio.h>

 

void main(void)

{

              int m,n;

              char c = ' ';

 

              printf("®”‚ð“ü—Í‚µ‚Ä‚­‚¾‚³‚¢B");

              scanf("%d",&n);

              for (m=2;n != 1;m++)

             {

                 while(n%m == 0)

                 {

                            n = n/m;

                            printf("%c%d",c,m);

                            c = ',';

                 }

              }

}

 

”z—ñ

”z—ñ‚ÌŠT”O

æ‚É’f‚Á‚Ä‚¨‚­‚ªACŒ¾Œê‚ł́A”z—ñ‚ÍŽŸÍ‚ÅŠw‚Ôƒ|ƒCƒ“ƒ^‚Æ‚ÌŠÔ‚É‹­‚¢ŠÖŒW‚ª‚ ‚é‚̂ŁA”z—ñ‚̓|ƒCƒ“ƒ^‚ƈꏏ‚ÉŠw‚Ô‚±‚Æ‚ðŠ©‚ß‚éB

ƒvƒƒOƒ‰ƒ€‚ðì‚é‚Æ‚«‚ɂ́Aƒf[ƒ^‚ð•Ï”‚Æ‚¢‚¤” ‚É“ü‚ê‚āA‚±‚ê‚ɕϐ”–¼‚Æ‚¢‚¤–¼‘O‚ð•t‚¯‚Ĉµ‚Á‚½B‚µ‚©‚µA‚±‚Ì•û–@‚ł́AƒvƒƒOƒ‰ƒ€‚ðì‚éã‚Å”ñí‚ɍ¢“ï‚ɂȂ邱‚Æ‚ª‚ ‚éB

—Ⴆ‚΁A¡A‚U’i‚̈ø‚«o‚µ‚ɉȖڕʂ̎óu¶‚̐”‚ªŽŸ‚̂悤‚É“ü‚Á‚Ä‚¢‚½‚Æ‚·‚éB
 

’i”

‚P

‚Q

‚R

‚S

‚T

6

“à—e

”÷•ªŠw

Ï•ªŠw

üŒ`‘㐔

CŒ¾Œê

”’l‰ðÍ

‰ž—p”Šw

”—Ê

‚X‚T

‚P‚O‚O

‚T‚T

‚W‚O

‚U‚O

‚S‚O

‚±‚±‚ŁAƒL[ƒ{[ƒh‚©‚çˆø‚«o‚µ‚Ì’i”‚ð•\‚·”‚ð“ü—Í‚µA‚»‚Ì“à—e•¨‚̐”—Ê‚ð•\Ž¦‚·‚éƒvƒƒOƒ‰ƒ€‚ɂ‚¢‚čl‚¦‚Ă݂悤B—Ⴆ‚΁A‚Q‚Æ“ü—Í‚µ‚½ê‡‚É‚Í‚Q’i–ڂ̐ϕªŠw‚ÌŽóu¶‚̐”‚P‚O‚O‚ð•\Ž¦‚µA‚S‚Æ“ü—Í‚µ‚½ê‡‚É‚Í‚S’i–Ú‚ÌCŒ¾Œê‚ÌŽóu¶‚̐”‚W‚O‚ð•\Ž¦‚·‚éB

‚»‚±‚ŁA‚P’i–Ú‚ðdrower‚PA‚Q’i–Ú‚ðdrower‚QA‚Æ‚¨‚­‚Æ,AƒvƒƒOƒ‰ƒ€‚Í

#include <stdio.h>

void main(void)

{

int drower1 = 95;

int drower2 = 100;

int drower3 = 55;

int drower4 = 80;

int drower5 = 60;

int drower6 = 40;

int i;

scanf(g%dh,&i);

if (i == 1) {

printf(g%dh,drower1);

}

else if (i == 2) {

printf(g%dh,drower2);

}

else if (i == 3) {

printf(g%dh,drower3);

}

else if (i == 4) {

printf(g%dh,drower4);

}

else if (i == 5) {

printf(g%dh,drower5);

}

else {

printf(g%dh,drower6);

}

}

‚Æ‚È‚éB‚±‚̃vƒƒOƒ‰ƒ€‚ł́AŒÂX‚̏ꍇ‚ð‹Lq‚¹‚˂΂Ȃ炸A•¡ŽG‚Å’·‚­‚È‚éB‚à‚µA‚±‚ꂪA‘åŠw‘S‘Ì‚ÌŽóu¶‚Æ‚È‚é‚ƁAˆøo‚µ‚̐”‚ª‚P‚O‚O‚â‚Q‚O‚O‚Å‚Í‘«‚è‚È‚­‚È‚Á‚Ä‚µ‚Ü‚¤B‚½‚Æ‚¦A‚±‚ê‚ç‚̕ϐ”‚ðŒÂX‚É’è‹`‚µ‚Ä•\Ž¦‚Å‚«‚½‚Æ‚µ‚Ä‚àA’·‚­‚ÄŒ©’Ê‚µ‚̈«‚¢ƒvƒƒOƒ‰ƒ€‚É‚È‚Á‚Ä‚µ‚Ü‚¤‚¾‚낤B

‚»‚±‚ŁA‚±‚̂悤‚ȏꍇ‚É—p‚¢‚é‚à‚̂ɁA”z—ñiarrayj‚Æ‚¢‚¤‚à‚Ì‚ª‚ ‚éB”z—ñ‚́u‰½”Ԗڂ̃f[ƒ^v‚Æ‚¢‚¤•\Œ»‚ª‚Å‚«‚é•Ï”‚Å‚ ‚éBƒxƒNƒgƒ‹‚âs—ñ‚ð”z—ñ‚ð—p‚¢‚Ä•\Œ»‚·‚邱‚Æ‚à‚Å‚«‚éB

‚PŽŸŒ³”z—ñ‚ð—p‚¢‚邽‚߂ɂ́A•Ï”‚ð”z—ñ‚Æ‚µ‚Ä’è‹`‚·‚é•K—v‚ª‚ ‚éB—Ⴆ‚΁A

int drower[‚U];

‚Æ‚·‚é‚ƁAdrower‚Æ‚¢‚¤”z—ñ‚ð—pˆÓ‚µA‚»‚±‚É‚Í‚UŒÂ‚̃f[ƒ^‚ªŠi”[‚Å‚«‚邱‚Æ‚ðˆÓ–¡‚·‚éB‚±‚̂悤‚É’è‹`‚·‚é‚ƁAdrower[0],drower[1],c,drower[‚T]‚̍‡Œv‚UŒÂ‚̕ϐ”‚ª—pˆÓ‚³‚ê‚éB‚±‚ê‚æ‚èã‚̃vƒƒOƒ‰ƒ€‚ð‚à‚¤ˆê“x‘‚«’¼‚·‚Æ

#include <stdio.h>

void main(void)

{

             int i;

             int drower[6];

             int choice=0;

              

             drower[1] = 95;

             drower[2] = 100;

             drower[3] = 55;

             drower[4] = 80;

             drower[5] = 60;

             drower[6] = 40;

             do

             {

                           choice=1;

                           printf("”Žš‚ð“ü—Í‚µ‚Ä‚­‚¾‚³‚¢\n");

                           scanf("%d",&i);

                           if((i <=0) || (i > 6))

                           {

                           printf("1‚©‚ç‚U‚܂ł̐”Žš‚ð“ü—Í‚µ‚Ä‚­‚¾‚³‚¢\n");

                           }

                           else

                           {

                                         printf("%d\n",drower[i-1]);

                           }

                           printf("‘±‚¯‚½‚¯‚ê‚Î0‚ð“ü—Í");

                           scanf("%d",&choice);

             } while (choice==0);

}

‚Q‚‚̓Y‚¦Žš‚ð‚à‚”z—ñ‚ð‚QŽŸŒ³”z—ñ‚Æ‚¢‚¤B—Ⴆ‚΁A

@int data[‚R][2] = {‚PC‚QC‚RC‚SC‚TC‚U};

‚Æ‚·‚é‚ƁAdata‚Æ‚¢‚¤”z—ñ‚ð—pˆÓ‚µA‚»‚±‚É‚Í‚R‚©‚¯‚é‚QA‚‚܂è‚UŒÂ‚̃f[ƒ^‚ªŠi”[‚Å‚«‚邱‚Æ‚ðˆÓ–¡‚·‚éB‚±‚ê‚́Adata[0][0]=1;data[0][1]=2;data[1][0]=3;data[1][1]=4;data[2][0]=5;data[2][1]=6;‚Æ‘ã“ü‚ðs‚Á‚½‚Ì‚Æ“¯‚¶‚±‚Æ‚Å‚ ‚éB

 

”z—ñ‚ð—p‚¢‚éŠî€

”z—ñ‚ð—p‚¢‚¸‚ɃvƒƒOƒ‰ƒ€‚ª‘g‚ß‚é‚Ì‚Å‚ ‚ê‚΁A”z—ñ‚ðŽg‚í‚È‚¢B

”z—ñ‚ð—p‚¢‚é‚̂́Aƒf[ƒ^‚ð’~‚¦‚Ä‚¨‚¢‚āAŒã‚ōė˜—p‚·‚éê‡‚âA‚»‚̃f[ƒ^‚ÌŠe—v‘f‚ðƒ‰ƒ“ƒ_ƒ€‚ÉŽQÆ‚·‚éê‡‚È‚Ç‚Å‚ ‚éB

 

—ûK–â‘è‚UD‚P@ƒvƒƒOƒ‰ƒ€‚Ì’†‚ÌŠ‡ŒÊ‚¨‚æ‚с ‚𖄂߂āA‘fˆö”•ª‰ð‚̃vƒƒOƒ‰ƒ€‚ðŠ®¬‚¹‚æBƒAƒ‹ƒSƒŠƒYƒ€‚Æ‚µ‚Ä‚Í‚à‚Ƃ̐”’l‚ð¬‚³‚¢‘f”‚©‚珇‚ÉŠ„‚Á‚Ä‚¢‚«A‚»‚ÌŠ„‚Á‚½¤‚ª‚P‚É‚È‚é‚Ü‚ÅŒJ‚è•Ô‚¹‚΂悢B

#include <stdio.h>

#define N_MAX 32768

int flg[N_MAX];

void main(void)

{

int i,j,n;

              printf(gƒf[ƒ^‚ð“ü—Í‚µ‚Ä‚­‚¾‚³‚¢h);

              scanf(g%dh,&n);

              for(i=2; i <=N_MAX; i++)

                            flg[i] = 1;

              for(i=2; i < N_MAX && n! = 1; i++)

              {

              if (flg[i]){

              while(ƒA ==0) {

                            printf(g%5dh,i);
 

ƒC

                            p

                            for(j = 2*i;j < N_MAX; j+=i)

                            flg[j] = 0;

                            }

}

}

‰ð“š@‚·‚Å‚ÉŒ©‚‚¯‚½–ñ”‚Ì”{”ˆÈŠO‚Ì’†‚©‚çAV‚µ‚¢–ñ”‚ðŒŸo‚·‚éƒvƒƒOƒ‰ƒ€‚Å‚ ‚éB–ñ”‚Å‚ ‚éðŒ‚́A—]‚肪‚O‚Ì‚±‚Æ‚Å‚ ‚éB‚æ‚Á‚ăA‚É‚Ín%i‚ª“ü‚èƒC‚É‚Ín/=i‚ª“ü‚éB
 

n/=i‚Æ‚Ín=n/i‚Ì‚±‚Æ‚Å‚ ‚éB‘¼‚É‚àn+=1‚Ín=n+1‚Ü‚½‚Ín++‚Æ•\‚¹‚éB

 

—á‘è‚UD‚P@•½‹ÏE•ªŽUE•W€•Î·@‚à‚¤ˆê‚”z—ñ‚Ì–â‘è‚ðl‚¦‚Ă݂悤B

ŽŸ‚Ì•\‚͍L“‡H‹Æ‘åŠw‚Ì‚ ‚é‰È–Ú‚ÌŠú––ƒeƒXƒg‚Ì“_”‚Å‚ ‚éBƒf[ƒ^‚Í‚R‚Ol•ª‚ ‚éB‚±‚̃f[ƒ^‚ð“ü—Í‚µ‚āA•½‹Ï’lA•ªŽUA•W€•Î·‚ðŒvŽZ‚·‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚Ă݂悤B
 

60 80 70 85 90 45 60 70 55 60 70 80 70 75 80 95 60 40 50 60 70 80 60 70 50 70 80 90 60 70

 

l‚¦•û

‚±‚ê‚ç‚̃f[ƒ^‚ðdjAj=1,2,c30‚ÉŠi”[‚·‚éB•½‹ÏmeanA•ªŽUvarianceA•W€•Î·std_dev‚ÍŽŸ‚ÌŽ®‚Å•\‚¹‚邱‚Æ‚É’ˆÓ‚·‚éB

               

‚±‚ÌŽ®‚ÉŠî‚¢‚č쐬‚µ‚½ƒvƒƒOƒ‰ƒ€‚ÍŽŸ‚̂悤‚É‚È‚éB

‚Ü‚¸Aƒf[ƒ^‚ðŠi”[‚·‚é”z—ñ‚ðdeta[30]‚Æ‚·‚éBƒf[ƒ^‚ð‡‚É“Ç‚Ýž‚Þ‚É‚Ífor(i=0;i<=29;i++)‚Æ”z—ñ‚Í0‚©‚çŽn‚܂邱‚Æ‚É’ˆÓ‚·‚éB‚Ü‚½A•½•ûª‚ð‹‚ß‚é‚½‚ß‚ÉsqrtŠÖ”‚ð—p‚¢‚é‚̂ŁAmath.h‚ðƒCƒ“ƒNƒ‹[ƒh‚µ‚Ä‚¨‚­B


‰ð“š

#include <stdio.h>

#include <math.h>

void main(void)

{

             int data[30];

             double mean,variance,std_dev;

             int i,n = 30;

             double sum;

             for (i = 0;i < n; i++)

             {

                           printf("%d”Ô–Ú‚Ìdata = ", i+1);

                           scanf("%d",&data[i]);

             }

             for (sum = 0.0,i = 0;i < n; i++)

             {

                           sum = sum + data[i];

             }

             mean = sum/n;

             for( sum = 0.0,i = 0;i < n;i++)

             {

                           sum = sum + (data[i] - mean)*(data[i] - mean);

             }

             variance = sum/n;

             std_dev = sqrt(variance);

              

             printf("•½‹Ï@@ =%10.3f\n",mean);

             printf("•ªŽU=%10.3f\n",variance);

             printf("•W€•Î· =%10.3f\n",std_dev);

}

 

‚QŽŸŒ³”z—ñ‚ð—p‚¢‚½s—ñ‚ÌŒvŽZ

‚QŽŸŒ³”z—ñ‚́As—ñŒvŽZ‚Æ‚µ‚Ä‚ÌŽg‚¢“¹‚ª”ñí‚É‘½‚¢B—Ⴆ‚΁A‚Žs‚—ñ‚̍s—ñ‚́AŽŸ‚̂悤‚É’è‹`‚·‚éBn=4,m=5‚Æ‚·‚é‚Æ

float matrix[4][5];

‚Ü‚½‚́Aƒ}ƒNƒ–¼‚ð—p‚¢‚Ä

              #define LOW 4

              #define COLUMN 5

              float matrix[LOW][COLOMN]; 

‚Æ‚µ‚½‚Ù‚¤‚ª‚³‚ç‚É‚æ‚¢B

”z—ñ‚ł́AŠm•Û‚·‚é‹L‰¯—Ê‚ª‘½‚­‚È‚éB‚QŽŸŒ³”z—ñ‚ł́A‚³‚ç‚É‘½‚­‚̗̈æ‚ð•K—v‚Æ‚·‚éB—Ⴆ‚΁A‚Ss‚T—ñ‚Ì‚QŽŸŒ³”z—ñ‚Å‚Í‚Q‚OŒÂ‚Ì—v‘f‚ª•K—v‚ŁA‚±‚±‚Å‚Í—v‘f‚ÌŒ^‚ªfloatŒ`‚Ȃ̂ŁA20~4ƒoƒCƒg@¨80ƒoƒCƒg‚̗̈悪•K—v‚Æ‚È‚éBdoubleŒ^‚É‚·‚é‚ƁA20~8ƒoƒCƒg@¨@160ƒoƒCƒg‚̗̈悪•K—v‚É‚È‚éB‚±‚Ì‚±‚Ì‚±‚Æ‚©‚çA”z—ñ‚ÌŒ^‚́A•K—v‚Æ‚·‚鐸“x‚ðl—¶‚µ‚Ä‚È‚é‚ׂ­Šm•Û‚·‚é—̈æ‚̏¬‚³‚¢Œ^‚ð‘I‚Ԃׂ«‚Å‚ ‚éB

—á‘è‚UD‚Q@s—ñ‚̉ÁŽZ@

ŽŸ‚̂悤‚È‚Ss‚R—ñ‚̍s—ñ‚̘a‚ð‹‚ß‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚Ă݂悤B

l‚¦•û

s—ñAAB‚ÍŽŸ‚̂悤‚É’è‹`‚Å‚«‚éB

              float a[4][3], b[4][3];

‚Ü‚½‚́Aƒ}ƒNƒ–¼‚ð—p‚¢‚Ä

              #define LOW‚R

              #define COLUMN ‚S

‚Æ‚à’è‹`‚Å‚«‚éBŒãX‚Ì‚±‚Æ‚ðl‚¦‚é‚ƃ}ƒNƒ–¼‚ð—p‚¢‚Ä’è‹`‚µ‚Ä‚¨‚­‚Ù‚¤‚ª‚æ‚¢B

‚Ü‚¸As—ñA‚̐¬•ª‚ð“ǂݍž‚ށBs‚Æ—ñ‚ª‚ ‚é‚̂ŁAƒ_ƒuƒ‹ƒ‹[ƒv‚ðì‚éBs‚²‚Ƃɓǂݍž‚ނɂ́AŠO‘¤‚̃‹[ƒv‚ªs‚Å“à‘¤‚̃‹[ƒv‚ª—ñ‚Æ‚È‚éB‚‚܂è

              for (i=0;i < LOW; i++)

              {

                            for (j=0;j < COLUMN;j++)

                            {

                                          printf(gA[%d,%d]=h,i+1,j+1);

                                          scanf(g%fh,&a[i][j]);

                            }

              }

‚Ə‘‚­‚Æ‚Ps–ڂɑ΂µ‚āA‚P—ñ–Ú‚©‚ç‚S—ñ–Ú‚Ü‚Å‚ð“ǂݍž‚Þ‚±‚Æ‚É‚È‚éB

€”õ‚Í‚±‚Ì‚­‚ç‚¢‚É‚µ‚āAƒvƒƒOƒ‰ƒ€‚ð‘‚¢‚Ă݂悤B

 

‰ð“š

#include <stdio.h>

#define LOW 3

#define COLUMN 4

void main(void)

{

             float a[LOW][COLUMN];

             float b[LOW][COLUMN];

             float c[LOW][COLUMN];

             int i,j;

              

             for (i = 0;i < LOW; i++)

             {

                           for (j = 0;j < COLUMN;j++)

                           {

                                         printf("A[%d][%d]=",i+1,j+1);

                                         scanf("%f",&a[i][j]);

                           }

             }

             for (i = 0;i < LOW; i++)

             {

                           for (j = 0;j < COLUMN;j++)

                           {

                                         printf("B[%d][%d]=",i+1,j+1);

                                         scanf("%f",&b[i][j]);

                           }

             }

             for (i = 0;i < LOW; i++)

             {

                           for (j = 0;j < COLUMN;j++)

                           {

                                         c[i][j] = a[i][j] + b[i][j];

                           }

             }

             printf("\nC:\n");

             for (i = 0;i < LOW; i++)

             {

                           for (j = 0;j < COLUMN;j++)

                           {

                                         printf("%10.5f",c[i][j]);

                           }

                           printf("\n");

             }

}

 

—á‘è‚UD‚R@s—ñ‚̐Ï

‚‚¢‚Å‚É‚à‚¤‚P‚‚̗á‚ðŽ¦‚·B‚±‚ê‚ÍŽŸ‚̍s—ñ‚ÌÏ‚ð‹‚ß‚éƒvƒƒOƒ‰ƒ€‚Å‚ ‚éB

l‚¦•û@

s—ñ‚̐ςÍC=AB‚Ì‚Æ‚«AC‚Ìij¬•ª‚Í

               

‚Å‹‚܂邱‚Æ‚É’ˆÓ‚·‚éB‚±‚ê‚͘a‚Å‚ ‚éB˜a‚Ì‹‚ß•û‚́is‚“{‚†i‚Šjj‚Å‚ ‚é‚̂ŁA

              C[i][j] = 0;

              C[i][j] = C[i][j] + a[i][k]*b[k][j];

‚ÅC[i][j]‚ª‹‚Ü‚éB‚ł́AƒvƒƒOƒ‰ƒ€‚ð‘‚¢‚Ă݂悤B

 

‰ð“š

#include <stdio.h>

#define ROW_A 3

#define COLUMN_A 4

#define ROW_B 4

#define COLUMN_B 5

void main(void)

{

              float a[ROW_A][COLUMN_A];

              float b[ROW_B][COLUMN_B];

              float c[ROW_A][COLUMN_B];

              int i,j,k;

               

              for (i = 0;i < ROW_A; i++)

              {

                            for (j = 0;j < COLUMN_A;j++)

                            {

                                          printf("A[%d][%d]=",i+1,j+1);

                                          scanf("%f",&a[i][j]);

                            }

              }

              for (i = 0;i < ROW_B; i++)

              {

                            for (j = 0;j < COLUMN_B;j++)

                            {

                                          printf("B[%d][%d]=",i+1,j+1);

                                         scanf("%f",&b[i][j]);

                           }

             }

             for (i = 0;i < ROW_A; i++)

             {

                           for (j = 0;j < COLUMN_B;j++)

                           {

                                         c[i][j] = 0;

                                         for (k=0;k < ROW_B;k++)

                                         {

                                                       c[i][j] = c[i][j] + a[i][k] * b[k][j];

                                         }

                           }

             }

             printf("\nC:\n");

             for (i = 0;i < ROW_A; i++)

             {

                           for (j = 0;j < COLUMN_B;j++)

                           {

                                         printf("%10.5f",c[i][j]);

                           }

                           printf("\n");

             }

}

 

ƒ|ƒCƒ“ƒ^‚ÌŠî‘b

C‚ł́Aƒ|ƒCƒ“ƒ^‚͍łàd—v‚ÈŠT”O‚Ì‚P‚‚ł ‚éB‚µ‚©‚µA“¯Žž‚ɍłà“ï‰ð‚È•”•ª‚Å‚à‚ ‚éB

ƒAƒhƒŒƒX

‚Ü‚¸‚́AC‚ł͂ǂ̂悤‚ÉŽÀsƒtƒ@ƒCƒ‹‚ªì‚ç‚ê‚é‚Ì‚©‚ð’m‚é•K—v‚ª‚ ‚éBƒGƒfƒBƒ^‚ŏ‘‚¢‚½ƒvƒƒOƒ‰ƒ€iƒ\[ƒXƒvƒƒOƒ‰ƒ€(source program)j‚ðƒRƒ“ƒsƒ…[ƒ^‚Ì—‰ð‚Å‚«‚é‹@ŠBŒê‚É–|–ó‚·‚éiƒRƒ“ƒpƒCƒ‹(compile)jB‚±‚Ì‚Æ‚«‚Å‚«‚½ƒvƒƒOƒ‰ƒ€‚ðƒIƒuƒWƒFƒNƒg(object)‚Æ‚¢‚¤B‚±‚̃IƒuƒWƒFƒNƒgƒ‚ƒWƒ…[ƒ‹‚ð˜AŒ‹‚³‚¹‚邱‚Æ‚ðƒŠƒ“ƒN(link)‚Æ‚¢‚¢A˜AŒ‹‚³‚¹‚éƒvƒƒOƒ‰ƒ€‚ðƒŠƒ“ƒJ(linker)‚Æ‚¢‚¤B‚±‚¤‚µ‚ÄŽÀs‰Â”\Œ`Ž®ƒtƒ@ƒCƒ‹iƒ[ƒhƒ‚ƒWƒ…[ƒ‹(load module)j‚ª‚Å‚«‚éBƒ[ƒhƒ‚ƒWƒ…[ƒ‹‚̓tƒ@ƒCƒ‹‚Æ‚µ‚ăn[ƒhƒfƒBƒXƒN‚È‚Ç‚ÉŠi”[‚³‚ê‚Ä‚¢‚é‚É‚ÅŽå‹L‰¯‘•’uiƒƒ‚ƒŠj‚É“WŠJ‚µ‚È‚¯‚ê‚΂Ȃç‚È‚¢B‚±‚Ì“®ì‚ðƒ[ƒhiloadj‚Æ‚¢‚¢AOS‚É‚æ‚Á‚čs‚í‚ê‚éBƒ[ƒh‚³‚ꂽƒ[ƒhƒ‚ƒWƒ…[ƒ‹‚́A‚»‚̐擪‚©‚çŽÀs‚ðŠJŽn‚³‚ê‚éBˆê”ʂɁAƒƒ‚ƒŠ‚͘A‘±‚µ‚Ä•À‚ñ‚¾ƒoƒCƒg‚Ì—ñ‚ŁAƒ[ƒhƒ‚ƒWƒ…[ƒ‹‚̓ƒ‚ƒŠã‚ɘA‘±“I‚Ƀ[ƒh‚³‚ê‚éB‚±‚̃oƒCƒg‚Ì—ñ‚ɂ́A‚»‚ꂼ‚êƒAƒhƒŒƒX(address)A‚à‚µ‚­‚͔Ԓn‚ƌĂ΂ê‚é˜A‘±‚µ‚½”ԍ†‚ª‚Ó‚Á‚Ä‚ ‚éBCPU‚́A‚±‚̃AƒhƒŒƒX‚ð–Úˆó‚É‚µ‚ăvƒƒOƒ‰ƒ€‚ÌŽÀs‚𐧌䂵‚½‚èAƒf[ƒ^‚̓ǂݍž‚݂⏑‚«o‚µ‚ðs‚¤B‘½‚­‚̏ꍇAƒ[ƒhƒ‚ƒWƒ…[ƒ‹‚͕ϐ”‚â’萔‚Ȃǂ̃f[ƒ^‚ðŠi”[‚µ‚Ä‚¢‚éƒf[ƒ^•”‚ƃvƒƒOƒ‰ƒ€‚̃Aƒ‹ƒSƒŠƒYƒ€‚ð‹Lq‚µ‚½ƒR[ƒh•”‚©‚ç\¬‚³‚ê‚Ä‚¢‚éB‚³‚āA¡‚Ü‚ÅŒ^éŒ¾‚Æ‚©’è‹`‚Æ‚¢‚¤Œ¾—t‚ðŽg‚Á‚Ä‚«‚½‚ªA’è‹`‚³‚ꂽ•Ï”‚̓ƒ‚ƒŠã‚̃AƒhƒŒƒX‚ÉŠ„‚è“–‚Ä‚ç‚ê‚Ä‚¢‚éB

 


ƒ|ƒCƒ“ƒ^‚Æ‚Í

ƒ|ƒCƒ“ƒ^‚Ƃ́Aƒf[ƒ^ƒIƒuƒWƒFƒNƒg‚Ì”z’u‚³‚ê‚Ä‚¢‚郁ƒ‚ƒŠã‚̃AƒhƒŒƒX‚ð•ÛŽ‚·‚é•Ï”‚Å‚ ‚é‚Æ’è‹`‚Å‚«‚éBƒf[ƒ^ƒIƒuƒWƒFƒNƒg‚Ƃ͕ϐ”‚Å‚ ‚é‚ÆŽv‚Á‚Ä‚©‚Ü‚í‚È‚¢B‚»‚µ‚āA•Ï”‚Æ‚Í‚ ‚é’l‚ð“ü‚ê‚Ä‚¨‚­” ‚̂悤‚È‚à‚Ì‚Å‚ ‚éBƒƒ‚ƒŠã‚̃AƒhƒŒƒX‚Ƃ́A‚±‚Ì” ‚ª‚Ç‚±‚É‚ ‚é‚©‚ðŽ¦‚·î•ñ‚ŁA‚±‚̃AƒhƒŒƒX‚ðŠi”[‚·‚é” ‚ªƒ|ƒCƒ“ƒ^(pointer)‚Å‚ ‚éB‚‚܂èAƒ|ƒCƒ“ƒ^‚àƒAƒhƒŒƒX‚Æ‚¢‚¤”’l‚ð“ü‚ê‚é” ‚Ȃ̂ŕϐ”‚Å‚ ‚éB•Ï”‚Æ‚¢‚Á‚Ä‚àA¡‚Ü‚ÅŠwK‚µ‚Ä‚«‚½•Ï”‚Ƃ͈قȂé“_‚ª‚ ‚éBƒ|ƒCƒ“ƒ^•Ï”‚Í‚»‚ꂪŽw‚µŽ¦‚·‘ΏۂƂȂé•Ï”‚ª‘¶Ý‚µ‚È‚¯‚ê‚΁A‰½‚̈Ӗ¡‚à‚È‚¢B

‚Ü‚½Aƒ|ƒCƒ“ƒ^‚à•Ï”‚Ȃ̂ŃAƒhƒŒƒX‚ðŽ‚Á‚Ä‚¢‚éB

 

ƒAƒhƒŒƒX‰‰ŽZŽq

•Ï”’è‹`

@@int x;

‚Æ‚µ‚½‚Æ‚«A•Ï”‚˜‚ª”z’u‚³‚ê‚郁ƒ‚ƒŠ‚̓Rƒ“ƒpƒCƒ‰‚ªŸŽè‚ÉŒˆ‚ß‚Ä‚µ‚Ü‚¤B‚±‚̃AƒhƒŒƒX‚ð’m‚é‚ɂ́AƒAƒhƒŒƒX‰‰ŽZŽq‚Å‚ ‚é&(ampersand)‚ð—p‚¢‚Ä

@ &x

‚Æ‚·‚邱‚ƂŁA‹‚߂邱‚Æ‚ª‚Å‚«‚éB

 

—á‘è‚VD‚P@•Ï”x‚Ì”z’uƒAƒhƒŒƒX‚ð•\Ž¦‚·‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚悤B

 

‰ð“š

#include <stdio.h>

 

void main(void)

{

           int x;

           print(g\n Address = %p\nh,&x);

}

 

ƒLƒƒƒbƒ`

printfŠÖ”‚̏‘Ž®Žw’è%p‚́AANSI‹KŠi‚ÅÌ‘ð‚³‚ê‚½ƒ|ƒCƒ“ƒ^•\Ž¦‘Ž®Žw’è‚Å‚ ‚邪AŒÃ‚¢ƒRƒ“ƒpƒCƒ‰‚ł̓Tƒ|[ƒg‚³‚ê‚Ä‚¢‚È‚¢B

 

ƒ|ƒCƒ“ƒ^•Ï”‚Ì’è‹`

&x‚Å“¾‚ç‚ꂽƒAƒhƒŒƒX‚ð•ÛŽ‚Å‚«‚éƒ|ƒCƒ“ƒ^•Ï”p‚ð’è‹`‚·‚é‚Æ

              int *p;

‚Æ‚È‚éB•Ï”p‚Ì‘O‚ɂ‚¢‚Ä‚¢‚éƒAƒXƒ^ƒŠƒXƒN(*)‚́Aƒ|ƒCƒ“ƒ^‚Æ‚¢‚¤”h¶Œê‚ðì‚é‹L†‚Å‚·B‚±‚ê‚Í”z—ñ‚ðì‚é‚Æ‚«‚ɏo‚Ä‚«‚½ŠpŠ‡ŒÊ[ ]‚Æ“¯‚¶‚悤‚É‚·‚ׂĂ̕û‚É“K—p‚Å‚«‚éB‚ł́A•Ï”x‚̃AƒhƒŒƒX‚Æx•Ï”x‚Ì’l‚ðƒ|ƒCƒ“ƒ^•Ï”‚ðŽg—p‚µ‚Ä•\Ž¦‚µ‚Ă݂悤B

 

—á‘è‚VD‚Q@•Ï”x‚Ì”z’uƒAƒhƒŒƒX‚ðƒ|ƒCƒ“ƒ^‚ð—p‚¢‚Ä•\Ž¦‚·‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚悤B

 

‰ð“š

#include <stdio.h>

 

void main(void)

{

           int x;

      int *p;

 @@ x = 10;

      p = &x;

           printf(g\n Address = %p\nh,p);

      printf(g\n value = %d\nh,*p);

}

ŽÀsŒ‹‰Ê@Address = 0012FF7C

      @@value = 10

‚±‚ê‚́ACPU‚ªƒCƒ“ƒeƒ‹Œn‚Ȃ̂ŃZƒOƒƒ“ƒgƒAƒhƒŒƒX‚ª0012AƒIƒtƒZƒbƒgƒAƒhƒŒƒX‚ªFF7CB

 

ƒLƒƒƒbƒ`

ÅŒã‚̍s‚ðŒ©‚é‚ƁAƒ|ƒCƒ“ƒ^•Ï”p‚ɃAƒXƒ^ƒŠƒXƒN(*)‚ª‚‚¢‚Ä‚¢‚éA‚±‚Ì‚±‚Æ‚É‚æ‚èAƒ|ƒCƒ“ƒ^•Ï”p‚ªŽw‚µŽ¦‚·“à—ei‚±‚̏ꍇA•Ï”‚˜j‚ðŠÔÚ“I‚ÉŽQÆ‚·‚邱‚Æ‚ª‚Å‚«‚éB‚±‚́u–v‚ðŠÔÚ‰‰ŽZŽq‚Æ‚æ‚сA’è‹`‚âéŒ¾‚ÉŒ»‚ê‚é‚Æ‚«‚́Aƒ|ƒCƒ“ƒ^‚Æ‚µ‚Ä‚ÌŒ^‚ðì‚邱‚Æ‚ðŽ¦‚µAŽ®‚Ì’†‚Ń|ƒCƒ“ƒ^•Ï”‚Ì‘O‚ÉŒ»‚ê‚é‚Æ‚«‚͊ԐڎQÆ‚ðŽ¦‚µ‚Ä‚¢‚éB

 

ƒ|ƒCƒ“ƒ^‚Æ”z—ñ

C‚ł̓|ƒCƒ“ƒ^‚Æ”z—ñ‚ÌŠÔ‚É‹­‚¢ŠÖŒW‚ª‚ ‚éB”z—ñ‚Ì“Y‚¦Žš‚ðŽg‚Á‚ÄŽÀs‚Å‚«‚é‚悤‚È‘€ì‚́Aƒ|ƒCƒ“ƒ^‚Å‚Å‚«‚邵Aƒ|ƒCƒ“ƒ^‚ðŽg‚¤‚Ù‚¤‚ªˆê”ʂɍ‚‘¬‚Å‚ ‚éB‚µ‚©‚µA‰SŽÒ‚É‚Æ‚Á‚Ä‚Í•ª‚©‚è‚É‚­‚¢‚Æ‚¢‚í‚ê‚Ä‚¢‚éB‚Ç‚¤‚¾‚낤‚©H

ŽŸ‚̐錾

              int a[10];

‚́A‘å‚«‚³‚ª‚P‚O‚Ì”z—ña‚ð’è‹`‚·‚é‚à‚Ì‚Å‚ ‚éB‚±‚ê‚Ía[0],a[1],ca[9]‚Æ‚¢‚¤–¼‚Ì‚P‚OŒÂ˜A‘±‚µ‚½ƒIƒuƒWƒFƒNƒg‚©‚ç‚È‚éƒuƒƒbƒN‚ƍl‚¦‚邱‚Æ‚ª‚Å‚«‚éB

a[i]‚Ə‘‚­‚ƁAæ“ª‚©‚çi”Ԗڂ̈ʒu‚Ì”z—ñ—v‘f‚ðŽQÆ‚·‚éB

 

pa‚ª®”‚ւ̃|ƒCƒ“ƒ^‚¾‚Æ‚·‚é‚ƁA

              int *pa;

‚Ɛ錾‚³‚êA‘ã“ü

              pa = &a[0];

‚É‚æ‚Á‚Äa‚Ì‚O”Ô–Ú‚Ì—v‘f‚ðŽw‚·‚悤‚Épa‚ªƒZƒbƒg‚³‚ê‚éB‚‚܂èpa‚Ía[0]‚̃AƒhƒŒƒX‚ð•ÛŽ‚·‚éB‚±‚ê‚Å‘ã“ü•¶

              x = *pa;

‚É‚æ‚èa[0]‚Ì“à—e‚ªx‚ɃRƒs[‚³‚ê‚邱‚Æ‚É‚È‚éB

*(pa + 1)‚Í‚Ç‚ñ‚È‚±‚Æ‚ðˆÓ–¡‚·‚é‚Ì‚©

pa‚Ía[0]‚ðŽw‚µŽ¦‚µ‚Ä‚¢‚é‚̂ŁA*(pa+1)‚Ía[1]‚Ì“à—e‚ðŽQÆ‚·‚éB‚Ü‚½Apa+1‚Ía[1]‚̃AƒhƒŒƒX‚Å‚ ‚éB

pa = &a[0]‚Ə‘‚­‚ƁApa‚Æa‚Í“¯‚¶’l‚ð‚à‚B”z—ñ‚Ì–¼‘O‚Í‚»‚̐擪‚Ì—v‘f‚̈ʒu‚Æ“¯‹`‚Å‚ ‚é‚©‚çApa = &a[0]‚Æ‚¢‚¤‘ã“ü•¶‚ÍŽŸ‚̂悤‚É‚à‘‚¯‚éB

              pa = a;

ƒLƒƒƒbƒ`

@scanfŠÖ”‚Å”z—ñ‚ð“ǂݍž‚Þ‚Æ‚«‚ɁA‚æ‚­‚ ‚éŠÔˆá‚¢‚Íscanf(g%sh,&str)‚Ə‘‚¢‚Ä‚µ‚Ü‚¤‚±‚Æ‚Å‚ ‚éB³‰ð‚Íscanf(g%sh,&str[0])‚©scanf(g%sh,str)‚Å‚ ‚éB

 

ƒ|ƒCƒ“ƒ^‚Ɗ֐”ˆø”iÚ‚µ‚­‚Í‚±‚±‚ðŽQÆj

swapŠÖ”

C‚ł͊֐”‚ɑ΂µ‚āAˆø”‚ð’l‚Å“n‚·‚©‚çAŒÄ‚΂ꂽŠÖ”‚Ì‚Ù‚¤‚ŁAŒÄ‚яo‚µ‚½ŠÖ”“à‚̕ϐ”‚𒼐ڕύX‚·‚邱‚Æ‚Í‚Å‚«‚È‚¢B—Ⴆ‚΁A‚ ‚镪—Þ—pƒ‹[ƒ`ƒ“‚ŁAswap‚ƌĂ΂ê‚éŠÖ”‚Å‚Q‚‚̗v‘f‚Ì“ü‚ê‘Ö‚¦‚ðs‚¤‚Æ‚·‚éBŽŸ‚̂悤‚ɏ‘‚¢‚½‚̂ł͏\•ª‚Å‚È‚¢‚Æ‚¢‚¤‚æ‚èŠÔˆá‚¢‚Å‚ ‚éB‰½‚ª‚¢‚¯‚È‚¢‚Ì‚©l‚¦‚Ä‚Ý‚éB

#include <stdio.h>

void swap(int,int);@/* ƒvƒƒgƒ^ƒCƒvéŒ¾*/

void main(void)

{

              int a,b;

              printf("®”‚ð‚Q‚“ü—Í‚µ‚½‚­‚¾‚³‚¢\n");

              scanf("%d %d",&a ,&b);

              if(a < b){

              swap(a,b); /* swapŠÖ”‚ðŒÄ‚яo‚·*/

              }

              printf("%d %d",a,b);

}

void swap(int x, int y)

{

              int temp;

              temp = x;

              x = y;

              y = temp;

}

‚±‚̃vƒƒOƒ‰ƒ€‚ð‰ðÍ‚µ‚Ä‚Ý‚éBswap(a,b)‚Í’l‚É‚æ‚éŒÄ‚яo‚µ‚Å‚ ‚é‚̂ŁAswapŠÖ”‚ªŒÄ‚΂ê‚āA•Ï”a,b‚ªx,y‚É“n‚³‚ê‚éBswapŠÖ”‚Åa‚Æ‚‚‚Ì’l‚Ì“ü‚ê‘Ö‚¦‚ªs‚í‚ê‚邪AŒÄ‚яo‚µ‚½swap(a,b)‚Ìa,b‚ɂ͉½‚̉e‹¿‚à‹y‚Ú‚³‚È‚¢B

³‰ð‚ÍŽŸ‚̂悤‚ɏ‘‚­BŒÄ‚яo‚µ‘¤‚̃vƒƒOƒ‰ƒ€‚ŕύX‚·‚ׂ«’l‚̃|ƒCƒ“ƒ^‚ð“n‚·‚悤‚É‚·‚é•K—v‚ª‚ ‚éB

              swap(&a,&b)G

‰‰ŽZŽq&‚͕ϐ”‚̃AƒhƒŒƒX‚ð—^‚¦‚é‚©‚çA&a‚Ía‚ւ̃|ƒCƒ“ƒ^‚Å‚ ‚éBƒ|ƒCƒ“ƒ^ˆø”‚ðŽg‚¦‚΁AŠÖ”‚Ì’†‚Å‚»‚ê‚ðŒÄ‚ñ‚¾ŠÖ”‚Ì’†‚̃IƒuƒWƒFƒNƒg‚ðƒAƒNƒZƒX‚µ•ÏX‚·‚邱‚Æ‚ª‰Â”\‚É‚È‚éBŽŸ‚ÉŽ¦‚·‚悤‚ɁAswapŽ©g“à‚ł͈ø”‚̓|ƒCƒ“ƒ^‚Æ‚µ‚Đ錾‚³‚êAŽÀÛ‚̔퉉ŽZ”‚Í‚»‚̃|ƒCƒ“ƒ^‚ð’Ê‚µ‚ĊԐړI‚ɃAƒNƒZƒX‚³‚ê‚éB

#include <stdio.h>

void swap(int *,int *);

void main(void)

{

             int a,b;

             printf("®”‚ð‚Q‚“ü—Í‚µ‚½‚­‚¾‚³‚¢\n");

             scanf("%d %d",&a ,&b);

             if(a < b){

             swap(&a,&b);

             }

             printf("%d %d",a,b);

}

void swap(int *px, int *py)

{

             int temp;

             temp = *px;

             *px = *py;

             *py = temp;

}


—ûK–â‘è‚VD‚P@‘I‘ð–@ƒ\[ƒg

ƒ”z—ñ‚ðŽg‚Á‚½–â‘è—၄

uƒvƒƒOƒ‰ƒ€‚Ìà–¾v

1.        ‚±‚̃vƒƒOƒ‰ƒ€‚́A“ü—Í‚³‚ꂽ‚T‚‚̐”’l‚ð¸‡‚É•À‚בւ¦‚éB

2.        •À‚בւ¦‚́A“à•”‚Ì”z—ñ‚„‚ōs‚í‚ê‚éB

3.        •À‚בւ¦‚̏‡˜‚́A‚„‚̐擪‚©‚珇‚ɍŏ¬‚Ì‚à‚Ì‚©‚çÝ’肳‚ê‚éB

4.        Å¬‚Ì’l‚ðÝ’è‚·‚é•û–@‚́Aæ“ª‚Ì’l‚Æ‚»‚êˆÈ~‚Ì’l‚ð”ä‚ׂĂ¢‚«Aæ“ª‚æ‚菬‚³‚È’l‚ðŒ©‚Â‚¯‚½‚çæ“ª‚Ì’l‚Æ‚»‚Ì’l‚ðŽæ‚è‘Ö‚¦‚邱‚Æ‚Å‚ ‚éB

5.        ’l‚ðŽæ‚è‘Ö‚¦‚é‚ɂ́AŠÖ”swap‚ð—p‚¢‚éBŠÖ”swap‚̈ø”‚ÍŽæ‚è‘Ö‚¦‚é”z—ñ‚Ì‚Q‚‚̃AƒhƒŒƒX‚Å‚ ‚éB

6.        æ“ª‚̍ŏ¬’l‚ªÝ’肳‚ê‚éBŽŸ‚́A‚Q”Ô–Ú‚ðæ“ª‚Æ‚µ‚āA‚»‚êˆÈ~‚̍ŏ¬’l‚ðæ“ª‚ɐݒ肷‚éB

7.        o—ÍŽž‚̔ԍ†‚́A‚RŒ…‚̐®”‚Å•\‚·B

 

ŽŸ‚ÌŽÀs—á‚ð‚݂āAƒvƒƒOƒ‰ƒ€‚́ ‚ð–„‚ß‚ÄŠ®¬‚¹‚æB

ƒŽÀs—၄

“ü—́@@@@@@@@@@o—Í

‚Pƒoƒ“@@‚R‚O@@@@@‚P”ԁ@@‚V‚O@‚R‚T“

‚Qƒoƒ“@@‚P‚O@@@@@‚Q”ԁ@@‚T‚O@‚Q‚T“

‚Rƒoƒ“@@‚S‚O@@@@@‚R”ԁ@@‚S‚O@‚Q‚O“

‚Sƒoƒ“@@‚V‚O@@@@@‚S”ԁ@@‚R‚O@‚P‚T“

‚Tƒoƒ“@@‚T‚O@@@@@‚T”ԁ@@‚P‚O@@‚T“

@Œv@‚Q‚O‚O@‚P‚O‚O“

 

ƒƒvƒƒOƒ‰ƒ€„

#include <stdio.h>

#define N_MAX 5

int d[N_MAX];

void main(void)

{

              int i,j,sum;

              for(i=0,sum=0;i < N_MAX;i++)

                            {

                            printf(g ƒA g, i+1);

                            scanf(g%dh, ƒC);

                            sum+=d[i];

                            }

              for(i=0;i < N_MAX-1;i++)

                 {

                 for(j=i+1;j < N_MAX;j++)

                            {

                            if(ƒE)

                            swap(&d[i],&d[j]);

                            }

                 }

              printf(gƒ\[ƒgŒã\nh);

              for(i=0;i < N_MAX;i++)

                {

                printf(gƒG”Ô = %d %2ld%\nh

                            ,ƒI,ƒJ,ƒL);

              }

              printf(g_________________________\nh);

              printf(gŒv%3d  100%\nh,sum);

}

void swap(int *a,int *b)  /* *a‚Í&d[i]‚Å“¾‚ç‚ꂽƒAƒhƒŒƒX‚ð•ÛŽ‚·‚éƒ|ƒCƒ“ƒ^*/

{

              int w;

              w = *a;

              *a = *b;

              *b = w;

}

&d[i]‚Íd[i]‚̃AƒhƒŒƒX‚ð•\‚µAint *a‚Ń|ƒCƒ“ƒ^‚Ì’è‹`‚ð‚µAa = & d[i]‚Ń|ƒCƒ“ƒ^a‚֕ϐ”d[i]‚̃AƒhƒŒƒX‚ð‘ã“ü‚·‚éBiƒ|ƒCƒ“ƒ^‚͕ϐ”‚̃AƒhƒŒƒX‚ðŠi”[‚·‚é•Ï”j

 

‰ð“š@ƒA‚É‚Í%3dƒoƒ“@ƒC‚É‚Í&d[i]@ƒE‚É‚Íd[i] < d[j]@ƒG‚É‚Í%3d@ƒI‚É‚Íi+1@ƒJ‚É‚Íd[i]@ƒL‚É‚Í(((long)1000*(long)d[i] + 5)/(long)sum)/10‚ª“ü‚éB

 

ŠÖ”‚̍ì‚è•û

‚±‚ê‚Ü‚ÅŠw‚ñ‚Å‚«‚½ƒL[ƒ{[ƒh‚©‚ç‚̃f[ƒ^‚Ì“ü—͂⏈—Œ‹‰Ê‚Ì•\Ž¦‚ÉŽg‚Á‚½scanf‚âprintf‚Ì–½—߂́AŽÀ‚͊֐”‚Æ‚¢‚í‚ê‚é‚à‚Ì‚Å‚ ‚éB‚ ‚é‚Ü‚Æ‚Ü‚Á‚½ˆ—‚ð‚·‚é‚½‚ß‚É‚¢‚­‚‚©‚Ì–½—ß‚ð‘g‚ݍ‡‚킹‚½¬‚³‚ȃvƒƒOƒ‰ƒ€‚ðŠÖ”‚Æ‚¢‚¤BCŒ¾Œê‚É‚Í•W€ŠÖ”‚Æ‚¢‚¤•Ö—˜‚È‘½‚­‚̊֐”‚ª—pˆÓ‚³‚ê‚Ä‚¢‚éB‚Ü‚½Aƒ†[ƒU‚ªˆ—‚µ‚½‚¢–Ú“I‚ɍ‡‚킹‚Ċ֐”‚ðì‚邱‚Æ‚à‚Å‚«‚éB‚±‚̊֐”‚ðƒ†[ƒUŠÖ”‚Æ‚¢‚¤B

‚±‚ê‚Ü‚Å‚É‚à‚·‚Å‚ÉswapŠÖ”‚ȂǍ쐬‚µŽg‚Á‚Ä‚«‚½‚ªA‚±‚±‚ł́A‘ÌŒn“I‚Ɋ֐”‚ɂ‚¢‚ďЉAŽ©•ª‚Å‚¢‚ë‚¢‚ë‚Ȋ֐”‚ðì¬‚·‚é•û–@‚ðŠw‚сA‚±‚ê‚ç‚̊֐”‚ð‘g‚ݍ‡‚킹‚Ä‘å‚«‚ȃvƒƒOƒ‰ƒ€‚ð‘g‚Þ•û–@‚ðŠw‚ԁB

 

ˆø”‚Ì‚È‚¢ŠÖ”

—á‘è‚WD‚P

ŠwZ–¼AŠÝ’n‚ð•\Ž¦‚·‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚悤B‚½‚¾‚µAŠwZ–¼AŠÝ’n‚ð•\Ž¦‚·‚é‚»‚ꂼ‚ê‚̊֐”‚ðì¬‚µ‚ÄŽg—p‚·‚éB

l‚¦•û

ŠwZ–¼‚ð•\Ž¦‚·‚éŠÖ”‚ðschoolAŠÝ’n‚ð•\Ž¦‚·‚éŠÖ”‚ðaddress‚Æ‚·‚éB‚±‚ê‚ç‚ðmainŠÖ”‚©‚çŒÄ‚яo‚µ‚ÄŽg—p‚·‚éƒvƒƒOƒ‰ƒ€‚ð‘‚¯‚΂悢B

#include <stdio.h>

 

void school(void); /* ƒvƒƒgƒ^ƒCƒvéŒ¾@*/

void address(void);

 

void main(void)

{

             school();

             address();

}

 

/* ŠÖ”school‚Ì’è‹`*/

void school(void)

{

             printf("L“‡H‹Æ‘åŠw\n");

}

 

/* ŠÖ”address‚Ì’è‹`*/

void address(void)

{

             printf("L“‡Žs²”Œ‹æŽO‘î2-1-1\n");

}

‰ðà@ŠwZ–¼‚ð•\Ž¦‚·‚éŠÖ”school‚́Aschool‚ªŒÄ‚΂ꂽ‚çŠwZ–¼‚ð•\Ž¦‚·‚ê‚΂悢B“¯—l‚Éaddress‚àZŠ‚ð•\Ž¦‚·‚ê‚΂悢B‚±‚ê‚ç‚̊֐”‚ðŒÄ‚яo‚·‚É‚ÍmainŠÖ”‚Åschool( )Aaddress( )‚Æ‚·‚ê‚΂悢B

‚±‚̃vƒƒOƒ‰ƒ€‚ðŽÀs‚·‚é‚ƁAmainŠÖ”‚©‚çŒÄ‚яo‚³‚ꂽŠÖ”scholl‚ɐ§Œä‚ªˆÚ‚èAŠwZ–¼‚ð•\Ž¦‚·‚éBŽŸ‚ɐ§Œä‚ÍmainŠÖ”‚ɈڂèA¡“x‚͊֐”address‚ðŒÄ‚яo‚µ‚ďZŠ‚ð•\Ž¦‚·‚éB

ŠÖ”school(void)‚̂悤‚É( )‚Ì’†‚Évoid‚Ə‘‚¢‚½ŠÖ”‚ðˆø”‚Ì‚È‚¢ŠÖ”‚Æ‚¢‚¤B

 

ã‚̃vƒƒOƒ‰ƒ€‚͊֐”‚ðŽg‚킸Aprintf‚¾‚¯‚Å‚à“¯‚¶Œ‹‰Ê‚𓾂邱‚Æ‚ª‚Å‚«‚éB‚ł́A‚È‚ºŠÖ”‚ðŽg‚Á‚½‚Ì‚©‚ðl‚¦‚Ă݂悤B—Ⴆ‚΁AŠwZ–¼AŠÝ’nˆÈŠO‚ÉŽ©•ª‚Ì–¼‘O‚âŠw¶”ԍ†‚È‚Ç‚ð•\Ž¦‚µ‚½‚¢‚Æ‚µ‚悤B‚à‚µƒvƒƒOƒ‰ƒ€‚ªŠÖ”‚ðŽg‚킸printf‚ŏ‘‚©‚ê‚Ä‚¢‚½‚Æ‚µ‚悤B‚·‚é‚ƁAŽ©•ª‚Ì–¼‘O‚âŠw¶”ԍ†‚ð•\Ž¦‚·‚邽‚߂ɂ́AmainŠÖ”‚Ì’†g‚ðC³‚·‚é•K—v‚ª‚ ‚èAƒGƒ‰[‚ª”­¶‚µ‚½‚Æ‚«‚ÉmainŠÖ”‚Ì’†‚ð‚·‚×‚Äƒ`ƒFƒbƒN‚µ‚È‚¯‚ê‚΂Ȃç‚È‚­‚È‚éB‚µ‚©‚µAã‚̃vƒƒOƒ‰ƒ€‚̂悤‚Ɋ֐”‚ð—p‚¢‚ď‘‚¢‚Ä‚¨‚¯‚΁A­‚È‚­‚Æ‚àŠwZ–¼‚ƏŠÝ’n‚ð•\‚·ŠÖ”‚ɂ̓Gƒ‰[‚ª‚È‚¢‚±‚Æ‚Í•ª‚©‚Á‚Ä‚¢‚é‚̂ŁAƒGƒ‰[‚ª”­¶‚µ‚½ê‡‚͒ljÁ‚µ‚½Ž©•ª‚Ì–¼‘O‚ÆŠw¶”ԍ†‚ð•\Ž¦‚·‚éŠÖ”‚¾‚¯ƒ`ƒFƒbƒN‚·‚ê‚΃Gƒ‰[C³‚ª‚Å‚«‚éB‚³‚ç‚ɁAƒvƒƒOƒ‰ƒ€‚ð“Ç‚ñ‚¾‚Æ‚«AmainŠÖ”‚¾‚¯‚ʼn½‚ð‚µ‚Ä‚¢‚é‚Ì‚©•ª‚©‚èA“Ç‚Ý‚â‚·‚¢ƒvƒƒOƒ‰ƒ€‚ðì¬‚·‚邱‚Æ‚ª‚Å‚«‚éB

 

ˆø”‚Ì‚ ‚éŠÖ”i’lŒÄ‚яo‚µ–@j

—á‘è‚WD‚Q@ƒf[ƒ^‚ð“ǂݍž‚ñ‚Řa‚ƍ·‚ð‹‚ß‚é

mainŠÖ”‚©‚çŽÀ”ƒf[ƒ^a,b‚ðŠÖ”sum‚Ɗ֐”diff‚É“n‚µ‚āA‚»‚̘a‚ƍ·‚ðŒvŽZ‚µ‚Ä•\Ž¦‚·‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚悤B

l‚¦•û

‚PD‚Q‚‚̒lx,y‚̘a‚ðŒvŽZ‚·‚éŠÖ”‚ðsumA·‚ðŒvŽZ‚·‚éŠÖ”‚ðdiff‚Æ‚·‚é‚ƁAŠÖ”sum‚Ædiff‚ÍŽŸ‚̂悤‚É‚È‚éB

float sum(float x, float y)

{

             float s;

             s = x+y;

             return (s);

}

float diff(float x, float y)

{

             float d;

             d = x-y;

             return (d);

}

‚QDmainŠÖ”‚©‚ç“ǂݍž‚ñ‚¾a,b‚Ì’l‚ðŠÖ”sum‚É“n‚·B“¯—l‚Ɋ֐”diff‚É“n‚·B

‚RDŒvŽZŒ‹‰Ê‚Íreturn•¶‚ðŽg‚Á‚ÄmainŠÖ”‚É–ß‚·B‚±‚Ì–ß‚³‚ê‚é’l‚ð–ß‚è’l‚Æ‚¢‚¤B‚±‚Ì–ß‚è’l‚ÍŽÀ”‚Ȃ̂ŁAŠÖ”‚Ì‘O‚Éfloat‚ª‚‚¢‚Ä‚¢‚éB‚ł̓vƒƒOƒ‰ƒ€‚ð‘‚¢‚Ă݂悤B

 

‰ð“š

#include <stdio.h>

 

float sum(float, float); /* ƒvƒƒgƒ^ƒCƒvéŒ¾@*/

float diff(float, float);

 

void main(void)

{

             float a,b;

             printf("‚Q‚‚̐”Žš‚ð“ü—Í‚µ‚Ä‚­‚¾‚³‚¢\n");

             scanf("%f%f",&a,&b);

             printf("“ü—Í‚µ‚½‚Q‚‚̐”%f‚Æ%f‚̘a‚Í%f‚Å‚·\n",a,b,sum(a,b));

             printf("“ü—Í‚µ‚½‚Q‚‚̐”%f‚Æ%f‚̍·‚Í%f‚Å‚·\n",a,b,diff(a,b));

}

 

/* ŠÖ”sum‚Ì’è‹`*/

float sum(float x,float y)

{

             float s;

             s = x+y;

             return (s);

}

 

/* ŠÖ”diff‚Ì’è‹`*/

float diff(float x,float y)

{

             float d;

             d = x-y;

             return (d);

}

ŽÀˆø”‚Ɖ¼ˆø”

ŠÖ”sum(a,b)‚ðŒÄ‚яo‚·‚Æ‚«‚ÉŽg—p‚·‚é( )‚Ì’†‚Ìa,b‚ðŽÀˆø”‚Æ‚¢‚¤B‚Ü‚½AŒÄ‚яo‚³‚ê‚éŠÖ”sum(float x,float y)‚Ì’†‚Ìx,y‚ð‰¼ˆø”‚Æ‚¢‚¤B‰¼ˆø”x,y‚É‚ÍŽÀˆø”‚Ì’la,b‚ª“n‚³‚ê‚ÄŒvŽZ‚ÉŽg—p‚³‚êA‚»‚ÌŒ‹‰Ê‚ðreturn•¶‚ÅmainŠÖ”‚É–ß‚·B‚±‚Ì‚Æ‚«AŽÀˆø”‚Ɖ¼ˆø”‚ÌŒ^‚Í“¯‚¶‚Å‚È‚¯‚ê‚΂Ȃç‚È‚¢B‚±‚̂悤‚ÉŽÀˆø”‚Ì’l‚ð‰¼ˆø”‚É“n‚·•û–@‚ð’lŒÄ‚яo‚µ–@icall by valuej‚Æ‚¢‚¤B‚±‚Ì•û–@‚ł͉¼ˆø”‚Ì’l‚ðŽÀˆø”‚É“n‚·‚±‚Æ‚Í‚Å‚«‚È‚¢‚µA–ß‚¹‚é’l‚Í‚P‚‚ł ‚éB‚ł́A‰¼ˆø”‚ðŽÀˆø”‚É“n‚·‚É‚Í‚Ç‚¤‚·‚ê‚΂悢‚Ì‚¾‚낤‚©B‚»‚Ì“š‚¦‚́AŽQÆ‚É‚æ‚éŒÄ‚яo‚µiƒAƒhƒŒƒX“n‚µj‚ðs‚¤‚±‚Æ‚Å‚ ‚éB

 

”z—ñ‚̈ø“n‚µ

—á‘è‚WD3 ƒf[ƒ^‚ð”z—ñ‚ɓǂݍž‚ñ‚Å•½‹Ï‚ð‹‚ß‚é

”z—ña[ ]‚ÉnŒÂ‚̃f[ƒ^‚ð“ǂݍž‚݁Aƒf[ƒ^‚Ì•½‹Ï‚ð‹‚ß‚Ä•\Ž¦‚·‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚悤B‚½‚¾‚µAƒf[ƒ^‚Ì•½‹Ï‚͊֐”ave_data‚Å‹‚ß‚é‚à‚Ì‚Æ‚·‚éB‚Ü‚½Aƒf[ƒ^‚̌”n‚à“ü—Í‚·‚é‚à‚Ì‚Æ‚·‚éB

 

l‚¦•û

mainŠÖ”‚Å”z—ña‚Ƀf[ƒ^‚ð“ü—Í‚µA‚»‚̃f[ƒ^‚𕽋ϒl‚ð‹‚ß‚éŠÖ”ave_data‚É“n‚·B”z—ñ‚ƃ|ƒCƒ“ƒ^‚Æ‚ÍŒZ’í‚̂悤‚È‚à‚Ì‚Å‚ ‚邱‚Æ‚ð‚VÍ‚ÅŠw‚ñ‚¾B‚‚܂èA”z—ña‚ðŠÖ”ave_data‚É“n‚·‚É‚Í”z—ña‚̃AƒhƒŒƒX‚ð“n‚µ‚Ä‚â‚ê‚΂悢B”z—ña‚̃AƒhƒŒƒX‚Í”z—ñ–¼a‚Ü‚½‚͐擪ƒAƒhƒŒƒX&a[0]‚Å‚ ‚éB‚‚܂èAmainŠÖ”‚Ì’†‚Å

              ave = ave_data(a,n);

‚Ə‘‚«AŠÖ”ave_data‚ð

float ave_data(float x[ ],int n)

{

              float s=0,

              int i;

              for (i = 0;i < n;i++)

              {

                            s = s + x[i];

              }

              return (s/n);

}

‚Æ‚·‚ê‚΁AmainŠÖ”‚Ì’†‚Åave_data‚ªŒÄ‚΂ꂽ‚Æ‚«Aave_data‚Í”z—ña‚̃AƒhƒŒƒX‚Ɠǂݍž‚ñ‚¾ƒf[ƒ^‚̐”n‚ð‰¼ˆø”x[ ]‚Æn‚É“n‚·B‚»‚ÌŒãAŠÖ”ave_data‚Í•½‹Ï‚ðŒvŽZ‚µA‚»‚Ì’l‚ðmainŠÖ”‚É–ß‚·B‚ł́AƒvƒƒOƒ‰ƒ€‚ð‘‚¢‚Ă݂悤B

 

‰ð“š

#include <stdio.h>

 

float ave_data(float * ,int );

#define MAX 10

void main(void)

{

              int i,n;

              float ave,a[MAX];

              printf("ƒf[ƒ^‚̌”‚ð“ü—Í‚µ‚Ä‚­‚¾‚³‚¢\n");

              scanf("%d",&n);

 

              for(i=0;i<n;i++)

              {

                           printf("a[%d] =",i);

                           scanf("%f",&a[i]);

             }

             ave = ave_data(a,n);

             printf("%f\n",ave);

}

 

float ave_data(float x[],int n)

{

             float s=0;

             int i;

 

             for (i=0;i<n;i++)

             {

                           s = s+x[i];

             }

             return s/n;

}

 

ˆø”‚Ì‚ ‚éŠÖ”iŽQÆ‚É‚æ‚éŒÄ‚яo‚µj

—á‘è‚WD4@‚Q‚‚̐”a,b ‚ð“ǂݍž‚݁AmainŠÖ”‚©‚ça,b‚ðƒ†[ƒUŠÖ”bin_op‚É“n‚µ‚āA˜aA·‚ðŒvŽZ‚µA‚»‚ÌŒ‹‰Ê‚ðmain‚É–ß‚µ‚Ä•\Ž¦‚·‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚悤B

 

l‚¦•û@

—á‘è‚WD‚Q‚Ƃ̈Ⴂ‚Í‚P‚‚̊֐”‚Řa‚ƍ·‚ðŒvŽZ‚³‚¹‚»‚ÌŒ‹‰Ê‚ðmain‚É–ß‚·‚±‚Æ‚Å‚ ‚éB‚‚܂èAƒ†[ƒUŠÖ”bin_op‚͘aA·‚ðŒvŽZ‚µA‚»‚ÌŒ‹‰Ê‚ðmain‚É–ß‚³‚È‚¯‚ê‚΂Ȃç‚È‚¢B’lŒÄ‚яo‚µ–@‚ł́Areturn•¶‚ðŽg‚Á‚Ä‚P‚‚̒l‚µ‚©–ß‚·‚±‚Æ‚ª‚Å‚«‚È‚¢B‚»‚±‚ŁAmainŠÖ”‚ÌŽÀˆø”‚́A•Ï”‚̃AƒhƒŒƒX‚Æ‚µAƒ†[ƒUŠÖ”bin_op‚̉¼ˆø”‚Í“n‚³‚ꂽƒAƒhƒŒƒX‚ðŠi”[‚Å‚«‚é‚悤‚ɁAƒ|ƒCƒ“ƒ^‚ð‘Ήž‚³‚¹‚éB‚à‚¤­‚µÚ‚µ‚­à–¾‚µ‚悤B

MainŠÖ”“à‚Å

bin_op(a,b,&sum,&diff);

printf(g%f%fh,sum,diff);

‚Ə‘‚«Aƒ†[ƒUŠÖ”‚ð

void bin_op(float x, float y, float *add, float *subtract)

{

              *add = x + y;

              *subtract = x – y;

}

‚Ə‘‚­‚ƁAŽÀˆø”a,b,&sum,&diff‚ª‰¼ˆø”x,y,*add,*subtract‚É“n‚³‚ê‚éB‚»‚ÌŒãAx+y‚ÌŒ‹‰Ê‚ªƒ|ƒCƒ“ƒ^•Ï”*add‚Ì’†‚ÉŠi”[‚³‚ê‚Ä‚¢‚éƒAƒhƒŒƒX‚ð”Ô’n‚Æ‚·‚é•Ï”sum‚É‘ã“ü‚³‚ê‚éB‚æ‚Á‚āAprintf‚Åsum‚Ì’l‚ª•\Ž¦‚³‚ê‚邱‚Æ‚É‚È‚éBŠÖ”bin_op‚Í’l‚ð•Ô‚³‚È‚¢‚Ì‚Åvoid bin_op(float x, float y, float *add, float *subtract)‚Æ‚È‚éB‚ł́AƒvƒƒOƒ‰ƒ€‚ð‘‚¢‚Ă݂悤B

 

‰ð“š

#include <stdio.h>

 

void bin_op(float, float, float *, float *); /* ƒvƒƒgƒ^ƒCƒvéŒ¾@*/

 

void main(void)

{

             float a,b,sum,diff;

             printf("‚Q‚‚̐”Žš‚ð“ü—Í‚µ‚Ä‚­‚¾‚³‚¢\n");

             scanf("%f%f",&a,&b);

             bin_op(a,b,&sum,&diff);

             printf("“ü—Í‚µ‚½‚Q‚‚̐”%f‚Æ%f‚̘a‚Í%f‚Å‚·\n",a,b,sum);

             printf("“ü—Í‚µ‚½‚Q‚‚̐”%f‚Æ%f‚̍·‚Í%f‚Å‚·\n",a,b,diff);

            

}

 

/* ŠÖ”bin_op‚Ì’è‹`*/

void bin_op(float x,float y, float *add, float *subtract)

{

             *add = x + y ;

             *subtract = x - y;

}

 

•¶Žš—ñ‘€ìŠÖ”

CŒ¾Œê‚́AƒVƒXƒeƒ€Œ¾Œê‚Æ‚µ‚ж‚܂ꂽ‚̂ŁA•¶Žš—ñ‚𑀍삷‚é•W€ŠÖ”‚ª—pˆÓ‚³‚ê‚Ä‚¢‚éB

‰º‚É‹“‚°‚éŠÖ”‚ð—p‚¢‚é‚ɂ́Aƒwƒbƒ_ƒtƒ@ƒCƒ‹string.h‚ðƒCƒ“ƒNƒ‹[ƒh‚·‚é•K—v‚ª‚ ‚éB

ŠÖ”–¼

‹@”\

strlen@(string length‚Ì—ª)

•¶Žš—ñ‚Ì•¶Žš‚̌”‚ð‹‚ß‚é

strcmp@(string comparison‚Ì—ª)

‚ ‚镶Žš—ñ‚Æ‘¼‚Ì•¶Žš—ñ‚ð”äŠr‚·‚é

strcpy@(string copy‚Ì—ª)

‚ ‚镶Žš—ñ‚𑼂̕¶Žš—ñ‚É•¡ŽÊ‚·‚é

strcat@(string concatination‚Ì—ª)

‚ ‚镶Žš—ñ‚É‘¼‚Ì•¶Žš—ñ‚ð˜AŒ‹‚·‚é

 

ghello worldh‚Í•¶Žš—ñ‚æ‚΂êŠe—v‘f‚ª‚P•¶Žš‚PƒoƒCƒg‚Å‚ ‚é”z—ñ‚Æ‚µ‚Ä•Û‘¶‚³‚ê‚éB‚±‚Ì‚Æ‚«•¶Žš—ñ‚Ì“à•”•\Œ»‚ł͍Ōã‚Ƀiƒ‹•¶Žš(null character)f\0f‚ª’u‚©‚ê‚é‚̂ŁA•K—v‚È•¨—“I‹L‰¯—e—ʂ́AŽÀÛ‚ɏ‘‚©‚ꂽ•¶Žš‚̌”‚æ‚è‚à‚P‚‘½‚­‚È‚éBŠÖ”strlen(s)‚́f\0f‚ðœ‚¢‚½•¶Žš—ñˆø”s‚Ì’·‚³‚ð‹‚ß‚é‚à‚Ì‚Å‚ ‚éB

 

/* strlenŠÖ”: s‚Ì’·‚³‚ð•Ô‚·*/

int strlen(char s[ ])

{

             int i;

           

             i = 0;

             wile (s[i] != 0)

             ++I;

             return i;

}

 

—á‘è‚WD‚T strlenŠÖ”‚ð—p‚¢‚Ä•¶Žš”‚ð‹‚ß‚é

ghello worldh‚Ɓhƒnƒ[@ƒ[ƒ‹ƒhh‚Ì•¶Žš”‚ð‹‚ß‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚悤B

 

l‚¦•û

•¶Žš—ñstr1[ ]‚Ɂhhello worldh‚ð‘ã“ü‚µA•¶Žš—ñstr2[ ]‚É"ƒnƒ[@ƒ[ƒ‹ƒh"‚ð‘ã“ü‚·‚éBŽŸ‚ɁAŠÖ”strlen‚Ɉø”‚Æ‚µ‚Ä”z—ñ–¼str1‚Æstr2‚ð“n‚µAŒvŽZŒ‹‰Ê‚ð•\Ž¦‚·‚ê‚΂悢B‚ł́AƒvƒƒOƒ‰ƒ€‚ð‘‚¢‚Ä‚Ý‚éB

 

‰ð“š

/*•¶Žš—ñ‚Ì’·‚³‚ÌŒvŽZ*/

#include <stdio.h>

#include <string.h>

 

void main(void)

{

             int n1,n2;

             const char str1[ ] = "hello world";

             const char str2[ ] = "ƒnƒ[@ƒ[ƒ‹ƒh";

 

             n1 = strlen(str1);

             n2 = strlen(str2);

             printf("•¶Žš—ñ‚P‚Ì•¶Žš”=%d\n",n1);

             printf("•¶Žš—ñ‚Q‚Ì•¶Žš”=%d\n",n2);         

}

 

\‘¢‘Ì‚Æ‹¤—p‘Ì

 

Ž©•ªŽ©g‚Ì•\Œ»

Ž©•ªŽ©g‚ð•\Œ»‚·‚é‚ɂ́A–¼‘OA«•ÊA¶”NŒŽ“úAZŠA“d˜b”ԍ†A‚È‚Ç‚½‚­‚³‚ñ‚̏î•ñ‚ª•K—v‚Æ‚È‚éB‚±‚ê‚ç‚̏î•ñ‚ðŠî‚É–¼•ë‚ðì‚邱‚Æ‚ðl‚¦‚Ă݂悤B‚Ü‚¸A‚±‚ê‚ç‚̏î•ñ‚ð‚µ‚Ü‚¤” ‚ÌŒ^‚ɂ‚¢‚čl‚¦‚éB–¼‘O‚Í•¶Žš”z—ñ‚Å‚R‚Q•¶ŽšAZŠ‚à•¶Žš”z—ñ‚Å‚W‚O•¶ŽšA“d˜b”ԍ†‚à•¶Žš”z—ñ‚Å‚Q‚O•¶ŽšA¶”NŒŽ“ú‚Ílong intŒ^‚Å‚æ‚¢‚¾‚낤B«•Ê‚Í’j‚©—‚Ì‚Ç‚¿‚ç‚©‚È‚Ì‚Å—ñ‹“Œ^‚Æ‚·‚éB

              char                    name[32];

              long int               birth;

              char                    address[80];

              char                    tel[20];

              enum {Female,Male}         sex;

‚Æ‚È‚éB

‚±‚̏ꍇAname‚âaddress‚ª‚Ü‚Æ‚Ü‚Á‚Ä”z’u‚³‚ê‚Ä‚¢‚é‚̂ŁA‚±‚ê‚ç‚ÌŽ–•¿‚ÍŠÖ˜A‚µ‚Ä‚¢‚é‚P‚‚̎–•¿‚ð•\‚µ‚Ä‚¢‚é‚Ɛ„‘ª‚Å‚«‚éB‚»‚±‚ŁA‚±‚̂悤‚Ȍ݂¢‚ÉŠÖ˜A‚µ‚Ä‚¢‚éƒf[ƒ^‚ð‚P‚‚̌^‚Æ‚µ‚Đ錾‚·‚é‚Ì‚É—p‚¢‚é‚Ì‚ª\‘¢‘Ì(structure)‚Å‚ ‚éB

 

—á‘è‚XD‚P@\‘¢‘̐錾‚ð—p‚¢‚āAã‚ÌŽ–•¿‚ðéŒ¾‚µ‚Ă݂悤B

‰ð“š

struct person {

             char                    name[32];

             long int               birth;

             char                    address[80];

             char                    tel[20];

             enum {Female,Male}         sex;

}@;

‚±‚±‚ŁAstruct‚͍\‘¢‘̐錾‚ðŽ¦‚·ƒL[ƒ[ƒh‚ŁAŽŸ‚Ìperson‚Í‚±‚̍\‘¢‘Ì‚Ì–¼‘O‚ŁA\‘¢ƒ^ƒO‚ƌĂ΂ê‚Ä‚¢‚éBo‚Ɓp‚Ɉ͂܂ꂽ’†‚́A\‘¢‘̂̃ƒ“ƒo‚ƌĂ΂êAƒƒ“ƒo‚Ç‚¤‚µ‚Ì–¼‘O‚ªd•¡‚µ‚È‚¯‚ê‚΁A‚ǂ̂悤‚È–¼‘O‚Å‚àŽg‚¦‚éB

 

ŽŸ‚ɁA

struct person self_data;

‚Æ‚·‚é‚ƁA•Ï”self_data‚ÍpersonŒ^‚Æ’è‹`‚³‚ê‚éB‚Ü‚½A—ñ‹“Œ^‚Æ“¯‚¶‚悤‚É

struct person {

             char                    name[32];

             long int               birth;

             char                    address[80];

             char                    tel[20];

             enum {Female,Male}         sex;

}@self_data;

‚Æ‚·‚é‚ƁAéŒ¾‚ƕϐ”self_data‚Ì’è‹`‚𓯎ž‚ɍs‚¤‚±‚Æ‚ª‚Å‚«‚éB

 

\‘¢‘̃ƒ“ƒo‚ÌŽQÆ

\‘¢‘̃ƒ“ƒo‚ÌŽQÆ‚Í

\‘¢‘̕ϐ”–¼.ƒƒ“ƒo–¼

‚ōs‚¤B—Ⴆ‚΁A\‘¢‘̕ϐ”–¼self_data‚̃ƒ“ƒobirth‚ÌŽQÆ‚Í

              self_data.birth

‚Ə‘‚­B

 

—á‘è‚XD‚Q@19530315‚ðƒL[ƒ{[ƒh‚©‚ç“ü—Í‚µAself_data.birth‚É‘ã“ü‚·‚éB

‰ð“š

              struct person{

lon int birth;

              }self_data;

              scanf(g%ldh,&self_data.birth);

              printf(g%ldh,self_data.birth);;

‚Æ‚·‚ê‚΂悢B

 

—á‘è‚XD‚R@–¼‘OA’a¶“úAZŠA“d˜b”ԍ†A«•Ê‚ðŠÜ‚ñ‚¾ŒÂlî•ñ‚ðƒL[ƒ{[ƒh‚©‚ç“ü—Í‚µA•\Ž¦‚·‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚悤B

‰ð“š@—ñ‹“Œ^enum {Female,Male}sex;‚Éscanf‚œǂݍž‚ñ‚¾’l‚ð‘ã“ü‚·‚é‚ɂ́A‚O‚Ü‚½‚Í‚P‚ðƒL[ƒ{[ƒh‚©‚ç‘łB

o—Í‚·‚é‚É‚Í

printf(g%ch,(self_data.sex = = 0)? eFf:fMf;)‚ð—p‚¢‚éB‚±‚ê‚Í‚R€‰‰ŽZŽq‚ƌĂ΂ê‚é‚à‚̂ŁAŽŸ‚̂悤‚É—p‚¢‚éB

              Ž®‚PHŽ®‚QFŽ®‚R

‚ÌŒ`Ž®‚ð‚Æ‚èAŽ®‚P‚ª^‚È‚ç‚΁AŽ®‚Q‚Ì’l‚ªŽ®‚Ì’l‚Æ‚È‚èA‹U‚È‚ç‚ÎŽ®‚R‚ªŽ®‚Ì’l‚Æ‚È‚éB

             

#include <stdio.h>

#include <string.h>

 

void main(void)

{

             int choice=0;

 

             struct person {    

             char name[32];

             long int birth;     

             char address[80];

             char tel[20];

             enum {Female,Male}sex;

} self_data;

 

             do

             {

             choice=1;

             printf("–¼‘O> ’a¶“ú> ZŠ> “d˜b”ԍ†> «•Ê> \n");

             scanf("%s %ld %s %s %d",&self_data.name, &self_data.birth,

                           &self_data.address,&self_data.tel, &self_data.sex);

             printf("\n NAME         BIRTHDAY ADDRESS                       TEL         SEX\n");

             printf("%-10.10s %11.8ld %-30.30s %-10.10s %3c",self_data.name, self_data.birth, self_data.address, self_data.tel, (self_data.sex==0)? 'F':'M');

             printf("\nŽŸ‚̃f[ƒ^‚ð“ü‚ê‚Ü‚·‚©Hyes‚È‚ç‚OˆÈŠO");

             scanf("%d",&choice);

             } while (choice != 0);

}

 

\‘¢‘̂̃lƒXƒg

struct date birthdate;

‚ðã‚̍\‘¢‘Ì‚Ì’†‚É“ü‚ê‚ĐV‚½‚ȍ\‘¢‘Ì‚ðì‚邱‚Æ‚ª‚Å‚«‚éB

struct person {

             char                    name[32];

             struct  date  birthdate;

             char                    address[80];

             char                    tel[20];

             enum {Female,Male}         sex;

}self_data@;

‚±‚Ì‚Æ‚«AƒlƒXƒg‚É‚È‚Á‚Ä‚¢‚édate\‘¢‘̂̃ƒ“ƒobirthdate‚ÌŽQÆ‚ÍŽŸ‚̂悤‚É‚µ‚čs‚¤‚±‚Æ‚ª‚Å‚«‚éB

              self_data.date.month

ˆê”Ê“I‚ɁA

              \‘¢‘̕ϐ”–¼.\‘¢‘̕ϐ”ƒƒ“ƒo.\‘¢‘̕ϐ”ƒƒ“ƒoc.ƒƒ“ƒo–¼

‚сƒ“ƒo‚ÌŽQÆ‚ª‚Å‚«‚éB

 

‹¤—p‘́iunionj

‹¤—p‘̂́A\•¶‚âŽQÆ•û–@‚͍\‘¢‘Ì‚Æ“¯‚¶‚Å‚ ‚邪A\‘¢‘̂ƈá‚Á‚ÄŠeƒƒ“ƒo‚ª“¯‚¶ƒƒ‚ƒŠ‚ðŽg—p‚·‚éB‚‚܂èA‚P‚‚̔ ‚𕡐”‚Ì—p“r‚É‹¤—Lo—ˆ‚é‚悤‚É‚È‚Á‚Ä‚¢‚éBæ‚Ù‚Ç‚ÌpersonŒ^‚̍\‘¢‘Ì‚ð‹¤—p‘Ì‚Å’è‹`‚µ‚Ă݂悤B

              union person{

             char                    name[32];

             struct  date  birthdate;

             char                    address[80];

             char                    tel[20];

             enum {Female,Male}         sex;

}self_data@;

Å‰‚Ìunion‚́A‹¤—p‘Ì‚ðŽ¦‚·ƒL[ƒ[ƒh‚ŁAŽŸ‚Ìperson‚Í‚±‚Ì‹¤—p‘Ì‚Ì–¼‘O‚ŁA‹¤—p‘̃^ƒO‚ƌĂ΂ê‚Ä‚¢‚éBo‚Ɓp‚Ɉ͂܂ꂽ’†‚́A‹¤—p‘̂̃ƒ“ƒo‚ƌĂ΂êAƒƒ“ƒo‚Ç‚¤‚µ‚Ì–¼‘O‚ªd•¡‚µ‚È‚¯‚ê‚΁A‚ǂ̂悤‚È–¼‘O‚Å‚àŽg‚¦‚éB

 

\‘¢‘̂ւ̃|ƒCƒ“ƒ^

struct tag{

              int         x;

              double   y;

} test;

‚±‚̍\‘¢‘̂ւ̃|ƒCƒ“ƒ^‚ÍŽŸ‚̂悤‚É’è‹`‚·‚éB

              struct tag *p;

              p = &test;

 

‚±‚±‚ŁA\‘¢‘̃ƒ“ƒox‚̃AƒhƒŒƒX‚͂ǂ̂悤‚É‹‚ß‚é‚Ì‚¾‚낤‚©B

&test.x‚Ə‘‚¯‚΁Ax‚̃AƒhƒŒƒX‚ª‹‚Ü‚éB

‚Ü‚½A\‘¢‘̂ւ̃|ƒCƒ“ƒ^p‚ð—˜—p‚µ‚āA\‘¢‘Ì‚ÌŠeƒƒ“ƒo‚ðŠÔÚŽQÆ‚·‚邱‚Æ‚ào—ˆ‚éB

ŠÔÚŽQÆu–v‚ðŽv‚¢o‚·‚ƁAp = &test‚æ‚è*p‚͍\‘¢‘̕ϐ”test‚ðŽw‚·B‚æ‚Á‚ÄŠeƒƒ“ƒo‚Í(*p).x,(*p).y‚ÅŽQÆ‚Å‚«‚éB‚±‚±‚ŁAŠ‡ŒÊ‚Í•K—v‚Å‚ ‚éB‚È‚º‚È‚çA*‚Æ.‚Ì—Dæ‡ˆÊ‚Í.‚Ì•û‚ªã‚Å‚ ‚éB

‚µ‚©‚µA‚±‚̂悤‚ɏ‘‚­‚æ‚è‚àC‚ł͍\‘¢‘Ì‚ðƒ|ƒCƒ“ƒ^‚ŊԐڎQÆ‚Å‚«‚é‚悤‚Ɂu¨v‚Æ‚¢‚¤\‘¢‘̉‰ŽZŽq(structure operator)‚ª—pˆÓ‚³‚ê‚Ä‚¢‚éB‚±‚̉‰ŽZŽq‚ð—p‚¢‚é‚ƁA(*p).x‚Íp¨x‚Æ‹Lq‚Å‚«AŽ‹Šo“I‚É‚à•ª‚©‚è‚â‚·‚¢B‚½‚¾‚µA¨‚̓}ƒCƒiƒX‹L†‚Æ•s“™†u„v‚ð—p‚¢‚Ä•\‚·B

 

—á‘è‚XD‚S@\‘¢‘̂̃ƒ“ƒo‚ðƒ|ƒCƒ“ƒ^‚ð—p‚¢‚ÄŽQÆ‚·‚éB

#include <stdio.h>

 

void main(void)

{

              struct tag{

                            int  x;

                            double y;

              }@test;

              struct tag *p;

 

              p = &test;

              p ->x = 30;

              p ->y = 15.3;

 

              printf("x = %d y = %lf\n",p -> x, p->y);

}

 

“ú•t‚ÆŽžŠÔ

“ú•t‚⎞ŠÔ‚ð’m‚é‚É‚Í<time.h>‚Ő錾‚³‚ê‚Ä‚¢‚étimeŠÖ”‚ÆlocaltimeŠÖ”‚ð—p‚¢‚éB

timeŠÖ”‚́AŒ»Ý‚̃JƒŒƒ“ƒ_ŽžŠÔ‚ð•Ô‚·ŠÖ”‚ÅŒ^time_t‚ÍlongŒ^‚ð<time.h>‚ÅtypedeféŒ¾‚µ‚Ä‚¢‚éB

localtimeŠÖ”‚͍\‘¢‘Ìstruct@tm‚̃|ƒCƒ“ƒ^Œ^‚ð•Ô‚·ŠÖ”‚Å‚ ‚èA\‘¢‘̕ϐ”tm‚̃ƒ“ƒo‚ÍŽŸ‚̂悤‚É‚È‚Á‚Ä‚¢‚éB

 

int tm_sec;         /*second after the minute – [0,59] */

int tm_min;       /*minute after the hour – [0,59] */

int tm_hour;      /*hours after the midnight – [0,23] */

int tm_mday;     /*day of the month – [1,31] */

int tm_mon;       /*months since January – [0,11] */

int tm_year;      /*years since 1900 */

int tm_wday;     /*days since Sunday – [0,6] */

int tm_yday;      /*days since January 1 – [0,365] */

int tm_isdst;      /*daylight savings time flag */

 

—á‘è‚XD‚T@ƒvƒƒOƒ‰ƒ€‚ðŽÀs‚µ‚½ŽžŠÔ‚ª‰½Žž‚©‚ð•Ô‚·ƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚悤B

 

‰ð“š@“ú•t‚⎞ŠÔ‚ð’m‚é‚ɂ́A‚Ü‚¸timeŠÖ”‚ŃJƒŒƒ“ƒ_ŽžŠÔ‚ð‹‚ßA‚±‚ÌŽžŠÔ‚ðlocaltimeŠÖ”‚œǂݍž‚ݍ\‘¢‘̕ϐ”tp‚É‘ã“ü‚·‚éB‚±‚ÌŒãAŽžŠÔ‚ª’m‚肽‚¯‚ê‚Îtp->tm_hour‚ð•\Ž¦‚·‚ê‚΂悢B

 

#include <stdio.h>

#include <time.h>

 

void main(void)

{

             struct tm *tp;

             time_t   t;

 

             t = time(&t);@// ƒJƒŒƒ“ƒ_ŽžŠÔ‚ðt‚É‘ã“ü

             tp = localtime(&t);@//ƒJƒŒƒ“ƒ_ŽžŠÔ‚ðƒ[ƒJƒ‹ŽžŠÔ‚ɕύX

             printf("Œ»Ý‚ÌŽž‚Í%d‚Å‚·",tp->tm_hour);@// tp->tm_hour‚ÅŽžŠÔ‚ð\‘¢‘̂̃ƒ“ƒo‚ðŽQÆ

}

 

—á‘è‚XD‚U@‰½ŒŽ‰½“ú‰½Žž‰½•ª‰½•b‚ð•\Ž¦‚·‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚悤B

‰ð“š

#include <stdio.h>

#include <time.h>

 

void main(void)

{

             struct tm *tp;

             time_t   t;

 

             t = time(&t);

             tp = localtime(&t);

             printf("%dŒŽ%d“ú%dŽž%d•ª%d•b\n",tp->tm_mon,tp->tm_mday,tp->tm_hour,tp->tm_min,tp->tm_sec);

}

 

—á‘è‚XD‚V@ƒvƒƒOƒ‰ƒ€‚ðŽÀs‚µ‚½ŽžŠÔ‚ªŒß‘O‚©ŒßŒã‚©‚ð”»’f‚µ‚āAŒß‘O‚È‚çŒß‘O‚Å‚·AŒßŒã‚È‚çŒßŒã‚Å‚·‚Æ•Ô‚·ƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚悤B

 

l‚¦•û@‚Ü‚¸AŒß‘O‚©ŒßŒã‚©‚ð”»’f‚·‚éŠÖ”‚ðì‚éB‚±‚̊֐”‚ðapre_midi‚Æ‚¢‚¤–¼‘O‚É‚·‚éB

 

apre_midi‚ÍŽŸ‚̂悤‚É‚È‚éB

 

int apre_mid(void)

{

             struct tm *tp;

             time_t   t;

 

             if( (t = time(&t)) == -1)

             {

                           perror(gtime function error \nh);

                           exit(1);

             }

             tp = localtime(&t);

             return(tp -> tm_hour < 12);

}

 

‰ð“š

#include <stdio.h>

#include <time.h>

#include <stdlib.h>

 

int apre_mid(void);

void main(void)

{

             if(apre_mid())

             {

                           printf("Œß‘O‚Å‚·\n");

             }

             else

             {

                           printf("ŒßŒã‚Å‚·\n");

             }

}

int apre_mid(void)

{

             struct tm *tp;

             time_t   t;

 

             if( (t = time(&t)) == -1)

             {

                           perror("time function error \n");

                           exit(1);

             }

             tp = localtime(&t);

             return(tp -> tm_hour < 12);

}

 

ƒtƒ@ƒCƒ‹‚ÌŠT”O

‚±‚ê‚܂Ńf[ƒ^‚Ì“ü—͂̓L[ƒ{[ƒh‚©‚çs‚Á‚Ä‚«‚½B‚µ‚©‚µA“ü—̓f[ƒ^‚ª‘å—Ê‚É‚È‚é‚ƁA‚»‚̍ì‹Æ‚Í‘å•Ï‚È‚à‚Ì‚Æ‚È‚éB‚»‚±‚ŁAC‚Å‚Í‚ ‚ç‚©‚¶‚߃tƒ@ƒCƒ‹‚É“ü‚Á‚Ä‚¢‚éƒf[ƒ^‚Ì“üo—Í‚ª‚Å‚«‚é‚悤‚ɁAfopen,fscanf,fprintf,fclose‚Ȃǂ̊֐”‚ª—pˆÓ‚³‚ê‚Ä‚¢‚éB

 

ŠÖ”–¼

‹@”\

ˆê”ÊŒ`

fopen

x.c ‚ây.dat‚È‚Ç‚ÌŠO•”–¼‚ðŽó‚¯Žæ‚èAƒtƒ@ƒCƒ‹‚ð“ǂݏ‘‚«‚·‚é‚Ì‚É•K—v‚ȃ|ƒCƒ“ƒ^‚ð•Ô‚·B

FILE *fp;

 

fp = fopen(name,mode);

fscanf

fopen‚ÅŠJ‚¢‚½ƒtƒ@ƒCƒ‹‚̃f[ƒ^‚ð‚P•¶Žš—ñ‚¸‚“ǂݍž‚Þ

int   s;

 

fscanf(fp,h%dh,&s);

fprintf

fopen‚ÅŠJ‚¢‚½ƒtƒ@ƒCƒ‹‚̃f[ƒ^‚֏‘‚«ž‚Ý

FILE *fp;

int   s;

 

fprintf(fp, g%dh,s);

fclose

fopen‚ÅŠJ‚¢‚½ƒtƒ@ƒCƒ‹‚ð•Â‚¶‚éB

FILE *fp;

 

fclose(fp);

feof

ƒf[ƒ^‚ª‹ó‚©‚Ç‚¤‚©‚Ì”»’è‚ðs‚¤B‹ó‚È‚ç‚ΐ^‚ð•Ô‚·B

FILE *fp;

 

feof(fp);

fgets

‚PsŽæ‚荞‚Þ

fgets(fp,80,s)‚Å”z—ñs‚É‚PsŽæ‚荞‚Ü‚ê‚éB

fgets‚ð1‰ñŽÀs‚·‚é‚ƁAfpid‚ªŽŸ‚̍s‚̐擪‚ɈڂéB

 

char s[80];

FILE *fp;

 

fgets(fp,80,s)

fgetc

1•¶ŽšŽæ‚荞‚Þ

 

 

FILE@*fp;

 

fgtec(fp);

fseek

ƒtƒ@ƒCƒ‹ˆÊ’u‚̈ړ®

offset‚ɂ͐擪‚©‚ç‚Ì•¶Žš”‚ª“ü‚éB

origin‚É‚Í0,1,2‚ª“ü‚éB0‚ÅŽn‚߁A1‚ÅŒ»Ý’nA2‚ōŌã

FILE *fp;

 

fseek(fp,offset,origin);

fflush

ƒtƒ@ƒCƒ‹‚ð•Â‚¶‚¸‚ɏ‘‚«ž‚Ý

Fflush(fp);

ftell

ƒtƒ@ƒCƒ‹ƒ|ƒWƒVƒ‡ƒ“ƒCƒ“ƒfƒBƒP[ƒ^(fpid)‚̈ʒu‚𒲂ׂé

fgets‚ð1‰ñŽÀs‚·‚é‚ƁA2s–ڂ̐擪‚Éfpid‚ªˆÚ“®B

 

rewind

ƒtƒ@ƒCƒ‹‚̐擪‚ɈڂéB

 

fopen(name,mode)‚Ìname‚̓tƒ@ƒCƒ‹–¼‚ð•\‚µAmode‚É‚Ír,w,a,r+,w+,a+‚ª‚ ‚èAr‚Íread(“ǂݍž‚Ý)Aw‚Íwritei‘‚«ž‚݁jAa‚Íappendiƒtƒ@ƒCƒ‹‚̏I‚í‚è‚ɒljÁ‘‚«ž‚݁j‚ð•\‚·B‚Ü‚½Ar+‚̓tƒ@ƒCƒ‹‚̓ǂݏ‘‚«Aw+‚͍¡‚܂ł̃tƒ@ƒCƒ‹‚ð”jŠü‚µ‚ēǂݏ‘‚«Aa+‚̓tƒ@ƒCƒ‹‚̒ljÁE•ÏX‚ð•\‚·B

 

fopen,fscanf,fprintf,fclose‚ÌŽg‚¢•û

 

ƒtƒ@ƒCƒ‹‚©‚ç‚Ì“ü—Í

‚±‚ê‚ç‚̊֐”‚ðŽg‚Á‚Ädata.dat‚Æ‚¢‚¤–¼‘O‚̃tƒ@ƒCƒ‹‚Ì‘€ì‚ð‚µ‚Ä‚Ý‚æ‚¤B

 

—á‘è‚P‚OD‚P@“ü—̓tƒ@ƒCƒ‹‚©‚çƒf[ƒ^‚ð“ǂݍž‚Þ

ŽŸ‚̂悤‚ȃf[ƒ^‚ðŽ‚Á‚½ƒtƒ@ƒCƒ‹data.dat‚ªCF\temp‚É‚ ‚é‚Æ‚«Adata.dat‚©‚çƒf[ƒ^‚ð“ǂݍž‚݁A•½‹Ï‚Ƙa‚ð‹‚ß‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚悤B

ƒf[ƒ^@

150

164

153

174

189

185

168

156

152

174

173

169

 

l‚¦•û

fopen‚ðŽg‚Á‚Ädata.datƒtƒ@ƒCƒ‹‚ðŠJ‚«Afeof‚Ńf[ƒ^‚ª‹ó‚©ƒ`ƒFƒbƒN‚µAfscanf‚ð—p‚¢‚Ä‚P‚‚¸‚ƒf[ƒ^‚ðÅŒã‚܂œǂݍž‚ށBdata.dat‚ÍC:\temp‚É‚ ‚é‚̂Ń_ƒuƒ‹ƒNƒH[ƒg‚Ì’†‚ł́AhC:\\temp\\data.dath‚Ə‘‚­•K—v‚ª‚ ‚éB‚¢‚Á‚½‚ñƒtƒ@ƒCƒ‹‚ðŠJ‚¢‚Ä‚µ‚Ü‚¦‚΁Afscanf‚Íscanf‚Æ“¯‚¶Žg‚¢•û‚É‚È‚éB•½‹Ï‚ƍ‡Œv‚ðŒvŽZ‚µ‚½‚çAÅŒã‚Éfclose‚Ńtƒ@ƒCƒ‹‚ð•Â‚¶‚éB

 

‰ð“š

#include <stdio.h>

#include <stdlib.h>

 

void main(void)

{

             int value=1;

             int sum=0;

             int count=0;

             FILE *fpin;

 

             if( (fpin=fopen("C:\\temp\\data.dat","r")) == NULL)

             {

                           printf("ƒtƒ@ƒCƒ‹‚ªŒ©‚‚©‚è‚Ü‚¹‚ñB---data.dat\n");

                           exit(1);

             }

             while( !feof(fpin) )@// ÅŒã‚Ü‚Å

             {

                           fscanf(fpin,"%d",&value);

                           sum = sum + value;

                           count++;

             }

             if (count > 0)

             {

                           printf("‡Œv=%d •½‹Ï’l=%f",sum,(double)sum/count);

             }

             fclose(fpin);

}

“ǂݍž‚Ý‚Ì‚Æ‚«‚́A“ǂݍž‚Ý‚Å‚ ‚邱‚Æ‚ªŒã‚©‚ç‚·‚®‚É•ª‚©‚é‚悤‚ɁAfpin‚Æ‚µ‚Ä‚¨‚­‚Æ•Ö—˜‚Å‚ ‚éB

 

—á‘è‚P‚OD‚Q@ƒtƒ@ƒCƒ‹–¼‚ðŽw’肵‚½“ü—Í

ƒvƒƒOƒ‰ƒ€‚ðH•v‚·‚邱‚Æ‚É‚æ‚Á‚āAƒf[ƒ^ƒtƒ@ƒCƒ‹‚Ì–¼‘O‚ðƒL[ƒ{[ƒh‚©‚ç’¼Ú“ü—Í‚·‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚¹‚æB

 

‰ð“š@fopen‚ÅŽw’肵‚½ƒtƒ@ƒCƒ‹–¼‚Ì—v‘f‚́A•¶Žš”z—ñ‚Å‚àŽw’è‚Å‚«‚éB—Ⴆ‚΁A

              char  FileName[16]:

              printf(gƒtƒ@ƒCƒ‹–¼‚ð“ü—Í‚µ‚Ä‚­‚¾‚³‚¢h);

              scanf(g%sh,FileName);

‚Æ‚·‚ê‚΂悢B‚ł̓vƒƒOƒ‰ƒ€‚ð‘‚¢‚Ă݂悤B

 

#include <stdio.h>

#include <stdlib.h>

 

void main(void)

{

             int value=1;

             int sum=0;

             int count=0;

             char FileName[16];

             FILE *fpin;

 

             printf("ƒtƒ@ƒCƒ‹–¼‚ð“ü—Í‚µ‚Ä‚­‚¾‚³‚¢");

             scanf("%s",FileName);

 

             if( (fpin=fopen("data.dat","r")) == NULL)

             {

                           printf("ƒtƒ@ƒCƒ‹‚ªŒ©‚‚©‚è‚Ü‚¹‚ñB---data.dat\n");

                           exit(1);

             }

             while( !feof(fpin) )

             {

                           fscanf(fpin,"%d",&value);

                           sum = sum + value;

                           count++;

             }

             if (count > 0)

             {

                           printf("‡Œv=%d •½‹Ï’l=%f",sum,(double)sum/count);

             }

             fclose(fpin);

}

 

‚±‚±‚ł́A‚P‚‚̃f[ƒ^ƒtƒ@ƒCƒ‹data.dat‚©‚çƒf[ƒ^‚ð“ǂݍž‚Þ‚±‚Æ‚ðs‚Á‚½‚ªA•¡”ŒÂ‚̃f[ƒ^ƒtƒ@ƒCƒ‹‚ð“ǂݍž‚Þ‚É‚Í

              FILE *fpin1, *fpin2, *fpin3;

‚Ɛ錾‚µA‚»‚ꂼ‚ê‚̃tƒ@ƒCƒ‹‚ðfopen‚ÅŠJ‚¯‚΂悢B

 

ƒtƒ@ƒCƒ‹‚ւ̏‘‚«ž‚Ý

ƒtƒ@ƒCƒ‹‚Öƒf[ƒ^‚ðo—Í‚·‚é‚ɂ́A

‚PD‚Ü‚¸out.dat‚Æ‚¢‚¤–¼‘O‚̃tƒ@ƒCƒ‹‚ðì¬‚·‚éB‘‚«‚±‚Ý‚Ì‚Æ‚«‚Ífpout‚Æ‚µ‚Ä‚¨‚­B

              FILE *fpout;

              fpout = fopen(gout.dath,hwh);

‚±‚Ì‚Æ‚«Afopen‚Ì‘æ‚Qˆø”mode‚͏‘‚«ž‚݉”\‚Æ‚·‚邽‚߁h‚—h‚É‚È‚éB‚½‚¾‚µAhwh‚ðŽw’肵‚Äfopen‚ðs‚Á‚½ê‡Aout.dat‚ª‘¶Ý‚·‚é‚Æout.dat‚̃f[ƒ^“à—e‚ÍŽ¸‚í‚ê‚é‚Ì‚Å’ˆÓ‚·‚邱‚ƁB‚‚܂èAhwh‚͏㏑‚«‚ðˆÓ–¡‚·‚éB

‚QDfprintfŠÖ”‚ð—p‚¢‚ătƒ@ƒCƒ‹‚Ƀf[ƒ^‚ðo—Í‚·‚éB

              fprintf(fpout,h%d\nh,value);

‚RDÅŒã‚Ƀtƒ@ƒCƒ‹‚ð•Â‚¶‚éB

              fclose(fpout);

 

—á‘è‚P‚OD‚R@ŽŸ‚̃f[ƒ^‚ðout.dat‚Æ‚¢‚¤ƒtƒ@ƒCƒ‹‚ðì¬‚µA‘‚«ž‚ÞƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚悤B

ƒf[ƒ^@

150

164

153

174

189

185

168

156

152

174

173

169

 

l‚¦•û

‚PD‚Ü‚¸out.dat‚Æ‚¢‚¤ƒtƒ@ƒCƒ‹‚ðì¬B

‚QDƒL[ƒ{[ƒh‚©‚ç‚̃f[ƒ^‚ðscanf‚œǂݍž‚݁Afprintf‚Åout.dat‚ɏ‘‚«ž‚Þ

‰ð“š

#include <stdio.h>

#include <stdlib.h>

 

void main(void)

{

             int value=1;

             FILE *fpout;

 

             if( (fpout = fopen("out.dat","w")) == NULL)

             {

                           fclose(fpout);

                           printf("ƒtƒ@ƒCƒ‹‚ªì¬‚Å‚«‚Ü‚¹‚ñB---out.dat\n");

                           exit(1);

             }

            

             while( value != 0 )

             {

                           printf("ƒf[ƒ^‚ð“ü—Í‚µ‚Ä‚­‚¾‚³‚¢BI—¹‚·‚é‚É‚Í‚O‚ð“ü—Í\n");

                           scanf("%d",&value);

                           fprintf(fpout,"%d\n",value);

             }

             fclose(fpout);

}

 

ƒtƒ@ƒCƒ‹‚ւ̒ljÁ‘‚«ž‚Ý

‚±‚±‚ł́A‚·‚łɍ쐬‚µ‚Ä‚ ‚éƒtƒ@ƒCƒ‹‚ɐV‚µ‚¢ƒf[ƒ^‚ð’ljÁ‚·‚é•û–@‚ðl‚¦‚éBfopen‚Ìmode‚ða‚É‚·‚邃ljÁ‘‚«ž‚Ý‚ª‚Å‚«‚é‚悤‚É‚È‚éB‚±‚Ì‚Æ‚«V‚µ‚­’ljÁ‚µ‚½ƒf[ƒ^‚ÍŒ³‚̃tƒ@ƒCƒ‹‚̉º‚ɒljÁ‚³‚ê‚Ü‚·B

 

—á‘è‚P‚OD‚S@—á‘è‚P‚OD‚R‚ō쐬‚µ‚½out.dat‚ÉŽŸ‚̃f[ƒ^‚ð’ljÁ‚µ‚Ă݂悤B

ƒf[ƒ^

‚P‚U‚O

‚P‚V‚O

‚P‚W‚O

‚P‚V‚T

 

‰ð“š

#include <stdio.h>

#include <stdlib.h>

 

void main(void)

{

             int value=1;

             FILE *fpout;

 

             if( (fpout = fopen("out.dat","a")) == NULL)

             {

                           fclose(fpout);

                           printf("ƒtƒ@ƒCƒ‹‚ªì¬‚Å‚«‚Ü‚¹‚ñB---out.dat\n");

                           exit(1);

             }

            

             while(value != 0)

             {

                           printf("ƒf[ƒ^‚ð“ü—Í‚µ‚Ä‚­‚¾‚³‚¢BI—¹‚·‚é‚É‚Í‚O‚ð“ü—Í\n");

                           scanf("%d",&value);

                           fprintf(fpout,"%d\n",value);

             }

             fclose(fpout);

}

 

ƒtƒ@ƒCƒ‹‚Ì•¶Žš•ÏX(fseek‚ÌŽg‚¢‚©‚½)

fseek(fp,offset,origin)‚Åorigin‚ɑ΂µ‚ătƒ@ƒCƒ‹‚Ìoffset‚̈ʒu‚Ɉړ®Borigin‚Í0,1,2‚ª“ü‚éA0‚͐擪A1‚ÍŒ»Ý’nA3‚̓tƒ@ƒCƒ‹‚̍ŌãBoffset‚É‚Í0L,1L,2L,c‚ª“ü‚éB0L‚Å‚P•¶Žš–ځA2L‚Å‚Q•¶Žš–ڂɈړ®‚·‚éB

fseek(fp,0L,0)‚ÅŠJŽns‚Ì‚P•¶Žš–ڂɈړ®‚·‚éB

 

ŽŸ‚̂悤‚È•¶Žš—ñ‚ª‚ ‚éƒf[ƒ^ƒtƒ@ƒCƒ‹‚ðtest.dat‚Æ–¼‘O‚ð•t‚¯‚Ä•Û‘¶‚µ‚Ä‚¨‚­B

D is defficalt.

 

‚PD•¶ŽšD‚ðC‚É•Ï‚¦‚éB

#include <stdio.h>

#include <stdlib.h>

 

void main(void)

{

             char c;

             char s[80];

             FILE *fpout;

 

             if( (fpout = fopen("test.dat","r+")) == NULL)

             {

                           fclose(fpout);

                           printf("ƒtƒ@ƒCƒ‹‚ªì¬‚Å‚«‚Ü‚¹‚ñB---test.dat\n");

                           exit(1);

             }

 

             fgets(s,80,fpout);

             fseek(fpout,0L,0);

             c = 'C';

             fprintf(fpout,"%c",c);

             fclose(fpout);

}

‚Å•¶ŽšD‚ÍC‚É’u‚«Š·‚¦‚ç‚ê‚éB

‚QDC is defficalt‚Ìe‚ði‚É•Ï‚¦‚éB

#include <stdio.h>

#include <stdlib.h>

 

void main(void)

{

              int i;

              int j;

              char c;

              char s[80];

              FILE *fpout;

 

              if( (fpout = fopen("test.dat","r+")) == NULL)

              {

                            fclose(fpout);

                            printf("ƒtƒ@ƒCƒ‹‚ªì¬‚Å‚«‚Ü‚¹‚ñB---test.dat\n");

                            exit(1);

              }

 

             fgets(s,80,fpout);

             for(i=0;i<80;i++)

             {

                           if(s[i] == 'e')

                           {

                           j = (long)i;

                           fseek(fpout,j,0);

                           c = 'i';

                           fprintf(fpout,"%c",c);

                           }

             }

             fclose(fpout);

}

‚RDC is difficalt‚̃Xƒyƒ‹ƒ~ƒX‚ðŒ©‚Â‚¯‚ďC³‚·‚éB

fseek‚Æfprintf‚̓yƒA‚Å—p‚¢‚éB‚‚܂èAfseek‚Æfprintf‚ÌŠÔ‚É‚Í‘¼‚Ì‘€ì‚ðs‚Á‚Ä‚Í‚¢‚¯‚È‚¢B‘¼‚Ì‘€ì‚ðs‚¤‚Æfseek‚Ìfp‚ª•Ï‚í‚Á‚Ä‚µ‚Ü‚¤B

 

#include <stdio.h>

#include <stdlib.h>

 

void main(void)

{

             int i;

             int j;

             char ch,ad;

             char s[80];

             FILE *fpout;

 

             if( (fpout = fopen("test.dat","r+")) == NULL)

             {

                           fclose(fpout);

                           printf("ƒtƒ@ƒCƒ‹‚ªì¬‚Å‚«‚Ü‚¹‚ñB---test.dat\n");

                           exit(1);

             }

 

             fgets(s,80,fpout);

             printf("%s",&s[0]);

             printf("C³‚µ‚½‚¢•¶Žš‚ƏC³—p‚Ì•¶Žš‚ð“ü—Í\n");

             scanf("%c %c",&ch,&ad);

 

             for(i=0;i<80;i++)

             {

                           if(s[i] == ch)

                           {

                           j = (long)i;

                           fseek(fpout,j,0);

                           fprintf(fpout,"%c",ad);

                           }

             }

             fclose(fpout);

}

 

ƒtƒ@ƒCƒ‹‚̒ljÁ•ÏX(•¶Žš—ñ)

•¶Žš—ñ‚ð“ǂݍž‚Þ‚É‚Ífgets(s,80,fpout);‚ð—p‚¢‚éB

ŽŸ‚Ì•¶Žš—ñ‚ðŠÜ‚ñ‚¾ƒf[ƒ^ƒtƒ@ƒCƒ‹test.dat‚ð—pˆÓ‚·‚éB‚±‚̃tƒ@ƒCƒ‹‚ðƒvƒƒ“ƒvƒg‚©‚çŠJ‚«A•¶Žš—ñ‚ð•\Ž¦‚µC³‚µ‚½‚¢•¶Žš—ñ‚ð“ü—Í‚·‚邱‚Æ‚É‚æ‚èAƒtƒ@ƒCƒ‹‚ª‘‚«’¼‚³‚ê‚éƒvƒƒOƒ‰ƒ€‚ðì¬‚µ‚悤B

They is stupid.

•¶Žš—ñ‚Ì’·‚³‚Ístrlen(s)‚ÅŒv‚éB

 

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

 

void main(void)

{

             int i;

             int j;

             int len,len1,len2;

             char ch[5],ad[5];

             char s[80];

             FILE *fpout;

 

             if( (fpout = fopen("test.dat","r+")) == NULL)

             {

                           fclose(fpout);

                           printf("ƒtƒ@ƒCƒ‹‚ªì¬‚Å‚«‚Ü‚¹‚ñB---test.dat\n");

                           exit(1);

             }

                           fgets(s,80,fpout);

 

                           printf("%s",&s[0]);

                           len=strlen(s);

                           printf("C³‚µ‚½‚¢•¶Žš—ñ‚ƏC³—p‚Ì•¶Žš—ñ‚ð“ü—Í\n");

                           scanf("%s %s",ch,ad);

                           len1=strlen(ch);

                           len2=strlen(ad);

 

                           for(i=0;i<80;i++)

                           {

                                         if(s[i] == ch[0])

                                         {

                                         j = (long)i;

                                         fseek(fpout,j,0);

                                         fgets(s,40,fpout);

                                         fseek(fpout,j+len2-len1,0);

                                         fprintf(fpout,"%s",s);

                                         fseek(fpout,j,0);

                                         fprintf(fpout,"%s",ad);

                                         break;

                                         }

                           }

             fclose(fpout);

}

 

ƒŠƒ_ƒCƒŒƒNƒVƒ‡ƒ“

C‚ɂ̓Šƒ_ƒCƒŒƒNƒVƒ‡ƒ“‚ƌĂ΂êA“üo—͂̐؂è‘Ö‚¦‚ðs‚¤‹@”\‚ª‚ ‚éB‚‚܂èAƒL[ƒ{[ƒh‚âƒfƒBƒXƒvƒŒƒC‚àƒtƒ@ƒCƒ‹‚ƍl‚¦‚é‚ƁAƒtƒ@ƒCƒ‹‚©‚ç“ǂݍž‚Þ‚±‚Æ‚àAƒtƒ@ƒCƒ‹‚ւ̏o—Í‚àƒL[ƒ{[ƒh‚©‚ç‚Ì“ü—Í‚âƒfƒBƒXƒvƒŒƒC‚ւ̏o—Í‚Æ“¯‚¶‚ƍl‚¦‚邱‚Æ‚ª‚Å‚«‚éB‚ł́AŽÀÛ‚ɃŠƒ_ƒCƒŒƒNƒVƒ‡ƒ“‚ðs‚Á‚Ä‚Ý‚éB

 

‚PD@ŽŸ‚̃vƒƒOƒ‰ƒ€‚ðread_data.c‚Æ‚¢‚¤ƒtƒ@ƒCƒ‹–¼‚ŃRƒ“ƒpƒCƒ‹‚µ‚悤B

#include <stdio.h>

 

void main(void)

{

             char  s[80];

            

             while(gets(s) !=NULL))

             {

             puts(s);

             }

}

 

‚QD@—á‘è‚P‚OD‚P‚Å—p‚¢‚½“ü—̓tƒ@ƒCƒ‹data.dat‚ðƒŠƒ_ƒCƒŒƒNƒVƒ‡ƒ“‚ð—p‚¢‚ēǂݍž‚ñ‚ł݂悤B

              read_data < data.dat

‚ƃvƒƒ“ƒvƒg‚ÅŽÀs‚·‚éB‚±‚ê‚́Adata.dat‚Æread_data.exe‚Í“¯‚¶ƒtƒHƒ‹ƒ_‚É‚ ‚邱‚Æ‚ð‘O’ñ‚É‚µ‚Ä‚¢‚éB‚à‚µdata.dat‚ª•Ê‚̏ꏊ‚É‚ ‚é‚Æ‚«‚́AƒpƒXipathj‚ª•K—v‚É‚È‚éBƒpƒX‚Æ‚Í–Ú“I’n‚Ü‚Å‚Ì“¹‡‚Ì‚±‚Æ‚Å‚ ‚éB

 

—Ⴆ‚΁Aread.dat‚ªCƒhƒ‰ƒCƒu‚̃tƒHƒ‹ƒ_My@Documents@‚̉º‚̃tƒHƒ‹ƒ_CEXE‚É‚ ‚èAread_data‚ªCƒhƒ‰ƒCƒu‚̃tƒHƒ‹ƒ_DAT‚É‚ ‚é‚Æ‚·‚éB‚±‚̏ꍇ‚ÍŽŸ‚̂悤‚É“ü—Í‚·‚ê‚΂悢B

              cd c:\mydocu~1\CEXE

              read_data < ..\data.dat

‚±‚ê‚Í‘Š‘΃pƒX‚ƌĂ΂ê‚é‚à‚Ì‚Å‚ ‚éB‚±‚Ì‘¼â‘΃pƒX‚ð—p‚¢‚é‚ÆŽŸ‚̂悤‚É‚È‚éB

              read_data < C:\DAT\data.dat

 

 

‚RD@—á‘è‚P‚OD‚R‚ōs‚Á‚½ƒtƒ@ƒCƒ‹‚ւ̏‘‚«ž‚Ý‚ðƒŠƒ_ƒCƒŒƒNƒVƒ‡ƒ“‚ð—p‚¢‚čs‚Á‚Ă݂悤B‘‚«ž‚Ý‚·‚éƒtƒ@ƒCƒ‹–¼‚Íout.txt‚Æ‚·‚éB

              read_data > out.txt

‚±‚ÌŒãAtype out.txt‚ƃvƒƒ“ƒvƒg‚Å“ü—Í‚·‚é‚Æout.txt‚Ì“à—e‚ªŒ©‚ê‚éBUNIX‚̏ꍇ‚Ícat out.txt‚Æ“ü—́B

 

‚SD@—á‘è‚P‚OD‚S‚ōs‚Á‚½ƒtƒ@ƒCƒ‹‚ւ̒ljÁ‘‚«ž‚Ý‚ðƒŠƒ_ƒCƒŒƒNƒVƒ‡ƒ“‚ð—p‚¢‚čs‚Á‚Ă݂悤B’ljÁ‘‚«ž‚Ý‚·‚éƒtƒ@ƒCƒ‹–¼‚Íout.txt‚Æ‚·‚éB

              read_data >> out.txt

‚±‚ÌŒãAtype out.txt‚ƃvƒƒ“ƒvƒg‚Å“ü—Í‚·‚é‚Æout.txt‚Ì“à—e‚ªŒ©‚ê‚éBUNIX‚̏ꍇ‚Ícat out.txt‚Æ“ü—́B

 

‚TD@“ǂݍž‚݂Ə‘‚«ž‚Ý‚ðƒŠƒ_ƒCƒŒƒNƒVƒ‡ƒ“‚ōs‚Á‚Ă݂悤B

              read_data < data.dat > data.out

‚±‚Ì‘€ì‚ðs‚¤‚ƁA‚Ü‚¸data.dat‚Ì“à—e‚ª‚æ‚«ž‚Ü‚êAŽŸ‚Édata.out‚ɏ‘‚«ž‚Ü‚ê‚éB

 

—ûK–â‘è‚P‚OD‚P

ŽŸ‚̃vƒƒOƒ‰ƒ€‚Ìà–¾‚¨‚æ‚уvƒƒOƒ‰ƒ€‚ð“Ç‚ñ‚ŁAÝ–â‚É“š‚¦‚æB

uƒvƒƒOƒ‰ƒ€‚Ìà–¾v

ƒ\ƒtƒgƒEƒFƒAŠJ”­‚̃eƒXƒgH’ö‚É‚¨‚¯‚éƒoƒOŽû‘©ó‹µ‚ð•]‰¿‚·‚邽‚߂̐M—Š“x¬’·‹Èü‚ðˆóü‚·‚éƒvƒƒOƒ‰ƒ€‚Å‚ ‚éBM—Š“x¬’·‹Èü‚́AƒeƒXƒg€–ڂ̏Á‰»ó‹µ‚ƃoƒO‚Ì”­¶ó‹µ‚Æ‚ÌŠÖŒW‚ðƒOƒ‰ƒt‚É‚µ‚½‚à‚Ì‚Å‚ ‚éB

i‚Pj@ƒeƒXƒg’S“–ŽÒ‚ª“úX‹L˜^‚µ‚Ä‚¢‚éƒeƒXƒg€–ڂ̏Á‰»€–ڐ”i‚»‚Ì“ú‚ɏI—¹‚µ‚½ƒeƒXƒg‚̍€–ڐ”j‚Æ“EoƒoƒO”iI—¹‚µ‚½€–Ú‚É‚¨‚¢‚Ä“Eo‚µ‚½ƒoƒO”j‚̈ꗗ‚ªA‰º‚̃oƒO‹L˜^•\‚Å‚ ‚éB

ƒoƒO‹L˜^•\

“ú•t

’S“–

Á‰»€–ڐ”

“EoƒoƒO”

19960802

A

2

40

19960803

B

1

20

19960804

A

3

20

19960805

B

4

10

 

 

 

 

19960823

A

10

5

19960823

C

5

0

19960825

A

8

1

19960827

C

12

1

i‚Qj       ƒoƒO‹L˜^•\‚́A‰º‚̐}‚̃ŒƒR[ƒh—lŽ®‚Åbugrec.txt‚Æ‚¢‚¤ƒtƒ@ƒCƒ‹‚ÉŠi”[‚³‚ê‚Ä‚¢‚éB

‚W‚¯‚½

‚P‚¯‚½

‚P‚¯‚½

‚P‚¯‚½

‚Q‚¯‚½

‚P‚¯‚½

‚Q‚¯‚½

‚P‚¯‚½

“ú•t

¢

’S“–

¢

Á‰»€–ڐ”

¢

“EoƒoƒO”

\n

¢     F‹ó”’•¶Žš

 

‚PD              “ú•t‚́A”NŒŽ“ú‚ð‚WŒ…‚Ì‚P‚Oi”ŽšiYYYYMMDDj‚Å•\Œ»‚µ‚Ä‚¨‚èAæ“ª‚Ì‚SŒ…‚ª¼—ï”N‚ðAŽŸ‚Ì‚QŒ…‚ªŒŽ‚ðAÅŒã‚Ì‚QŒ…‚ª“ú‚ð•\‚µ‚Ä‚¢‚éB

‚QD              ’S“–‚́AƒeƒXƒg’S“–‚ð‚PŒ…‚̉pŽš‚ɃR[ƒh‰»‚µ‚½‚à‚Ì‚Å‚ ‚éB

‚RD              Á‰»€–ڐ”‚¨‚æ‚Ñ“EoƒoƒO”‚́A‚QŒ…‚Ì‚P‚Oi”Žš‚Å‚ ‚éB

‚SD              Še€–ڂ́A‚PŒÂ‚Ì‹ó”’•¶Žš‚Å‹æØ‚ç‚ê‚Ä‚¨‚èAƒŒƒR[ƒh‚̏I’[‚͉üs•¶Žšh\nh‚Å‚ ‚éB

‚TD              ƒŒƒR[ƒh‚̓eƒXƒg’S“–ŽÒ‚²‚Æ‚É‚P“ú‚̃eƒXƒgŒ‹‰Ê‚ð‹L˜^‚µ‚½‚à‚Ì‚Å‚ ‚èA“¯ˆê“ú•t‚ŃeƒXƒg’S“–ŽÒ‚ªˆÙ‚Ȃ郌ƒR[ƒh‚ª‚QŒˆÈã‘¶Ý‚·‚邱‚Æ‚à‚ ‚éB

‚UD              ƒŒƒR[ƒh‚Í“ú•t‚̏¸‡‚ɐ®—ñ‚³‚ê‚Ä‚¢‚éB

‚VD              ƒtƒ@ƒCƒ‹bugrec.txt‚É‹L˜^‚³‚ê‚Ä‚¢‚éƒeƒXƒgì‹Æ“ú‚̐”‚Í‚U‚O“úˆÈ“à‚Å‚ ‚éB

i‚Rj@‚±‚̃vƒƒOƒ‰ƒ€‚ł́Aƒtƒ@ƒCƒ‹bugrec.txt‚ð“ü—Í‚µA‚P“ú‚ ‚½‚è‚̏Á‰»€–ڐ”‚¨‚æ‚Ñ“Eoƒo‚®”‚ðWŒv‚·‚éB‚³‚ç‚ɁA‚»‚Ì“ú‚܂ł̗ݐϐ”‚ðŒvŽZ‚µ‚āA—ݐϏÁ‰»€–ڐ”‚ƗݐϓEoƒoƒO”‚ÌŠÖŒW‚ð‚à‚Ƃ߁AÜ‚êüƒOƒ‰ƒto—͊֐”prtgraph‚ð—p‚¢‚ĐM—Š“x¬’·‹Èü‚ðˆóü‚·‚éB

i‚Sj@ŠÖ”prtgraph‚ÌŽd—l‚́AŽŸ‚Ì‚Æ‚¨‚è‚Å‚ ‚éB

@@@u‹@”\v@‘æ‚Pˆø”‚ÅŽw’肳‚ꂽŒÂ”‚Ì“_iÀ•W‚Í‘æ‚Qˆø”‚Ì”z—ñ“à‚ÉŠi”[j‚ðÜ‚êü‚ł‚Ȃ¢‚ňóü‚·‚éB

@@@u‘Ž®v@

                            typedef struct{int x;int y;} ZAHYO;

                            void prtgraph(int dcnt,ZAHYO +tbl, char *title);

 

@@@uˆø”v@\‘¢‘ÌZAHYO‚̃ƒ“ƒoxFˆóü‚·‚é“_‚ÌXÀ•W

                            \‘¢‘ÌZAHYO‚̃ƒ“ƒoyFˆóü‚·‚é“_‚ÌYÀ•W

                           

                            dcntF@ˆóü‚·‚é“_‚̌”

                            tblF@@“_‚̍À•W‚ðŠi”[‚µ‚½”z—ñ

                            titleF@ƒOƒ‰ƒt‚Ì•\‘è

 

ƒƒvƒƒOƒ‰ƒ€„

#include <stdio.h>

 

#define STBMAX 61

 

typedef struct{int x;int y;} ZAHYO;

void prtgraph(int,ZAHYO,char*);

 

void main(void)

{

              ZAHYO  s_tbl[STBMAX];

              FILE *fp;

              long yymmdd, t_yymmdd;

              int t_bug, t_chk,I;

              int idx=0;

              char tanto;

 

              fp = fopen(gbugrec.txth,hrh);

              yymmdd=0;

              s_tbl[0].x = s_tbl{0},y = 0;

              while(fscanf(fp,h%81d %c %2d %2d\nh,

                                          &t_yymmdd, &tanto, &t_chk, &t_bug) != EOF)

              {

                            if (yymmdd != t_yymmdd)

                            {

                                          idx++;

                                          yymmdd = t_yymmdd;

                                          s_tbl[idx].x = s_tbl[idx].y = 0;

                            }

                            s_