@SHARIF - IE برنامه نویسی جلالی

‫داﻧﺸﮕﺎه ﻋﻠﻢ و ﺻﻨﻌﺖ اﻳﺮان – داﻧﺸﻜﺪه ﻣﻬﻨﺪﺳﻲ ﻛﺎﻣﭙﻴﻮﺗﺮ‬
‫ﺑﺮﻧﺎﻣﻪ ﻧﻧﻮﻳﺴﻲ‬
‫آﻣﻮزش ﻧﺎ ﻪ‬
‫آ زش‬
‫‪C‬‬
‫‪C++‬‬
‫‪C++ Programming‬‬
‫‪T t i l‬‬
‫‪Tutorial‬‬
‫ﮔﺮدآورﻧﺪه ‪ :‬ﻋﺒﺎس ﻋﺰﻳﺰ ﺟﻼﻟﻲ‬
‫‪C++ Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬ ‫‪1‬‬
‫ﻞا ل‬
‫اول‬ ‫ﻓﻓﺼﻞ‬
‫آﺷﻨﺎﺋﻲ ﺑﺎ‬
‫‪C++‬‬
‫و ﻣﺤﻴﻂ ﻛﺎﻣﭙﺎﻳﻠﺮ‬
: C ‫ﻳﻚ ﺑﺮﻧﺎﻣﻪ ﺑﻪ زﺑﺎن‬
/* P1.1 First Program */
#include <stdio.h>
main()
{
int a, b;
scanf( %d %d”
scanf(“%d %d , &a,
&a &b);
printf(“\n%d”, a + b);
}
Running program:
12 36
48
C++ Tutorial azizjalali@iust.ac.ir 3
: C ‫ﻳﻚ ﺑﺮﻧﺎﻣﻪ ﺑﻪ زﺑﺎن‬
Comment
#
#include <stdio.h> Use of Library Function
main() Basic Function

{ St t off program
Start
int a, b; Declaration part
scanf( %d %d”
scanf(“%d %d , &a,
&a &b); C Executable Statement
} End of program End of each statement
Running program:
12 36
48 .‫ﻴﺢ اﺳﺖ‬
‫ﻣﻴﺸﻮد ﻳﻳﻚ ﻋﺪد ﺻﺤﻴﺢ‬
‫پ ﻴ ﻮ‬‫ﭼﺎپ‬
‫ﺧﻮاﻧﺪه و ﻳﻳﺎ ﭼ‬
‫آﻧﭽﻪ ﻛﻪ ﻮ‬
‫ن اﺳﺖ ﻛﻪ ﭽ‬ ‫ ﻧﺸﺎن‬%
‫ن دﻫﻨﺪه آن‬ %d ‫اﻟﮕﻮي‬
‫ ﻮي‬.‫ﻴﻢ‬‫ﻣﻴﻨﺎﻣﻴﻢ‬
‫ﭘﻴﻤﺎﻳﺶ ﻴ‬ ‫ ررا اﻟﮕﻮي‬%
‫ﻮي ﭘﻴﻤ ﻳﺶ‬ %d %
%d ‫ررﺷﺘﻪ‬

‫دﺳﺘﻮر اﻓﺰاﻳﺶ ‪:‬‬

‫;‪ ++‬ﻣﺘﻐﻴﺮ‬
‫;ﻣﺘﻐﻴﺮ ‪++‬‬
‫ﻴﻢ ‪:‬‬
‫ﺑﻨﻮﻳﺴﻴﻢ‬
‫ﻴﻢ ﺑ ﻮﻳ‬
‫ﻣﻴﺘﻮاﻧﻴﻢ‬ ‫ﻣﺘﻐﻴﺮ ﺑﺑﺎ ﻧﺎمم ‪ a‬ﺮﻳ‬
‫ﺗﻌﺮﻳﻒ ﺷﺪه ﺑﺑﺎﺷﺪ‪ ،‬ﻴ ﻮ‬ ‫اﮔﺮ ﻴﺮ‬‫ﺮ‬
‫;‪a++‬‬
‫;‬
‫;‪++a‬‬
‫و ﻳﺎ‬
‫; ‪a = a + 1‬‬
‫ﻫﻤﻴﻨﻄﻮر ﻣﻲ ﺗﻮاﻧﻴﻢ دﺳﺘﻮر ﻛﺎﻫﺸﻲ داﺷﺘﻪ ﺑﺎﺷﻴﻢ‪ .‬ﻳﻌﻨﻲ ‪:‬‬
‫‪a = a -1‬‬
‫‪1 ; | a‬‬ ‫;‪a--‬‬ ‫;‪; | --a‬‬ ‫;‪a‬‬
: ‫ﻣﻘﺪاردﻫﻲ ﺑﻪ ﻣﺘﻐﻴﺮﻫﺎ در ﺑﺨﺶ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ‬
#include <stdio.h>
main()
{
int a=12, b=36;
/ scanf( %d %d”
/*scanf(“%d %d , &a,
&a &b);*/
&b); /
}
Running program:
12 36
48

‫ﻓﺼﻞ دوم‬
‫ﻓ ﻞ‬
‫آﺷﻨﺎﺋﻲ ﺑﺎ‬
‫داده ﻫﺎ و اﻧﻮاع آن ﻫﺎ‬

‫اﻧﻮاع داده ﻫﺎ ‪:‬‬

‫ﻫﺎ‪.‬‬
‫ﺣﺮوف ‪ /‬ﻧﻧﻮﻳﺴﻪ ﺎ‬
‫ﻛﺎراﻛﺘﺮﻫﺎ ‪ /‬ف‬
‫‪ -1‬ﻛﺎ اﻛﺘ ﺎ‬
‫‪ -2‬ﻋﺪدﻫﺎي ﺻﺤﻴﺢ‪.‬‬
‫‪ -3‬ﻋﺪدﻫﺎي اﻋﺸﺎري ﺗﻚ دﻗﺘﻲ‪.‬‬
‫ﻲ‪.‬‬
‫ري دوو دﻗﺘﻲ‬ ‫‪ -4‬ﻋﺪدﻫﺎي‬
‫ي اﻋﺸﺎري‬
‫‪ -5‬ﻣﻘﺪار ﺗﻬﻲ‪.‬‬

‫‪ -1‬ﻛﺎراﻛﺘﺮﻫﺎ ‪:‬‬
‫ﮔﻮﺋﻴﻢ‪.‬‬
‫ﻛﺎراﻛﺘﺮ ﻣﻲ ﮔ ﺋ‬
‫روﻧﺪ‪ ،‬ﻛﺎ اﻛﺘ‬
‫ﻛﺎر ﻣﻲ ﻧ‬
‫زﺑﺎن ﺑﻪ ﻛﺎ‬
‫ﻫﺎﺋﻲ ﻛﻛﻪ در ﺎ‬
‫ﻧﺸﺎﻧﻪ ﺎﺋ‬
‫ﻳﻚ ااز ﻧﺸﺎﻧ‬
‫ﺑﻪ ﻫﺮ ﻚ‬
‫اﻳﻦ ﻛﺎراﻛﺘﺮﻫﺎ ﻋﺒﺎرﺗﻨﺪ از ‪:‬‬
‫ﺣﺮوف ‪a.. z , A..Z :‬‬

‫ارﻗﺎم ‪0..9 :‬‬
‫‪…., &,‬‬
‫‪& !,‬‬
‫‪! “, #,‬‬
‫‪# $‬‬‫ﺣﺮوف وﻳﮋه ‪$, % :‬‬
‫ﺣ وف‬

‫‪ -2‬ﻋﺪدﻫﺎي ﺻﺤﻴﺢ ‪:‬‬

‫ﺷﻤﺎرش‬
‫ش‬ ‫ﺑﺮاي ﺷ ﺎ‬
‫ﺑﻴﺸﺘﺮ ا‬
‫اﻋﺸﺎر( ﺑﻮده و ﺸﺘ‬
‫اﻋﺪاد ﻃﻃﺒﻴﻌﻲ )ﺑﺪون ا ﺸﺎ‬
‫واﻗﻊ ا ا‬
‫اﻋﺪاد در اﻗ‬
‫ااﻳﻦ ا ا‬
‫ﺑﻜﺎر ﻣﻲ روﻧﺪ‪ .‬ﻋﺪدﻫﺎي ﺻﺤﻴﺢ ﻣﻲ ﺗﻮاﻧﻨﺪ ﺑـﺎ ﻋﻼﻣـﺖ و ﻳـﺎ ﺑـﺪون ﻋﻼﻣـﺖ‬
‫ﻣﺜﺎل‪:‬‬
‫ﺑﺎﺷﻨﺪ‪ .‬ﺜﺎل‬
‫ﺎﺷ‬
‫‪32‬‬
‫‪+164‬‬
‫‪-5821‬‬
‫‪5821‬‬

‫‪ -3‬ﻋﺪدﻫﺎي اﻋﺸﺎري ﺗﻚ دﻗﺘﻲ ‪:‬‬

‫ﺷﻨﺎور(‪،‬‬
‫اﻋﺸﺎري ﺎﻳﺎ ﺷ ﺎ‬
‫ﻋﺪدﻫﺎي ا ﺸﺎ‬
‫ﺎ‬ ‫اﺧﺘﺼﺎر‬
‫دﻗﺘﻲ ) ﺎﻳﺎ ﺑﻪ اﺧﺘ ﺎ‬
‫اﻋﺸﺎري ﺗﻚ ﻗﺘ‬
‫ﺎ‬
‫ﻋﺪدﻫﺎﺋﻲ ﻫﺴﺘﻨﺪ ﻛﻪ داراي ﺟﺰء ﻛﻤﺘﺮ از ﻳﻚ ﻣﻲ ﺑﺎﺷﻨﺪ و در ﭼﻬﺎر ﺑﺎﻳﺖ‬
‫دودوﺋﻲ ‪/‬‬
‫ﺋ‬ ‫ﻛﺎﻣﭙﻴﻮﺗﺮ ﺑﻪ ﺷﻜﻞ‬
‫اﻋﺪاد در ﻛﺎ ﺗ‬
‫ﺷﻮﻧﺪ‪ .‬ااﻳﻦ ا ا‬
‫ذﺧﻴﺮه ﻣﻲ ﺷ ﻧ‬
‫ﺣﺎﻓﻈﻪ ذﺧ‬
‫ااز ﺎﻓﻈ‬
‫ﺑﺎﻳﻨﺮي ﺿﺮب در ﺗﻮاﻧﻲ از ﻋﺪد دو ﻧﮕﻬﺪاري ﻣﻲ ﺷﻮﻧﺪ‪ .‬ﻣﺜﺎل ‪:‬‬
‫‪12.5‬‬
‫‪-132.754‬‬
‫‪+64.‬‬

‫‪ -4‬ﻋﺪدﻫﺎي اﻋﺸﺎري دو دﻗﺘﻲ ‪:‬‬

‫ﻛﻤﺘﺮ ااز‬
‫داراي ﺟﺰء ﻛ ﺘ‬
‫ﻫﺴﺘﻨﺪ ﻛﻛﻪ ا ا‬
‫ﻋﺪدﻫﺎﺋﻲ ﺘ‬‫ﺎﺋ‬ ‫دﻗﺘﻲ ﻫﻢ‬
‫اﻋﺸﺎري دو ﻗﺘ‬
‫ﺎ‬
‫ﻳﻚ ﻣﻲ ﺑﺎﺷﻨﺪ وﻟﻲ در ﻫﺸﺖ ﺑﺎﻳﺖ از ﺣﺎﻓﻈﻪ ذﺧﻴﺮه ﻣﻲ ﺷﻮﻧﺪ‪ ،‬از اﻳﻦ رو‬
‫اﻋﺪاد ﻫﻢ در‬
‫ﻧﺸﺎن دﻫﻨﺪ‪ .‬ااﻳﻦ ا ا‬
‫ﺑﺰرﮔﺘﺮي ارا ﻧﺸﺎ‬
‫ﻣﻘﺪار ﮔﺘ‬
‫ﺗﻮاﻧﻨﺪ ﻘ ا‬
‫ﻋﺪدﻫﺎ ﻣﻲ ﺗ اﻧ‬
‫ﺎ‬ ‫ااﻳﻦ‬
‫ﻛﺎﻣﭙﻴﻮﺗﺮ ﺑﻪ ﺷﻜﻞ دودوﺋﻲ ‪ /‬ﺑﺎﻳﻨﺮي‪ ،‬ﺿﺮب در ﺗﻮاﻧﻲ از ﻋﺪد دو ﻧﮕﻬﺪاري‬
‫ﺷﻮﻧﺪ‪.‬‬
‫ﻣﻲ ﺷ ﻧ‬

‫‪ -5‬ﻣﻘﺪار ﺗﻬﻲ ‪:‬‬

‫ﻛﺎر ﻣﻲ ﺑﺮﻳﻢ‪ .‬ﻫﺮ ﺗﺎﺗﺎﺑﻊ‬‫ﻧﺸﺎﻧﮕﺮﻫﺎ ﺑﻪ ﻛﺎ‬
‫ﺗﻮاﺑﻊ و ﻧﺸﺎﻧﮕ ﺎ‬ ‫ﻫﻤﺮاه ﺎﺑﺎ ﺗ ا‬
‫ا‬ ‫ﻻ‬
‫ﻣﻌﻤﻮﻻ‬ ‫ﻣﻘﺪار ﺗﺗﻬﻲ ارا‬
‫ﻘ ا‬
‫ﻣﻌﻤﻮﻻ ﻣﻘﺪاري را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ‪ ،‬ﭼﻨﺎﻧﻜﻪ ﺗﺎﺑﻌﻲ ﻫﻴﭻ ﻣﻘﺪاري را ﺑﺮﻧﮕﺮداﻧﺪ‪،‬‬
‫ﻧﺸﺎﻧﻲ ﻧﻧﻮع‬
‫ﻧﺸﺎﻧﮕﺮ‪ ،‬ﻧﺸﺎﻧ‬
‫ﺗﻌﺮﻳﻒ ﻣﻲ ﻛﻛﻨﻴﻢ‪ .‬ﻫﻤﭽﻨﻴﻦ ﻫﺮ ﻧﺸﺎﻧﮕ‬ ‫آآن ارا ااز ﻧﻧﻮع ﺗﺗﻬﻲ ﺗ ﻒ‬
‫ﺧﺎﺻﻲ از داده ﻫﺎ را ﻧﺸﺎن ﻣﻲ دﻫﺪ‪ .‬ﭼﻨﺎن ﭼﻪ ﻧﺨﻮاﻫﻴﻢ ﻧﻮع داده اي را ﻛﻪ‬
‫ﺗﻌﺮﻳﻒ ﻣﻲ‬
‫ﻧﻤﺎﺋﻴﻢ‪ ،‬ﺗﺎﺗﺎﺑﻊ ارا ااز ﻧﻧﻮع ﺗﺗﻬﻲ ﺗ ﻒ‬
‫اﺷﺎره ﻣﻲ ﻛﻛﻨﺪ ﺗﺗﻌﻴﻴﻦ ﻧ ﺎﺋ‬
‫ﻧﺸﺎﻧﮕﺮ ﺑﻪ آآن اﺷﺎ‬
‫ﻧﺸﺎﻧﮕ‬
‫ﻛﻨﻴﻢ‪.‬‬

C ‫اﻧﻮاع ﺗﺎﻳﭗ ﻫﺎي داده در‬

‫‪ -5‬ﻣﺘﻐﻴﺮﻫﺎ ‪:‬‬
‫ﻫﺎﺋﻲ از ﺣﺎﻓﻈﻪ ﻫﺴﺘﻨﺪ ﻛﻪ آن ﻫﺎ را ﺑﺮاي ﻧﮕﻬﺪاري داده ﻫﺎ ﺑﻜﺎر ﻣﻣﻲ‬ ‫ﻣﺘﻐﻴﺮﻫﺎ ﻣﻜﺎن ﻫﺎﺋ‬
‫ﺑﺮﻳﻢ‪ .‬اﻳﻦ ﻣﺤﻞ ﻫﺎ را از آن رو ﻣﺘﻐﻴﺮ ﻣﻲ ﻧﺎﻣﻴﻢ ﻛﻪ داده ﻫﺎي آﻧﻬﺎ ﻣﻲ ﺗﻮاﻧﻨﺪ ﺗﻐﻴﻴﺮ‬
‫ﻢ ﻛﻪ درر ﺣﻘﻴﻘﺖ ﻧﺸﺎن‬
‫ن‬ ‫ﻗﺮارر ﻣﻴﺪﻫﻴﻢ‬
‫ﻲ ﺮ‬‫ن ﻧﺎﻣﻲ‬
‫ﺑﺮاي آن‬
‫ﻣﺘﻐﻴﺮ‪ ،‬ﺮ‬
‫ﺮ‬ ‫ﻣﺮاﺟﻌﻪ ﺑﻪ ﻫﺮﺮ‬ ‫ﻧﻤﺎﻳﻨﺪ‪ .‬ﺮ‬
‫ﺑﺮاي ﺮ‬
‫دﻫﻨﺪه ﻣﺤﺘﻮﻳﺎت آن ﻣﺘﻐﻴﺮ اﺳﺖ‪ .‬ﺑﺮ اي ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮﻫﺎ‪ ،‬اﻟﮕﻮي زﻳﺮ را ﺑﻜﺎر ﻣﻴﺒﺮﻳﻢ‪:‬‬
‫;‪char a‬‬
‫;‪int i , cont‬‬
‫‪,‬‬ ‫‪;/ single‬‬
‫*‪float first,second;/‬‬ ‫‪g‬‬ ‫‪precision */‬‬
‫‪p‬‬ ‫‪/‬‬
‫‪double sum; /* double precision */‬‬

: 2 ‫ﻣﺜﺎل‬
/* P2.1 Second Program */
#include <stdio.h>
main()
{
int number;
float sum;
char ch;
scanf(“%d %f %c” , &number, &sum, &ch);

printf(“\n%d %f %c”, number, sum, ch);
}
Running program:
12 2.5 x
12 2.500000 x

‫‪ -5‬ﻧﺎم ﮔﺬاري ﻣﺘﻐﻴﺮﻫﺎ ‪:‬‬
‫ﺑﺮاي ﻧﺎم ﮔﺬاري ﺑﺎﻳﺴﺘﻲ ﻗﻮاﻋﺪ زﻳﺮ را ﺑﻜﺎر ﺑﺮﻳﻢ‪:‬‬
‫‪ -1‬ﻧﺎم ﺑﺎﻳﺪ ﺗﻨﻬﺎ از ﺣﺮوف )‪ a..z‬و ‪ ،(A..Z‬ارﻗﺎم )‪ (0..9‬و ﺣﺮف زﻳﺮﺧﻂ )_( ﺷﺎﺧﺘﻪ ﺷﻮد‪.‬‬
‫‪ -2‬ﺑﻴﺶ از ‪ 31‬ﺣﺮف ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬
‫‪ -3‬از واژه ﻫﺎي ﻛﻠﻴﺪي ‪ C‬و ﺷﻨﺎﺳﻪ ﻫﺎي ‪ /‬ﻣﺘﻐﻴﺮﻫﺎي ﺗﻌﺮﻳﻒ ﺷﺪه در ﺗﻮاﺑﻊ ﻛﺘﺎﺑﺨﺎﻧﻪ اي ﻧﺒﺎﺷﺪ‪.‬‬
‫اﺳﺎﻣﻲ درﺳﺖ ‪:‬‬
‫‪month‬‬
‫‪DAY13‬‬
‫‪new_year‬‬
‫‪_yes‬‬
‫اﺳﺎﻣﻲ ﻧﺎدرﺳﺖ ‪:‬‬
‫‪month:‬‬
‫‪13DAY‬‬
‫‪new year‬‬
‫‪char‬‬
‫‪scanf‬‬
‫ﻳﺎدآوري ‪:‬‬
‫‪ -1‬اﮔﺮ ﻧﺎم ﺑﻴﺶ از ‪ 31‬ﺣﺮف ﺑﺎﺷﺪ‪ ،‬ﻣﺘﺮﺟﻢ ﻓﻘﻂ ‪ 31‬ﺣﺮف اول را در ﻧﻈﺮ ﻣﻲ ﮔﻴﺮد‪.‬‬
‫‪ -2‬زﺑﺎن ‪ C‬ﺑﺮاي ﺣﺮوف ﻛﻮﭼﻚ و ﺑﺰرگ ﻓﺮق ﻗﺎﺋﻞ اﺳﺖ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ ‪ SUM‬و ‪ Sum‬ﻧﺎم دو ﻣﺘﻐﻴﺮ ﻣﺘﻔﺎوت ﻣﻲ ﺑﺎﺷﺪ‪.‬‬
‫‪ -3‬ﻣﻌﻤﻮﻻ ﻧﺎم ﻣﺘﻐﻴﺮﻫﺎ در ﺗﻮاﺑﻊ ﻛﺘﺎﺑﺨﺎﻧﻪ اي ﺑﺎ ﺧﻂ زﻳﺮ ﺷﺮوع ﻣﻣﻲ ﺷﻮد‪ ،‬ﺑﻨﺎﺑﺮاﻳﻦ ﺑﻬﺘﺮ اﺳﺖ اﻳﻦ ﻛﺎراﻛﺘﺮ را در آﻏﺎز ﻧﺎم ﻫﺎ ﺑﻜﺎر ﻧﺒﺮﻳﻢ‪.‬‬

C ‫ﺑﻌﻀﻲ از واژه ﻫﺎي ﻛﻠﻴﺪي در‬

auto double int struct
break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed
g void
default goto sizeof volatile
do if static while
‫ﺛﺎﺑﺖ ﻫﺎ )‪: (constant‬‬

‫ﺛﺎﺑﺖ ﻫﺎ ﻣﻘﺎدﻳﺮي ﻫﺴﺘﻨﺪ ﻛﻪ در ﻃﻮل ﺑﺮﻧﺎﻣﻪ ﺗﻐﻴﻴﺮ ﻧﻤﻲ ﻛﻨﻨﺪ‪ .‬ﺛﺎﺑﺖ ﻫﺎ در زﺑﺎن ‪C‬‬
‫ﻋﺒﺎرﺗﻨﺪ ااز ‪:‬‬
‫ﺎ‬
‫ﺛﺎﺑﺖ ﻫﺎي ﺻﺤﻴﺢ ‪ :‬ﻣﻌﻤﻮﻻ در دو ﺑﺎﻳﺖ )‪ 16‬ﺑﻴﺖ( ﮔﺬاﺷﺘﻪ ﻣﻲ ﺷﻮﻧﺪ‪ .‬اﻳﻦ اﻋﺪاد‬
‫ﺑﻴﻦ ‪ +32767‬و ‪ -32678‬ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ‪ .‬ﭼﺮا؟‬
‫ﺛﺎﺑﺖ ﻫﺎي اﻋﺸﺎري ‪ :‬ﺛﺎﺑﺖ ﻫﺎي اﻋﺸﺎري ﻫﻤﺎﻧﻨﺪ ﻣﺘﻐﻴﺮﻫﺎي اﻋﺸﺎري ﻣﻲ ﺗﻮاﻧﻨﺪ ﺗﻚ‬
‫دﻗﺘﻲ و ﻳﺎ دو دﻗﺘﻲ ﺑﺎﺷﻨﺪ‪ .‬ﻣﺜﻞ ‪2.35E6‬‬
‫ﻛﺎراﻛﺘﺮي ‪ :‬ﺛﺎﺑﺖ ﻫﺎﺋﻲ ﻫﺴﺘﻨﺪ ﻛﻪ ﺑﺮاي ﻧﻤﺎﻳﺶ ﻳﻚ ﻛﺎراﻛﺘﺮ ﺑﻜﺎر ﻣﻲ‬ ‫ﻫﺎي ﻛﺎ اﻛ‬‫ﺛﺎﺑﺖ ﺎ‬ ‫ﺛﺎ‬
‫روﻧﺪ‪ .‬اﻳﻦ ﺛﺎﺑﺖ ﻫﺎ را ﻣﻴﺎن دو ﮔﻴﻮﻣﻪ ﺗﻜﻲ ﻣﻲ ﮔﺬارﻳﻢ‪ .‬ﻣﺜﺎل ‪:‬‬
‫‪A‬‬
‫’‪‘A‬‬
‫’‪‘+‬‬
‫’‪‘2‬‬
‫رﺷﺘﻪ ﻫﺎ )‪: (Strings‬‬

‫رود‪ .‬ﺑﺑﻪ‬
‫ﻲ رو‬
‫ﻣﺴﺘﻘﻴﻤﺎ ﺑﺑﻪ ﻛﺎرر ﻧﻤﻲ‬
‫ﻴ‬ ‫ن ‪ C‬ﻣﺘﻐﻴﺮ‬
‫ﻴﺮ ررﺷﺘﻪ اي‬
‫ي‬ ‫ي ‪ :‬درر زﺑزﺑﺎن‬
‫ي ررﺷﺘﻪ اي‬
‫ﻣﺘﻐﻴﺮﻫﺎي‬
‫ﻴﺮ‬
‫ﺟﺎي ﻣﺘﻐﻴﺮ رﺷﺘﻪ اي از آراﻳﻪ رﺷﺘﻪ اي اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻴﻢ‪) .‬آراﻳﻪ ﻫﺎ در ﻓﺼﻮل ﺑﻌﺪي‬
‫اراﺋﻪ ﻣﻲ ﺷﻮﻧﺪ(‬
‫ﻫﺎي رﺷﺘﻪ ااي‪ :‬ﺑﺮاي ﺳﺎﺧﺘﻦ ﺛﺎﺑﺖ ﻫﺎي رﺷﺘﻪ اي‪ ،‬رﺷﺘﻪ ﻫﺎ را در ﻣﻴﺎن دو‬ ‫ﺛﺎﺑﺖ ﺎ‬ ‫ﺛﺎ‬
‫ﮔﻴﻮﻣﻪ دوﺗﺎﺋﻲ ﻗﺮار ﻣﻲ دﻫﻴﻢ‪ .‬ﻣﺜﺎل‪:‬‬
‫‪“year‬‬
‫‪year 1373‬‬
‫”‪1373‬‬
‫”‪“m‬‬
‫دودوﺋﻲ ارا ﺑﻪ ﻃﻮل ﻳﻚ‬
‫ﺻﻔﺮ دودوﺋ‬‫رﺷﺘﻪ ﻫﺎ‪ ،‬ﻋﺪد ﺻﻔ‬
‫ﺑﺮاي ﻣﺸﺨﺺ ﺷﺪن ﭘﺎﻳﺎن ﺷﺘﻪ‬ ‫ﻣﺘﺮﺟﻢ ‪ ،C‬ﺑ اي‬
‫ﻣﺘ ﺟﻢ‬
‫ﺑﺎﻳﺖ ﺑﻪ اﻧﺘﻬﺎي ﻫﺮ رﺷﺘﻪ اﺿﺎﻓﻪ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫ﭼﻴﺴﺖ؟‬‫ﺛﺎﺑﺖ ’‪ ‘m‬و ”‪ “m‬ﭼﻴ‬ ‫ﺮق دوو ﺑ‬
‫ل ‪ :‬ﻓﺮق‬
‫ﺳﻮال‬
‫ﻮ‬
‫دﺳﺘﻮرﻫﺎي ﭘﻴﻤﺎﻳﺶ و ﺧﻮاﻧﺪن‬

int a;
float sum;
, name[10];
char ch, [ ];
scanf(“%d %f %c %s”, &a, &sum, &ch, &name);

‫دﺳﺘﻮرﻫﺎي ﭘﻴﻤﺎﻳﺶ و ﭼﺎپ‬

printf( Sum = %f\n
printf(“Sum %f\n”, sum);
printf(“Mr. %c %s”, ch , name);
printf(“%f\n”,
p ( \ , sum * 4);
);

‫ﻣﺜﺎل ‪ :‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻧﺎم ﺷﺨﺺ و ﺷﻤﺎره ﺗﻠﻔﻦ او را ﺑﺨﻮاﻧﺪ و ﭼﺎپ ﻧﻤﺎﻳﺪ‪.‬‬
‫‪/* P2.3 Name & Tel. No. */‬‬

‫‪#include <stdio‬‬
‫>‪<stdio.h‬‬
‫>‪h‬‬
‫)(‪main‬‬
‫{‬
‫]‪char name[20‬‬
‫;]‪name[20], tel[10‬‬
‫;)“ ‪printf(“Enter name and tel# :‬‬
‫;)‪scanf(“%s %s” , &name , &tel‬‬
‫;)‪printf(“%s %s\n”, name, tel‬‬
‫}‬
‫‪Running program:‬‬
‫‪Enter name and tel# : Ebrahim 6688007‬‬
‫‪Ebrahim 6688007‬‬
‫ﻣﺜﺎل ‪ :‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻧﺎم و ﭼﻬﺎر ﻧﻤﺮه داﻧﺸﺠﻮﺋﻲ را ﺑﺨﻮاﻧﺪ‪ ،‬ﻧﺎم‪ ،‬ﻧﻤﺮه ﻫﺎ و ﻣﻴﺎﻧﮕﻴﻦ آن ﻫﺎ را ﭼﺎپ ﻧﻤﺎﻳﺪ‪.‬‬

.‫ ﻧﻤﺮه ﻫﺎ و ﻣﻴﺎﻧﮕﻴﻦ آن ﻫﺎ را ﭼﺎپ ﻧﻤﺎﻳﺪ‬،‫ ﻧﺎم‬،‫ ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻧﺎم و ﭼﻬﺎر ﻧﻤﺮه داﻧﺸﺠﻮﺋﻲ را ﺑﺨﻮاﻧﺪ‬: ‫ﻣﺜﺎل‬
/* P2.5 Staudent_Name & Marks */

#include <stdio.h>
main() {
char name[20];
float g1, g2, g3, g4, avg;
printf(“Enter name : “);
scanf(“%s”
f(“% ” , name )
);
printf(“Enter 4 marks : “);
scanf(“%f %f %f %f”, &g1, &g2, &g3, &g4);
avg = (g1 + g2 + g3 + g4) / 4;
printf(“\nName : %s\n”, name);
p
printf(“Marks : %.2f %.2f %.2f %.2f\n”, g1, g2, g3, g4);
printf(“Average : %.2f\n”, avg); }
Running program:
Enter name : Ebrahim.Azari
Enter 4 marks : 18 19 17.5 20
Name : Ebrahim Azari

Marks : 18.00 19.00 17.50 20.00
Average : 18.62

‫دﺳﺘﻮرﻫﺎي ورودي و ﺧﺮوﺟﻲ ‪ cin‬و ‪cout‬‬

‫ﻋﻼوه ﺑﺮ دﺳﺘﻮرات اراﺋﻪ ﺷﺪه ﺑﺮاي ﺧﻮاﻧﺪن و ﻳﺎ ﻧﻤﺎﻳﺶ‪/‬ﭼﺎپ ﻣﻘﺎدﻳﺮ ﺛﺎﺑﺖ و ﻳﺎ ﻣﺤﺘﻮاي‬
‫ﻣﺘﻐﻴﺮﻫﺎ‪ ،‬دﺳﺘﻮرات دﻳﮕﺮي ﻧﻴﺰ از ﻗﺒﻴﻞ ‪ cin‬ﺑﺮاي ﺧﻮاﻧﺪن از ﺻﻔﺤﻪ ﻛﻠﻴﺪ و ‪ cout‬ﺑﺮاي‬
‫ﻧﻤﺎﻳﺶ روي ﺻﻔﺤﻪ ﻣﺎﻧﻴﺘﻮر وﺟﻮد دارد‪.‬‬
‫ﺑﺮاي اﻳﻨﻜﻪ ﺑﺘﻮاﻧﻴﻢ از اﻳﻦ دو ﻣﺘﺪ‪/‬ﺗﺎﺑﻊ اﺳﺘﻔﺎده ﻛﻨﻴﻢ ﺑﺎﻳﺴﺘﻲ در اﺑﺘﺪاي ﺑﺮﻧﺎﻣﻪ ﻓﺎﻳﻞ ﻫﺪر‬
‫ﻧﻤﺎﺋﻴﻢ‪:‬‬
‫ﺗﻌﺮﻳﻒ ﻧﻤﺎﺋ ﻢ‬
‫را ﺗﻌ ﻳﻒ‬
‫زﻳﺮ ا‬
‫زﻳ‬
‫>‪#include <iostream.h‬‬

‫دﺳﺘﻮر ﺧﺮوﺟﻲ ‪cout‬‬

‫اﺳﺖ و ﺗﺎﺗﺎﺑﻊ ﺗﺗﻌﺮﻳﻒ‬
‫ﻒ‬ ‫ﻣﺎﻧﻴﺘﻮر ا ﺖ‬
‫ﺻﻔﺤﻪ ﺎﻧ ﺘ‬
‫ﺑﺮﻧﺎﻣﻪ ﻔ ﻪ‬
‫ﻳﻚ ﻧﺎ ﻪ‬‫اﺳﺘﺎﻧﺪارد ﻚ‬
‫ﺧﺮوﺟﻲ ا ﺘﺎﻧﺪا د‬
‫ﻓﺮض‪ ،‬ﺧ‬
‫ﭘﻴﺶ ﻓ ض‬
‫ﺑﺼﻮرت ﺶ‬
‫ت‬
‫ﺷﺪه ﺑﺮاي دﺳﺘﻴﺎﺑﻲ ﺑﻪ آن ‪ cout‬ﻣﻲ ﺑﺎﺷﺪ‪ cout .‬ﺑﻪ ﻫﻤﺮاه اﭘﺮاﺗﻮر << اﺳﺘﻔﺎده‬
‫ﻣﻴﮕﺮدد‪.‬‬
‫ﻴ ﺮ‬
‫ﻣﺜﺎل ‪:‬‬
‫;"‪cout << "Output sentence‬‬ ‫‪// prints Output sentence on screen‬‬
‫;‪cout << 120‬‬ ‫‪// prints number 120 on screen‬‬
‫;‪cout << x‬‬ ‫‪// prints the content of x on screen‬‬

‫دﺳﺘﻮر ﺧﺮوﺟﻲ ‪ - cout‬اداﻣﻪ‬

‫ﺑﻪ ‪cout‬‬
‫اﺳﺖ ﻪ‬
‫ﮔﺮﻓﺘﻪ ا ﺖ‬
‫ﻗﺮار ﮔ ﻓﺘﻪ‬
‫اﭘﺮاﺗﻮر ﻗ ا‬
‫ﺑﻌﺪ از ا اﺗ‬
‫داده ااي ﻛﻪ ﺪ‬ ‫اﭘﺮاﺗﻮر << ﻣﻮﺟﺐ ﮕ‬
‫ﻣﻴﮕﺮدد ﺗﺎ ا‬ ‫ا اﺗ‬
‫ارﺳﺎل ﺷﻮد‪.‬‬
‫ﺷﻮد‪.‬‬
‫اﺳﺘﻔﺎده ﺷ د‬
‫ت ا ﺘﻔﺎده‬‫ﻋﺒﺎرت‬
‫ﻚﻋﺎ‬‫ﻣﺮﺗﺒﻪ ددر ﻳﻚ‬
‫ﻳﻚ ﺗ ﻪ‬‫ﺑﻴﺶ از ﻚ‬ ‫اﭘﺮاﺗﻮر << ﺘ اﻧﺪ‬
‫ﻣﻴﺘﻮاﻧﺪ ﺶ‬ ‫ا اﺗ‬
‫ﺜﺎل ‪:‬‬
‫ﻣﺜﺎل‬
‫;"‪cout << "Hello, " << "I am " << "a C++ statement‬‬
‫اﻳﻦ ﻋﺒﺎرت ﻣﻮﺟﺐ ﻣﻴﮕﺮدد ﺗﺎ ﻋﺒﺎرت زﻳﺮ روي ﺻﻔﺤﻪ ﻣﺎﻧﻴﺘﻮر ﻧﻤﺎﻳﺶ داده ﺷﻮد‪:‬‬
‫‪Hello, I am a C++ statement‬‬

‫‪Hello, I am 24 years old and my zipcode is 90064‬‬
‫دﺳﺘﻮر ﺧﺮوﺟﻲ ‪ – cout‬اداﻣﻪ‬

‫ﻧﻴﺰ ا ا‬
‫اﺟﺮا‬ ‫ﺑﺎﺷﺪ ارا ﻧ ﺰ‬
‫ﻫﺎ ﺎﺷﺪ‬
‫ﺛﺎﺑﺖ ﺎ‬
‫ﻣﺘﻐﻴﺮﻫﺎ و ﺛﺎ ﺖ‬
‫ﺗﻠﻔﻴﻘﻲ از ﺘﻐ ﺎ‬
‫ت ﻛﻪ ﺗﻠﻔ ﻘ‬
‫ﻋﺒﺎرت‬
‫ﻳﻚ ﺎ‬ ‫اﭘﺮاﺗﻮر ‪ cout‬ﺘ اﻧﺪ‬
‫ﻣﻴﺘﻮاﻧﺪ ﻚ‬ ‫ا اﺗ‬
‫ﻧﻤﺎﻳﺪ‪.‬‬
‫‪cout << "Hello,‬‬
‫;‪Hello, I am " << age << " years old and my zipcode is " << zipcode‬‬
‫ﺪار‬ ‫‪ zipcode‬داراي‬
‫اراي ﻣﻣﻘﺪار‬ ‫ﺪار ‪ 24‬ﺑﺑﺎﺷﺪﺪ و ‪pcode‬‬‫ﻮاي ‪ age‬ﻣﻣﻘﺪار‬
‫ﻴﻢ ﻛﻪ ﻣﻣﺤﺘﻮاي‬ ‫ﺮض ﻛﻨﻴﻢ‬
‫ااﮔﺮﺮ ﻓﺮض‬
‫‪ 90046‬اﺳﺖ‪ ،‬آﻧﮕﺎه ﭘﻴﺎم زﻳﺮ را روي ﺻﻔﺤﻪ ﻣﺎﻧﻴﺘﻮر ﺧﻮاﻫﻴﻢ داﺷﺖ‪:‬‬
‫‪Hello I am 24 years old and my zipcode is 90064‬‬
‫‪Hello,‬‬


‫ﺑﻌﺪي‬
‫ﺧﻄﻮط ﺪ‬
‫ﺑﻪ ﺧﻄ ط‬ ‫ﻣﺨﺘﻠﻒ ‪ cout‬ﻣﻮﺟﺐ ﻓﺘ‬
‫رﻓﺘﻦ ﻪ‬ ‫ﻋﺒﺎرات ﺨﺘﻠﻒ‬
‫ﺑﺪاﻧﻴﻢ ﺎ ات‬
‫اﺳﺖ ﻛﻪ ﺪاﻧ‬
‫ااﻳﻦ ﻧﻜﺘﻪ ﻣﻬﻢ ا ﺖ‬
‫ﻧﻤﻲ ﺷﻮد‪ .‬ﺑﻪ ﻋﺒﺎرت دﻳﮕﺮ‪ ،‬ﻫﺮ ‪ cout‬در اﻧﺘﻬﺎ ﻳﻚ ‪ line break‬ﻧﺨﻮاﻫﺪ داﺷﺖ‪.‬‬
‫‪cout << “This‬‬
‫‪This is a sentence‬‬
‫;;”‪sentence.‬‬
‫”‪cout << “This is another sentence.‬‬
‫ﻣﻮﺟﺐ ﻧﻤﺎﻳﺶ ﻋﺒﺎرت زﻳﺮ روي ﺻﻔﺤﻪ ﻣﺎﻧﻴﺘﻮر ﻣﻴﮕﺮدد‪:‬‬

‫‪This is a sentence. This is another sentence.‬‬


‫ﺑﻪ ﺧﻄ ط‬
‫ﺧﻄﻮط‬ ‫ﻛﻨﺘﺮل ارا ﻪ‬
‫ﻋﺒﺎرﺗﻲ ﻛﻨﺘ ل‬
‫ﺑﻪ ﻋ ﺎ ﺗ‬
‫ﻛﻨﻴﻢ و ﺎﻳﺎ ﻪ‬
‫ﺟﺪا ﻛﻨ‬
‫ﻳﻜﺪﻳﮕﺮ ﺪا‬
‫ﺟﻤﻼت ارا از ﻜﺪ ﮕ‬
‫ﺑﺨﻮاﻫﻴﻢ ﻼت‬‫اﮔﺮ ﺨ اﻫ‬
‫اﮔ‬
‫دﻳﮕﺮ ﻣﻨﺘﻘﻞ ﻧﻤﺎﺋﻴﻢ ﺑﺎﻳﺴﺘﻲ از ﻋﻤﻠﮕﺮ ‪ \n‬اﺳﺘﻔﺎده ﻧﻤﺎﺋﻴﻢ‪.‬‬
‫ﺜﺎل‬
‫;”‪cout << “First sentence.\n‬‬
‫”‪cout << “Second sentence.\nThird sentence.‬‬

‫‪First sentence.‬‬
‫‪Second sentence‬‬
‫‪sentence.‬‬
‫‪Third sentence.‬‬


‫ﺑﺼﻮرت ززﻳﺮ‬
‫ت‬ ‫ﺷﺪه ‪ endl‬ﻫﻢ‬
‫رزرو ﺷﺪ‬ ‫ﺑﺮاي ‪ cout‬ﺎﺑﺎ ﻛﻠ ﻪ‬
‫ﻛﻠﻤﻪ ز‬ ‫ﺑﻌﺪ ا‬
‫ﻛﻨﺘﺮل ﺑﻪﻪ ﺧﻂ ﺪ‬
‫اﻧﺘﻘﺎل ﻛ ﺘ ل‬
‫اﻧﺠﺎم ﻣﻲ ﭘﺬﻳﺮد‪:‬‬
‫ﺜﺎل‬
‫;‪cout << “First sentence.” << endl‬‬
‫;‪cout << “Second sentence.” << endl‬‬

‫‪First sentence.‬‬
‫‪Second sentence‬‬
‫‪sentence.‬‬

‫دﺳﺘﻮر ورودي – ‪cin‬‬

‫ﻛﻠﻴﺪﺪ‬
‫ﺻﻔﺤﻪ ﻛﻠ‬
‫اﻧﺪن از ﻔ ﻪ‬
‫ﺧﻮاﻧﺪن‬
‫ﺑﺮاي ﺧ‬
‫ﻣﻴﺒﺎﺷﺪ‪ .‬ا‬
‫ﻛﻠﻴﺪ ﺎﺷﺪ‬‫ﺻﻔﺤﻪ ﻛﻠ ﺪ‬
‫ﻣﻌﻤﻮﻻ ﻔ ﻪ‬‫ﻻ‬ ‫ورودي ا ﺘﺎﻧﺪا د‬
‫اﺳﺘﺎﻧﺪارد‬ ‫اﺳﺒﺎب د‬ ‫ا ﺎ‬
‫ﻣﻴﺘﻮاﻧﻴﻢ از ﺗﺎﺑﻊ ‪ cin‬و اﭘﺮاﺗﻮر >> اﺳﺘﻔﺎده ﻧﻤﺎﺋﻴﻢ‪ .‬ﺑﻪ دﻧﺒﺎل اﭘﺮاﺗﻮر‪ ،‬اﺳﺎﻣﻲ‬
‫ﺷﻮد‪.‬‬
‫ﻲ ﻮ‬‫آورده ﻣﻲ‬
‫ﺑﮕﻴﺮﻧﺪ ور‬
‫ي ﻣﻘﺪارر ﺑ ﻴﺮ‬
‫ورودي‬
‫ﻲ ازز ورو‬
‫ﺑﺎﻳﺴﺘﻲ‬
‫ﻲ ﻛﻪ ﺑ ﻳ‬
‫ﻣﺘﻐﻴﺮﻫﺎﺋﻲ‬
‫ﻴﺮ‬
‫;‪int age‬‬
‫; ‪cin >> age‬‬
‫ﻋﺒﺎرت اول ﻳﻚ ﻣﺘﻐﻴﺮ دو ﺑﺎﻳﺘﻲ از ﻧﻮع ﺻﺤﻴﺢ را ﺗﻌﺮﻳﻒ ﻣﻴﻜﻨﺪ و ﻋﺒﺎرت دوم ﻣﻨﺘﻈﺮ‬
‫ﻣﺘﻐﻴﺮ ‪ age‬ﻗ ا‬
‫ﻗﺮار ﻣﻴﺪﻫﺪ‪.‬‬ ‫ﺷﺪه و آآن ارا در ﻐ‬
‫ﻳﻚ ﻋﺪد ااز ورودي ﺷ‬
‫ﮔﺮﻓﺘﻦ ﻚ‬
‫ﮔﻓ‬
‫اﺳﺘﻔﺎده ااز & ا‬

‫ﻧﺪارﻳﻢ‪.‬‬ ‫ﺑﺮﺧﻼف دﺳﺘﻮر ‪ ،scanff‬ﺎ‬
‫ﻧﻴﺎز ﺑﻪ ا ﺎ‬ ‫ﻧﻜﺘﻪ ‪ :‬ﻼ‬
‫ﻜ‬
Hello, I am 24 years old and my zipcode is 90064
‫ – اداﻣﻪ‬cin –‫دﺳﺘﻮر ورودي‬

‫ ززده ﺷ‬enter ‫ﻛﻠﻴﺪ‬
.‫ﺷﻮد‬ ‫ﺑﺨﻮاﻧﺪ ﻛﻪ ﻛﻠ ﺪ‬
‫ﻛﻠﻴﺪ ﺨ اﻧﺪ‬
‫ﺻﻔﺤﻪ ﻛﻠ ﺪ‬
‫داده ارا از ﻔ ﻪ‬
‫زﻣﺎﻧﻲ ا‬
‫ﻣﻴﺘﻮاﻧﺪ ز ﺎﻧ‬ ‫ ﺗ ﺎ‬cin
‫ﺗﻨﻬﺎ ﺘ اﻧﺪ‬
‫( داﺷﺘﻪ‬Data Type) ‫ﻗﻄﻌﺎ ﺑﺎﻳﺴﺘﻲ داده ورودي ﺑﺎ ﻣﺘﻐﻴﺮ ﻳﺎ ﻣﺘﻐﻴﺮﻫﺎ ﻫﻤﺨﻮاﻧﻲ‬
: ‫ ﻣﺜﺎل‬.‫ﺑﺎﺷﺪ‬
// i/o example
#include <iostream.h>
int main ()
{ int i;
cout << "Please enter an integer value: ";
cin >> i;
cout << "The value you entered is " << i;
cout << " and its double is " << i*2 << ".\n";
return
t 0 }
0;

‫دﺳﺘﻮر ورودي– ‪ – cin‬اداﻣﻪ‬

‫اﺟﺮاي ﺑﺮﻧﺎﻣﻪ ﻣﺜﺎل ﻗﺒﻞ ﺑﺼﻮرت زﻳﺮ ﺧﻮاﻫﺪ ﺑﻮد ‪:‬‬
‫‪Please enter an integer value: 702‬‬

‫‪The value you entered is 702 and its double is 1404.‬‬
‫ﻧﻜﺘﻪ ‪ :‬ﺑﺎ اﺳﺘﻔﺎده از ‪ ،cin‬ﺗﻨﻬﺎ ﺗﺎ اوﻟﻴﻦ ﻛﺎراﻛﺘﺮ ﺑﻼﻧﻚ ﻣﻘﺪار ورودي ﺧﻮاﻧﺪه ﻣﻴﺸﻮد‪.‬‬


‫ﻧﻜﺘﻪ ‪ :‬ﺑﺎ اﺳﺘﻔﺎده از ‪ ،cin‬ﺗﻨﻬﺎ ﺗﺎ اوﻟﻴﻦ ﻛﺎراﻛﺘﺮ ﺑﻼﻧﻚ‪ ،‬ﻣﻘﺪار ورودي ﺧﻮاﻧﺪه ﻣﻴﺸﻮد‪.‬‬
‫ﻣﻘﺪار ﺬ د‬
‫ﻣﻴﭙﺬﻳﺮد‬ ‫ورودي ﻘﺪا‬
‫ﻣﺘﻐﻴﺮ از دي‬‫ﻳﻚ ﺘﻐ‬‫ﻋﺒﺎرت ‪ cin‬ﻓﻘﻂ ﻚ‬
‫ﻚﻋﺎت‬ ‫اﺳﺖ ﻛﻪ ﺎﺑﺎ ﻳﻚ‬
‫ﻨﺎ ا ﺖ‬
‫ﺑﺪان ﻣﻌﻨﺎ‬
‫ﻦ ﺪان‬ ‫ااﻳﻦ‬
‫و ﻳﺎ اﻳﻨﻜﻪ ﻣﻴﺘﻮاﻧﻴﻢ ﺑﺼﻮرت زﻳﺮ از ﺗﺎﺑﻊ ‪ cin‬اﺳﺘﻔﺎده ﻧﻤﺎﺋﻴﻢ‪.‬‬
‫;‪cin >> a >> b‬‬
‫ﻛﻪ ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ ‪:‬‬
‫;‪cin >> a‬‬
‫;‪cin >> b‬‬


‫ﻣﻘﺪار‬
‫ﺑﻼﻧﻚ ﻘﺪا‬
‫ﻛﺎراﻛﺘﺮ ﻼﻧﻚ‬
‫اوﻟﻴﻦ ﻛﺎ اﻛﺘ‬ ‫اﺳﺘﻔﺎده از ‪ ،cin‬ﺗ ﺎ‬
‫ﺗﻨﻬﺎ ﺗﺎ ا ﻟ‬ ‫ﺷﺪ‪ ،‬ﺎﺑﺎ ا ﺘﻔﺎ‬
‫ﻗﺒﻼ ﮔﻔﺘﻪ ﺷﺪ‬
‫ﻫﻤﺎﻧﮕﻮﻧﻪ ﻛﻪ ﻗ ﻼ‬
‫ﺎﻧﮕ ﻧﻪ‬
‫ورودي ﺧﻮاﻧﺪه ﻣﻴﺸﻮد‪ .‬اﻳﻦ ﻣﺴﺌﻠﻪ در ﻣﻮرد ﺧﻮاﻧﺪن رﺷﺘﻪ ﻫﺎ ﻧﻴﺰ ﺑﺎ اﺳﺘﻔﺎده از ‪cin‬‬
‫ﺻﺪق ﻣﻴﻜﻨﺪ‪ .‬در واﻗﻊ ﺑﺎ اﺳﺘﻔﺎده از ‪ ،cin‬در ﻫﺮ ﺑﺎر ﺧﻮاﻧﺪن ﻣﺠﻤﻮﻋﻪ اي از ﻛﻠﻤﺎت‬
‫ﻛﻪ ﺑﺎ ﻛﺎراﻛﺘﺮ ﺑﻼﻧﻚ از ﻳﻜﺪﻳﮕﺮ ﺟﺪا ﺷﺪه اﻧﺪ‪ ،‬ﻓﻘﻂ ﻣﻴﺘﻮاﻧﻴﻢ ﻳﻚ ﻛﻠﻤﻪ را ﺑﺨﻮاﻧﻴﻢ‪.‬‬
‫‪// cin with strings‬‬
‫>‪#i l d <iostream.h‬‬
‫‪#include‬‬ ‫‪i t‬‬ ‫‪h‬‬
‫>‪#include <string‬‬
‫{ )( ‪int main‬‬
‫;‪string mystr‬‬
‫;" ?‪cout << "What's your name‬‬
‫;)‪getline (cin, mystr‬‬
‫;"‪cout << "Hello " << mystr << ".\n‬‬
‫;)‪cout << "What is your favorite team? "; getline (cin, mystr‬‬
‫‪coutC++‬‬
‫‪<< "I‬‬ ‫;"‪like " << mystr << " too!\n‬‬
‫‪Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬ ‫‪36‬‬
‫} ;‪return 0‬‬

‫ﺑﻮد‪:‬‬
‫ﺧﻮاﻫﺪ د‬
‫ﺑﺼﻮرت ززﻳﺮ ﺧ اﻫﺪ‬
‫ت‬ ‫ﻗﺒﻞ‪ ،‬ا ا‬
‫اﺟﺮا‬ ‫ﻣﺜﺎل ﻗ ﻞ‬
‫ﺑﺮاي ﺜﺎل‬
‫ا‬
‫‪What's your name? Juan Soulie‬‬
‫‪Hello Juan Soulie.‬‬
‫‪What is your favorite team? The Isotopes‬‬
‫!‪I like The Isotopes too‬‬
‫‪ string.h‬ررا داﺷﺘﻪ ﺑ ﻴ‬
‫ﺑﺎﺷﻴﺪ‪.‬‬ ‫ﻳﻞ ﻫﺪرر ‪g‬‬
‫ﺷﺮط آﻧﻜﻪ ﻓﺎﻳﻞ‬
‫ﻧﻜﺘﻪ ‪ :‬ﺑﺑﻪ ﺮ‬
‫دﻫﻴﺪ‪:‬‬
‫اﻧﺠﺎمم ﻴ‬
‫ﻴﺰ ﺠ‬‫ﺑﺼﻮرت زﻳﺮ ﻧﻴﺰ‬
‫ﻴﺮ ﺑ ﻮر‬
‫ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ‬
‫ﻳﻦ ﻛﺎرر ررا ﺑﺑﺎ ﺮﻳ‬
‫ﻤﺮﻳﻦ ‪ :‬اﻳﻦ‬
‫ﺗﻤﺮﻳﻦ‬
‫;]‪char mystr[30‬‬

‫ﺗﻤﺮﻳﻦ ﭘﺎﻳﺎن ﻓﺼﻞ‬
‫ﺒﻲ ررا ازز ﻛﺎرﺑﺮ‬

‫رﺑﺮ‬ ‫ي ﻣﻜﻌﺒﻲ‬
‫ﺮض و ﺑﺑﻠﻨﺪي‬
‫ﻃﻮل‪ ،‬ﻋﺮض‬
‫ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻮل‬
‫ي ﺑ ﻮﻳ ﻴ‬
‫ﺑﺮﻧﺎﻣﻪ اي‬
‫‪ -1‬ﺑﺮ‬
‫ﭘﺮﺳﻴﺪه‪ ،‬ﺳﭙﺲ ﺣﺠﻢ آن را ﻣﺤﺎﺳﺒﻪ و ﭼﺎپ ﻧﻤﺎﻳﺪ‪.‬‬
‫‪ -2‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﺗﻌﺪاد ﺳﺎﻋﺖ ﻫﺎ‪ ،‬دﻗﻴﻘﻪ ﻫﺎ و ﺛﺎﻧﻴﻪ ﻫﺎي ﻳﻚ‬

‫ﭼﺎپ ﺎ‬
‫ﺳﻄﺮ ﺎ‬
‫ﻣﺤﺎﺳﺒﻪ و در ﺳﻪ ﻄ‬
‫ﺳﺎل ارا ﺎ‬
‫ﺎل‬

‫ﻓﺼﻞ ﺳﻮم‬
‫ﻋﺒﺎرت ﻫﺎ‬
‫ﻋﺎت‬
‫و‬
‫ﻋﻤﻠﮕﺮﻫﺎ‬

‫‪ -3‬ﻋﻤﻠﮕﺮﻫﺎ‬
‫اﻧﻮاع ﻋ ﻠﮕ ﻫﺎ‬
‫ﻋﻤﻠﮕﺮﻫﺎ‬ ‫‪ -3-1‬اﻧ اع‬
‫‪ .1‬ﺣﺴﺎﺑﻲ‬
‫راﺑﻄﻪ ااي‬
‫‪ .2‬ا ﻄ‬
‫‪ .3‬ﻣﻨﻄﻘﻲ‬
‫ﺑﻴﺘﻲ‬
‫‪ .4‬ﺘ‬
‫‪ .5‬ﺟﺎﺑﻪ ﺟﺎﺋﻲ‬
‫ﻳﮕﺎﻧﻲ‬
‫‪ .6‬ﮕﺎﻧ‬
‫‪ .7‬واﮔﺬاري‬
‫ﺷﺮﻃﻲ‬
‫‪ .8‬ﺷﺮﻃ‬
‫‪ -1‬ﻋﻤﻠﮕﺮﻫﺎي ﺣﺴﺎﺑﻲ‬
‫ﻣﻌﻨﺎي ﻋﻤﻠﮕﺮﺮ‬ ‫ﻋﻤﻠﮕﺮﺮ‬

‫ﺟﻤﻊ‬ ‫‪+‬‬
‫ﺗﻔ ﻳﻖ‬
‫ﺗﻔﺮﻳﻖ‬ ‫‪-‬‬
‫ﺿﺮب‬ ‫*‬
‫ﺗﻘﺴﻴﻢ‬
‫ﻘ‬ ‫‪/‬‬
‫ﺑﺎﻗﻴﻤﺎﻧﺪه ﺗﻘﺴﻴﻢ دو ﻣﻘﺪار ﺻﺤﻴﺢ‬ ‫‪%‬‬

‫‪ -1‬اوﻟﻮﻳﺖ ﻋﻤﻠﮕﺮﻫﺎي ﺣﺴﺎﺑﻲ‬
‫ﻫﺎي ﻫﻫﻢ اوﻟﻮﻳﺖ‬

‫ﻋﻤﻠﮕﺮﻫﺎي‬
‫اي ﻋﻤﻠﮕ‬
‫اﺟﺮاي‬
‫اﺟ‬ ‫ﻋﻤﻠﮕﺮ‬
‫ﻋﻤﻠﮕ‬ ‫اوﻟﻮﻳﺖ‬
‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫* ‪% /‬‬ ‫‪1‬‬

‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫‪- +‬‬ ‫‪2‬‬

‫‪ -2‬ﻋﻤﻠﮕﺮﻫﺎي راﺑﻄﻪ اي‬

‫ﻣﻌﻨﺎي ﻋﻤﻠﮕﺮ‬ ‫ﻋﻤﻠﮕﺮ‬
‫ﺑﺰرﮔﺘﺮ‬ ‫>‬
‫ﺑﺰرﮔﺘﺮ ﻳﺎ ﻣﺴﺎوي‬ ‫=>‬
‫ﻛﻮﭼﻜﺘﺮ‬ ‫<‬
‫ﻛﻮﭼﻜﺘﺮ ﻳﺎ ﻣﺴﺎوي‬ ‫=<‬
‫ﻣﺴﺎوي‬ ‫==‬
‫ﻧﺎﻣﺴﺎوي‬
‫وي‬ ‫=!!‬
‫‪ -2‬اوﻟﻮﻳﺖ ﻋﻤﻠﮕﺮﻫﺎي راﺑﻄﻪ اي‬

‫اﺟﺮاي‬
‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫< =<‬ ‫> =>‬ ‫‪1‬‬

‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫==‬ ‫=!‬ ‫‪2‬‬

‫‪ -3‬ﻋﻤﻠﮕﺮﻫﺎي ﻣﻨﻄﻘﻲ‬
‫ﻣﻌﻨﺎي ﻋﻤﻠﮕﺮﺮ‬ ‫ﻋﻤﻠﮕﺮﺮ‬

‫ﻧﻪ ﻳﺎ ﻧﻘﻴﺾ‬ ‫!‬
‫و )‪(Logical AND‬‬ ‫&&‬
‫ﻳﺎ )‪(Logical OR‬‬ ‫||‬

‫‪ -3‬اوﻟﻮﻳﺖ ﻋﻤﻠﮕﺮﻫﺎي ﻣﻨﻄﻘﻲ‬

‫اﺟﺮاي‬
‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫!‬ ‫‪1‬‬

‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫&&‬ ‫‪2‬‬
‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫||‬ ‫‪3‬‬

‫‪ -3‬ﻧﺘﻴﺠﻪ ﻋﻤﻠﮕﺮﻫﺎي ﻣﻨﻄﻘﻲ‬

‫ﻣﻘﺪار ﻋﺒﺎرت‬ ‫ﻋﺒﺎرت‬
‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪a‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪b‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪!a‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪a && b‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪a || b‬‬

‫‪ -4‬ﻋﻤﻠﮕﺮﻫﺎي ﺑﻴﺘﻲ‬
‫وي ﺑﻴﺘﻲ )‪(AND‬‬ ‫&‬
‫ﻳﺎي ﺑﻴﺘﻲ )‪(OR‬‬ ‫|‬
‫ﻳﺎي اﻧﺤﺼﺎري ﺑﻴﺘﻲ )‪(Exclusive OR‬‬ ‫^‬
‫ﻧﻘﻴﺾ ﺑﻴﺘﻲ‬ ‫~‬
‫ﺟﺎﺑﺠﺎﺋﻲ ﺑﻪ راﺳﺖ )‪(Shift Right‬‬ ‫>>‬
‫ﺟﺎﺑﺠﺎﺋﻲ ﺑﺑﻪ ﭼﭗ )‪(Shift Left‬‬
‫ﺟ ﺑﺠ ﻲ‬ ‫<<‬
‫‪ -4‬ﻧﺘﻴﺠﻪ ﻋﻤﻠﮕﺮﻫﺎي ﺑﻴﺘﻲ‬

‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﻢ ﻛﻪ ﻫﺮ ﺑﻴﺖ ‪ a‬و ﻳﺎ ‪ b‬ﻣﺪ ﻧﻈﺮ اﺳﺖ‪.‬‬
‫ﻋﺒﺎرت‬
‫ﻣﻘﺪارر ر‬ ‫ﻋﺒﺎرت‬
‫ر‬
‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪a‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪b‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪~a‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪a ^ b‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪a&b‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪a|b‬‬
‫‪ -5‬ﻋﻤﻠﮕﺮﻫﺎي ﺟﺎﺑﺠﺎﺋﻲ‬
‫ﻋﻤﻠﮕﺮﻫﺎي ﺟﺎﺑﺠﺎﺋﻲ را ﺑﺮاي ﺟﺎﺑﺠﺎﻛﺮدن ﺑﻴﺖ ﻫﺎي ﻳﻚ ﻛﺎراﻛﺘﺮ و ﻳﺎ ﻳﻚ ﻋﺪد ﺻﺤﻴﺢ‬
‫ﺑﻪ ﻛﺎر ﻣﻲ ﺑﺮﻳﻢ‪ .‬ﻣﺜﺎل ‪:‬‬
‫‪‘a’ >> 1‬‬
‫‪‘E’ << 4‬‬
‫آراﻳﺶ ﺑﻴﺘﻲ ﻛﺎراﻛﺘﺮ ‪0110 0001 a‬‬
‫ﻛﺎراﻛﺘﺮ ‪0100 0101 E‬‬ ‫آراﻳﺶ ﺑﻴﺘﻲ ﻛﺎ اﻛ‬
‫آا‬
‫‪‘a’ = 0 1 1 0 0 0 0 1‬‬
‫’‪0 0 1 1 0 0 0 0 = ‘0‬‬ ‫‪0 :: ASCII = 48‬‬
‫‪‘E’ = 0 1 0 0 0 1 0 1‬‬
‫’‪0 1 0 1 0 0 0 0 = ‘P‬‬ ‫? = ‪P :: ASCII‬‬
‫‪ -5‬ﻋﻤﻠﮕﺮﻫﺎي ﺟﺎﺑﺠﺎﺋﻲ )اداﻣﻪ(‬

‫ﻛﺎراﻛﺘﺮﺮ ‪0110 0001 a‬‬
‫ﺑﻴﺘﻲ ر‬
‫ﻳﺶ ﺑﻴ ﻲ‬
‫آراﻳﺶ‬
‫ر‬
‫آراﻳﺶ ﺑﻴﺘﻲ ﻛﺎراﻛﺘﺮ ‪0100 0101 E‬‬
‫’‪a = ‘a‬‬
‫’‪a , E = ‘E‬‬
‫‪E‬‬
‫’‪a & E = 0 1 0 0 0 0 0 1 = ‘A‬‬
‫’‪a | E = 0 1 1 0 0 1 0 1 = ‘e‬‬
‫’‪a ^ E = 0 0 1 0 0 1 0 0 = ‘$‬‬
‫’@‘ = ‪a << 6 = 0 1 0 0 0 0 0 0‬‬
‫’”‘ = ‪E >> 1 = 0 0 1 0 0 0 1 0‬‬
‫‪ -5‬اوﻟﻮﻳﺖ ﻋﻤﻠﮕﺮﻫﺎي ﺑﻴﺘﻲ‬

‫اﺟﺮاي ﻋﻤﻠﮕﺮﻫﺎي ﻫﻢ اوﻟﻮﻳﺖ‬ ‫ﻋﻤﻠﮕﺮ‬ ‫اوﻟﻮﻳﺖ‬
‫از راﺳﺖ ﺑﻪ ﭼﭗ‬ ‫~‬ ‫‪1‬‬

‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫>> <<‬ ‫‪2‬‬
‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫&‬ ‫‪3‬‬
‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫^‬ ‫‪4‬‬
‫زاز ﭼﭗ ﺑﺑﻪ رراﺳﺖ‬ ‫|‬ ‫‪5‬‬
‫‪ -5‬اوﻟﻮﻳﺖ ﻋﻤﻠﮕﺮﻫﺎي ﺑﻴﺘﻲ)ﻣﺜﺎل(‬

‫‪a & b >> 3 | c ^ e << 2‬‬
‫‪If a=1 , b=8 , c=3 , e=1 Then‬‬

‫‪ -5‬اوﻟﻮﻳﺖ ﻋﻤﻠﮕﺮﻫﺎي ﺑﻴﺘﻲ)ﻣﺜﺎل(‬

‫‪a & b >> 3 | c ^ e << 2‬‬
‫‪If a=1 , b=8 , c=3 , e=1 Then‬‬
‫‪1 & 8 >> 3 | 3 ^ 1 << 2‬‬

‫‪1&1|3^4‬‬
‫‪1|3^4‬‬
‫‪1|7‬‬
‫‪7‬‬
‫‪ -6‬ﻋﻤﻠﮕﺮﻫﺎي ﻳﮕﺎﻧﻲ‬
‫ﻣﺜﺒﺖ‬ ‫‪+‬‬
‫ﻣﻨﻔﻲ‬ ‫‪-‬‬
‫اﻓﺰاﻳﺶ‬ ‫‪++‬‬
‫ﻛﺎﻫﺶ‬ ‫‪--‬‬
‫ﺗﺒﺪﻳﻞ ﻧﻮع‬ ‫)ﻧﻮع(‬
‫اﻧﺪازه‬ ‫‪sizeof‬‬
‫ﻧﺸﺎﻧﻲ‬
‫ﻲ‬ ‫&‬
‫‪C++ Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬
‫ﻧﺸﺎﻧﮕﺮ‬ ‫*‬ ‫‪55‬‬
(‫ ﻋﻤﻠﮕﺮﻫﺎي ﻳﮕﺎﻧﻲ )ﻣﺜﺎل‬-6

If i=3 , j=4 , k=5 , m=6
++i Æ 4 , j++ Æ 5 , --k Æ 4 , m-- Æ 5
i = i + 1;
1 j = j + 1;1 k = k – 1;
1 x = ++i;++i
(int) 25.5 Æ 25 , (float) 12 Æ 12.0
sizeof 12 Æ 2 (if shortint) , 4 (if int)
sizeof (float) Æ 4
sizeof (int) Æ 4
sizeof ((double)) Æ 8
‫‪ -7‬ﻋﻤﻠﮕﺮﻫﺎي واﮔﺬاري‬
‫ﻋﻤﻠﮕﺮﻫﺎﺋﻲ ﻫﺴﺘﻨﺪ ﻛﻪ ﺑﺮاي واﮔﺬار ﻛﺮدن ﻣﻘﺪار ﻳﻚ ﻋﺒﺎرت ﺑﻪ ﻳﻚ ﻣﺘﻐﻴﺮ ﺑﻪ ﻛﺎر‬
‫ﻣﻴﺮوﻧﺪ‪ .‬ﻣﺜﺎل‪:‬‬
‫;‪a = b + 2‬‬
‫ﻣﻲ ﺗﻮاﻧﻴﻢ ﻋﻤﻠﮕﺮﻫﺎي دودوﺋﻲ ﺣﺴﺎﺑﻲ را ﺑﺎ ﻋﻤﻠﮕﺮﻫﺎي واﮔﺬاري ﺗﺮﻛﻴﺐ ﻧﻤﺎﺋﻴﻢ‪ .‬اﻳﻦ‬
‫ﻋﻤﻠﮕﺮﻫﺎ ﻋﺒﺎرﺗﻨﺪ از ‪:‬‬
‫=‪+= -= *= /= %‬‬
‫;‪x = x + 3; ::: x += 3‬‬
‫دﻳﮕﺮ ﻛﻛﻤﺘﺮ ااﺳﺖ‪ .‬ﺧﻮد ااﻳﻦ ﻠﮕ ﺎ‬
‫ﻋﻤﻠﮕﺮﻫﺎ‬ ‫ﻋﻤﻠﮕﺮﻫﺎي ﮕ‬
‫واﮔﺬاري ااز ﻫﻤﻪ ﻠﮕ ﺎ‬
‫ﻋﻤﻠﮕﺮﻫﺎي اﮔﺬا‬
‫اوﻟﻮﻳﺖ ﻠﮕ ﺎ‬ ‫اﻟ‬
‫داراي اوﻟﻮﻳﺖ ﻳﻜﺴﺎﻧﻨﺪ و در ﺻﻮرت داﺷﺘﻦ ﭼﻨﺪ ﻋﻤﻠﮕﺮ واﮔﺬاري در ﻳﻚ ﻋﺒﺎرت‪،‬‬
‫اوﻟﻮﻳﺖ آن ﻫﺎ از راﺳﺖ ﺑﻪ ﭼﭗ ﻣﻲ ﺑﺎﺷﺪ‪.‬‬
‫‪ -8‬ﻋﻤﻠﮕﺮ ﺷﺮﻃﻲ‬
‫ﺑﺮﻗﺮار ﺑﻮدن و ﺎﻳﺎ ﻧﺒﻮدن‬ ‫ﺷﺮﻃﻲ )‪ ،(?:‬ﻠﮕ‬
‫ﻋﻤﻠﮕﺮي ااﺳﺖ ﻛﻛﻪ ﺑﺴﺘﻪ ﺑﻪ ﻗ ا‬ ‫ﻋﻤﻠﮕﺮ ﺷ ﻃ‬
‫ﻠﮕ‬
‫ﻳﻚ ﺷﺮط‪ ،‬ﻣﻘﺪار ﻳﻜﻲ از دو ﻋﺒﺎرت ﭘﺲ از ﺧﻮد را ﺑﺮﻣﻲ ﮔﺰﻳﻨﺪ‪ .‬اﻟﮕﻮي ﺑﻪ‬
‫اﺳﺖ‪:‬‬
‫ﺻﻮرت زﻳﺮ ا ﺖ‬
‫ﻋﻤﻠﮕﺮ ﺑﻪ ت‬ ‫ﺑﺴﺘﻦ ااﻳﻦ ﻠﮕ‬
‫ﻛﺎر ﺘ‬‫ﻛﺎ‬
‫ﻋﺒﺎرت ‪ : 2‬ﻋﺒﺎرت ‪ ? 1‬ﺷﺮط‬
‫ﻣﻘﺪار اﻳﻦ ﻋﺒﺎر در ﺻﻮرت ﺑﺮﻗﺮاي ﺷﺮط ﻋﺒﺎرت ‪ 1‬و در ﻏﻴﺮ اﻳﻦ ﺻﻮرت‬
‫ﻋﺒﺎرت ‪ 2‬ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬
‫;‪x = n > 0 ? n : -n‬‬

‫ﺗﺮﺗﻴﺐ اوﻟﻮﻳﺖ ﻋﻤﻠﮕﺮﻫﺎ‬
‫اﺟﺮاي ﻋﻤﻠﮕﺮﻫﺎي ﻫﻢ اوﻟﻮﻳﺖ‬ ‫ﻋﻤﻠﮕﺮ‬ ‫اوﻟﻮﻳﺖ‬
‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫‪--‬‬ ‫‪++‬‬ ‫‪Æ‬‬ ‫)(‬ ‫‪1‬‬
‫از راﺳﺖ ﺑﻪ ﭼﭗ‬ ‫‪sizeof‬‬
‫‪i‬‬ ‫‪f‬‬ ‫))ﻧﻮع((‬ ‫&‬ ‫*‬ ‫‪-‬‬ ‫~‬ ‫!‬ ‫‪+‬‬ ‫‪2‬‬
‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫‪%‬‬ ‫‪/‬‬ ‫*‬ ‫‪3‬‬
‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫‪-‬‬ ‫‪+‬‬ ‫‪4‬‬
‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫<<‬ ‫>>‬ ‫‪5‬‬
‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫=<‬ ‫<‬ ‫=>‬ ‫>‬ ‫‪6‬‬
‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫=!‬ ‫==‬ ‫‪7‬‬
‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫&‬ ‫‪8‬‬
‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫^‬ ‫‪9‬‬
‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫|‬ ‫‪10‬‬
‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫&&‬ ‫‪11‬‬
‫از ﭼﭗ ﺑﻪ راﺳﺖ‬ ‫||‬ ‫‪12‬‬
‫از راﺳﺖ ﺑﻪ ﭼﭗ‬ ‫‪?:‬‬ ‫‪13‬‬
‫از راﺳﺖ ﺑﻪ ﭼﭗ‬ ‫= =‪< <= >> = |= ^= &= %= /= *= -= +‬‬ ‫‪14‬‬
(3-1 ‫ﻣﺜﺎل )ﺑﺮﻧﺎﻣﻪ‬
/* P 3.1 Compound assignment operations */
#include <stdio.h>
main()
{
int p=10 , q=3;
printf(“p
printf( p = %d , q = %d\n”
%d\n , p,
p q);
printf(“p += q Æ %d\n” , p += q);
printf(“p -= q Æ %d\n” , p -= q);
printf(“p *= q Æ %d\n” , p *= q);
printf(“p /= q Æ %d\n” , p /= q);
printf(“p %= q Æ %d\n” , p %= q);
printf(“p ^= q Æ %d\n” , p ^= q);
p &= q Æ %d\n
printf(“p
printf( %d\n” , p &= q);
printf(“p |= q Æ %d\n” , p |= q);
printf(“p <<= q Æ %d\n” , p <<= q);
printf(“p >>= q Æ %d\n” , p >>= q);
}
3-1 ‫اﺟﺮاي ﺑﺮﻧﺎﻣﻪ‬

p = 10 , q = 3
p += q Æ 13
p -= q Æ 10
p *= q Æ 30
p /= q Æ 10
p %= q Æ 1
p ^= q Æ 9
p &= q Æ 2
p |= q Æ 3
p <<= q Æ 24
p >>= q Æ 3
(3-2 ‫ﻣﺜﺎل )ﺑﺮﻧﺎﻣﻪ‬
/* P 3.2 Compound assignment operations */
#include <stdio.h>
main()
{
int x, n;
printf(“Enter a number : “);
scanf(“%d”
scanf( %d , &n);
x = n > 0 ? n : -n;
printf(“Absolute value of %d is %d\n”, n , x);
}
Running Program
Enter a number : 100
Absolute value of 100 : is 100
Running Program
Enter a number : -100
Absolute value of -100 : is 100

‫‪ -1‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻣﻘﺎدﻳﺮ ‪ a , b, c, d, i, j, k‬را از ورودي ﺧﻮاﻧﺪه و ﻋﺒﺎرات زﻳﺮ را ﻣﺤﺎﺳﺒﻪ و ﭼﺎپ ﻧﻤﺎﻳﺪ‪.‬‬
‫‪a+b/c–d‬‬
‫‪(a + b) / c – d‬‬
‫)‪a + b / (c – d‬‬
‫))‪((a + b)) / ((c – d‬‬
‫‪i < j‬‬
‫‪i > j‬‬
‫‪i == j‬‬
‫‪i <= j‬‬
‫‪i >= j‬‬
‫‪i != j‬‬
‫‪i > j && j > k‬‬
‫‪i > j || j > k‬‬
‫)‪! ( I > j || j > k‬‬

‫ﻓﺼﻞ ﭼﻬﺎرم‬
‫دﺳﺘﻮ ﻫﺎ‬
‫دﺳﺘﻮرﻫﺎ‬
‫)‪(C Statements‬‬

‫‪ -1‬ﻋﺒﺎرت ﻛﻨﺘﺮﻟﻲ ‪if‬‬

‫;‪if (condition) then_clause‬‬
‫‪[ l‬‬
‫];‪[else_clause‬‬
‫‪l‬‬ ‫]‬
‫در ﺻﻮرت درﺳﺖ ﺑﻮدن ﺷﺮط )‪ ،(condition‬ﺑﺨﺶ ‪ then_clause‬و در‬
‫ﺷﻮد‪.‬‬
‫ﻣﻲ ﻮ‬ ‫ﺶ ‪ else_clause‬ﺟﺮ‬
‫اﺟﺮا ﻲ‬ ‫ﺷﺮط‪ ،‬ﺑﺑﺨﺶ‬
‫ن ﺮ‬‫ﺑﻮدن‬
‫ﻧﺎدرﺳﺖ ﺑﻮ‬
‫ﺻﻮرت ر‬‫ﻮر‬
‫)‪if (x > 100‬‬
‫;‪x = 100‬‬
‫)‪if (i > 10‬‬
‫;‪x = 100‬‬
‫‪100‬‬
‫‪else‬‬
‫;‪x = 200‬‬
‫ ﭼﻨﺎن ﻛﻪ اوﻟﻲ از دوﻣﻲ ﺑﺰرﮔﺘﺮ ﺑﺎﺷﺪ‬،‫ ﻣﻲ ﺧﻮاﻫﻴﻢ ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﻢ ﻛﻪ دو ﻋﺪد را ﺑﺨﻮاﻧﺪ‬: ‫ﻣﺜﺎل‬
.‫ﺗﻔﺎﺿﻞ دو ﻋﺪد و در ﻏﻴﺮ اﻳﻦ ﺻﻮرت ﻣﺠﻤﻮع آن ﻫﺎ را ﭼﺎپ ﻧﻤﺎﻳﺪ‬
/* P4.1 if statement */
#include <stdio.h>
main()
{
i t a, b
int b;
printf(“Enter 2 Integer No. : “);

scanf(“%d %d” , &a, &b);
if (a>b)
printf(“a – b = %d\n”, a – b);
else
printf(“a + b = %d\n”, a + b);
}
Running program:
Enter 2 Integer No. : 12 9
a – b = 3

‫ﻣﺤﺎﺳﺒﻪ و‬
‫ﺑﺰرﮔﺘﺮ ﺑﺎﺷﺪ ﺗﻔﺎﺿﻞ دو ﻋﺪد ارا ﻣﺤﺎﺳ ﻪ‬
‫دوﻣﻲ ﺑﺰ ﮔﺘ‬
‫اوﻟﻲ از دوﻣ‬
‫ﺑﻨﻮﻳﺴﻴﻢ ﻛﻪ دو ﻋﺪد ارا ﺑﺨﻮاﻧﺪ‪ ،‬ﭼﻨﺎن ﻛﻪ اوﻟ‬
‫ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳ ﻢ‬
‫ﺧﻮاﻫﻴﻢ ﺑ ﻧﺎﻣﻪ‬
‫ﻣﺜﺎل ‪ :‬ﻣﻣﻲ ﺧﻮاﻫ ﻢ‬
‫ﭼﺎپ ﻧﻤﺎﻳﺪ‪ ،‬در ﻏﻴﺮ اﻳﻦ ﺻﻮرت ﻳﻚ ﻋﺪد دﻳﮕﺮ را ﻫﻢ ﺧﻮاﻧﺪه و ﻣﺠﻤﻮع ﺳﻪ ﻋﺪد را ﭼﺎپ ﻧﻤﺎﻳﺪ‪.‬‬
‫‪/* P4.2 compound if statement */‬‬
‫>‪#include <stdio.h‬‬
‫)(‪main‬‬
‫{‬
‫;‪int a, b, c‬‬
‫;)“ ‪printf(“Enter 2 Integer No. :‬‬
‫‪scanf(“%d‬‬
‫(‪scanf‬‬ ‫”‪%d %d‬‬
‫‪%d , &a,‬‬
‫;)‪&a &b‬‬
‫)‪if (a>b‬‬
‫;)‪printf(“a – b = %d\n”, a – b‬‬
‫{ ‪else‬‬
‫;)“ ‪printf(“Enter third No. :‬‬
‫;)‪scanf(“%d”, &c‬‬
‫;)‪printf(“a + b + c = %d\n”, a + b + c‬‬ ‫}‬
‫}‬
‫‪Running‬‬ ‫‪program:‬‬
‫‪Enter 2 Integer No. : 20‬‬ ‫‪32‬‬
‫‪Enter third No. : 8‬‬
‫‪a + b + c = 60‬‬

‫ﺑﺰرﮔﺘﺮ‬
‫اوﻟﻲ از ددوﻣﻲ ﺰ ﮔﺘ‬
‫ﭼﻨﺎن ﻛﻪ ا ﻟ‬
‫ﺑﺨﻮاﻧﺪ‪ ،‬ﻨﺎن‬
‫ﺑﺮﻧﺎﻣﻪ اي ﻨﺑﻨﻮﻳﺴﻴﻢ ﻛﻪ ددو ﻋﺪد ارا ﺨ اﻧﺪ‬
‫ﺧﻮاﻫﻴﻢ ﻧﺎ ﻪ‬
‫ﻣﺜﺎل ‪ :‬ﻣﻲ ﺧ اﻫ‬
‫ﺑﺎﺷﺪ ﺗﻔﺎﺿﻞ دو ﻋﺪد را ﻣﺤﺎﺳﺒﻪ و ﭼﺎپ ﻧﻤﺎﻳﺪ‪ ،‬در ﺻﻮرﺗﻲ ﻛﻪ اوﻟﻲ از دوﻣﻲ ﻛﻮﭼﻜﺘﺮ ﺑﺎﺷﺪ ﻣﺠﻤﻮع‬
‫دو ﻋﺪد و در ﻏﻴﺮ اﻳﻦ ﺻﻮرت ﺣﺎﺻﻞ ﺿﺮب دو ﻋﺪد را ﭼﺎپ ﻧﻤﺎﻳﺪ‪.‬‬
‫‪/* P4.3 compound‬‬
‫‪p‬‬ ‫‪if statement */‬‬
‫)(‪main‬‬
‫{‬
‫‪int a‬‬
‫‪a, b‬‬
‫;‪b, c‬‬
‫;)“ ‪printf(“Enter 2 Integer No. :‬‬
‫;)‪scanf(“%d %d” , &a, &b‬‬
‫)‪if (a>b‬‬
‫;)‪printf(“a – b = %d\n”, a – b‬‬
‫)‪else if (a < b‬‬
‫;)‪printf(“a + b = %d\n “, a + b‬‬
‫‪else‬‬
‫;) ‪printf(“a * b = %d\n”, a * b‬‬
‫}‬
‫‪Running‬‬ ‫‪program:‬‬
‫‪Enter 2 Integer No. : 20‬‬ ‫‪20‬‬
‫‪a * b = 400‬‬

‫‪ -2‬ﻋﺒﺎرت ﻛﻨﺘﺮﻟﻲ‪-‬اﻧﺘﺨﺎﺑﻲ )‪(Switch‬‬
‫ﻋﺒﺎرت ﻧﺘﺨﺎﺑﻲ ‪ switch‬را زﻣﺎﻧﻲ ﺑﻪ ﻛﺎر ﻣﻲ ﺑﺮﻳﻢ ﻛﻪ ﺑﺨﻮاﻫﻴﻢ از ﻣﻴﺎن ﭼﻨﺪ ﮔﺰﻳﻨﻪ ﻳﻜﻲ را اﻧﺘﺨﺎب ﻧﻤﺎﺋﻴﻢ‪ .‬ﻓﺮﻣﺖ‬
‫ﻋﺒﺎرت ﺑﻪ ﺻﻮرت زﻳﺮ اﺳﺖ‪:‬‬
‫{ )‪switch (variable/expression‬‬
‫;‪case value1 : statement‬‬
‫;‪case value2 : statement‬‬
‫‪…..‬‬
‫];‪[default : statement‬‬
‫}‬
‫ﺗﺬﻛﺮﺮ ‪:‬‬
‫¾ در اﻳﻦ ﻋﺒﺎرت‪ ،‬ﻣﻘﺎدﻳﺮ ﺑﺎﻳﺴﺘﻲ از ﻧﻮع ﻛﺎراﻛﺘﺮي و ﻳﺎ ﺻﺤﻴﺢ ﺑﺎﺷﻨﺪ‪.‬‬
‫¾ ﻣﻘﺎدﻳﺮ ﻧﺒﺎﻳﺪ ﺗﻜﺮاري ﺑﺎﺷﻨﺪ‪.‬‬
‫¾ ﺑﺮاي ﻫﺮ ‪ case‬ﻣﻲ ﺗﻮاﻧﻴﻢ ﻳﻚ ﻳﺎ ﭼﻨﺪ دﺳﺘﻮر داﺷﺘﻪ ﺑﺎﺷﻴﻢ‪.‬‬
‫¾ در ﻫﻨﮕﺎم اﺟﺮا‪ ،‬ﺑﻪ ﻣﺤﺾ ﺑﺮاﺑﺮ ﺷﺪن ﺑﺎ ﻫﺮ ﻳﻚ از ﺣﺎﻻت‪ ،‬ﻋﻼوه ﺑﺮ اﺟﺮاي ﻋﺒﺎرت ]ﻫﺎي[ ﻣﺘﻨﺎﻇﺮ‪ ،‬ﺑﻘﻴﻪ ﻋﺒﺎرات‬
‫‪ case‬ﻫﺎي ﺑﻪ دﻧﺒﺎل آن ﻧﻴﺰ اﺟﺮا ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬
‫¾ اﮔﺮ ﻣﻘﺪار ﻋﺒﺎرت ﺑﺎ ﻫﻴﭻ ﻳﻚ از ﻣﻘﺎدﻳﺮ )‪ (value‬ﺑﺮاﺑﺮ ﻧﺒﺎﺷﺪ‪ ،‬ﮔﺰﻳﻨﻪ ﻣﺮﺑﻮط ﺑﻪ ﺑﻨﺪ ﭘﻴﺶ ﻓﺮض )‪ (default‬اﺟﺮا‬
‫ﻣﻣﻲ ﺷﻮد‪.‬‬

‫ ﻧﺎﻧﺎم آن‬، ‫ﺑﺨﻮاﻧﺪ‬
‫ﺳﻪ ارا ﻛﻪ ﺨ اﻧﺪ‬
‫ﻳﻚ ﺗﺎ ﻪ‬
‫ﻛﺪام از اﻋﺪاد ﻚ‬
‫ﺑﺮﻧﺎﻣﻪ اي ﻨﺑﻨﻮﻳﺴﻴﻢ ﻛﻪ ﻫﻫﺮ ﻛﺪا‬
‫ﺧﻮاﻫﻴﻢ ﻧﺎ ﻪ‬
‫ ﻣﻲ ﺧ اﻫ‬: ‫ﻣﺜﺎل‬
.‫ﻋﺪد را ﭼﺎپ ﻧﻤﺎﻳﺪ‬
/* P4.4 switch statement */
#include
#i l d <stdio.h>
tdi h
main()
{
int n;
printf(“Enter
p ( a number (
(1 – 3)
) : “);
)
scanf(“%d” , &n);
switch (n) {
case 1 : printf(“One\n”);
case 2 : printf(“Two\n”);
case 3 : printf(“Three\n”);
default : printf(“Other\n”); }
}
Running program:
Enter a number (1 – 3) : 2
Two
Three
Other

‫ – اداﻣﻪ‬switch ‫ ﻋﺒﺎرت ﻛﻨﺘﺮﻟﻲ‬-2
‫ ﺑﺎﻳﺪ از دﺳﺘﻮر‬،‫ ﺧﺎﺗﻤﻪ ﻳﺎﺑﺪ و ﺑﻘﻴﻪ ﻋﺒﺎرات ﺑﻪ دﻧﺒﺎل آن اﺟﺮا ﻧﺸﻮد‬switch ‫ دﺳﺘﻮر‬،case ‫ ﻋﺒﺎرات ﻣﺘﻨﺎﻇﺮ ﺑﺎ ﻳﻚ‬/ ‫ﺑﺮاي اﻳﻨﻜﻪ ﺑﻌﺪ از اﺟﺮاي ﻋﺒﺎرت‬
.‫ اﺳﺘﻔﺎده ﻧﻤﺎﺋﻴﻢ‬break
/* P4.5 switch statement */
#include <stdio.h>
main()
{
int n;
printf(“Enter
p t ( te a number
u be ((1 – 3)
) : “);
);
scanf(“%d” , &n);
switch (n) {
case 1 :
printf(“One\n”);
break;
case 2 :
printf(“Two\n”);
break;
case 3 :
printf(“Three\n”);
break;
default : printf(“Other\n”); }
}
Running program:
Enter a number (
(1 – 3)
) : 2
Two

‫‪ -2‬ﻋﺒﺎرت ﻛﻨﺘﺮﻟﻲ ‪ – switch‬اداﻣﻪ‬

‫اﮔﺮ ﮔﺰﻳﻨﻪ ﻫﺎي ﭼﻨﺪ ‪ case‬ﻫﻤﺎﻧﻨﺪ ﻫﻢ ﺑﺎﺷﻨﺪ‪ ،‬ﻣﻲ ﺗﻮاﻧﻴﻢ آن ‪case‬ﻫﺎ‬
‫را ﺑﺪون ﮔﺰﻳﻨﻪ زﻳﺮ ﻫﻢ و ﻳﺎ ﺑﻪ دﻧﺒﺎل ﻫﻢ ﻧﻮﺷﺘﻪ‪ ،‬ﺗﻨﻬﺎ ﻋﺒﺎرت ‪ /‬ﻋﺒﺎرات‬
‫ﻣﺮﺑﻮط ﺑﻪ آﺧﺮﻳﻦ ‪ case‬را ﺑﻨﻮﻳﺴﻴﻢ‪.‬‬

: ‫ﻣﺜﺎل‬
/* P 4.6 switch statement for similar value */
#include<stdio.h>
#include<conio.h>
main()
{
char ch;
printf(“Enter a letter : “);
ch = getche();
switch (ch) {
case ‘A’ :
case ‘E’ :
case ‘I’ :
case ‘O’ :
case ‘U’ :
case ‘Y’ :
case ‘a’ :
case ‘e’ :
case ‘i’ :
case ‘o’ :
case ‘u’ :
case ‘y’ :
printf(“\n%c is a vowel\n”, ch);
break;
default :
printf(“\n%c is a consonant\n” , ch);
}
}
Running program
C++a Tutorial
Enter letter : E azizjalali@iust.ac.ir 73
E is a vowel
‫‪ -3‬ﻋﺒﺎرات ﺳﺎﺧﺖ ﺣﻠﻘﻪ‬

‫ﺗﻌﺪادي از دﺳﺘﻮرﻫﺎ ‪ /‬ﻋﺒﺎرات ﺑﺮﻧﺎﻣﻪ ﻛﻪ ﻗﺎﺑﻠﻴﺖ اﺟﺮا ﺑﺮاي ﭼﻨﺪ ﻣﺮﺗﺒﻪ را داﺷﺘﻪ ﺑﺎﺷﻨﺪ‪ ،‬ﺣﻠﻘﻪ ﻧﺎﻣﻴﺪه‬
‫ﻣﻲ ﺷﻮﻧﺪ‪ .‬در زﺑﺎن ‪ ،C‬ﻋﺒﺎرات زﻳﺮ را ﺑﺮاي ﺳﺎﺧﺖ ﺣﻠﻘﻪ ﻫﺎ ﺑﻪ ﻛﺎر ﻣﻲ ﺑﺮﻳﻢ‪.‬‬
‫‪ -1‬ﺣﻠﻘﻪ ﻫﺎي ﭘﻴﺶ ﺷﺮط )‪.(while‬‬
‫‪ -2‬ﺣﻠﻘﻪ ﻫﺎي ﭘﺲ ﺷﺮط )‪.(do while‬‬
‫‪ -3‬ﺣﻠﻘﻪ ﻫﺎي ﺑﺎ ﺷﻤﺎرش ﻣﻌﻴﻦ )‪.(for‬‬

‫‪ -3-1‬ﺣﻠﻘﻪ ﭘﻴﺶ ﺷﺮط )‪(while‬‬

‫اﻳﻦ ﻋﺒﺎرات‪ ,‬ﻋﺒﺎراﺗﻲ ﻫﺴﺘﻨﺪ ﻛﻪ ﻣﻴﺘﻮاﻧﻨﺪ از ﺻﻔﺮ ﺗﺎ ‪ n‬ﻣﺮﺗﺒﻪ ﺗﻜﺮار ﺷﻮﻧﺪ‪ .‬ﻗﺎﻟﺐ اﻳﻦ دﺳﺘﻮر ﺑﻪ ﺻﻮرت زﻳﺮ اﺳﺖ‪:‬‬
‫;‪while (condition) statement‬‬
‫و ﻳﺎ در ﺻﻮرﺗﻲ ﻛﻪ ﺑﺨﻮاﻫﻴﻢ ﭼﻨﺪ ﻋﺒﺎرت در ﺣﻠﻘﻪ اﺟﺮا ﺷﻮد‪ ،‬آن ﻫﺎ را در } و { ﻗﺮار ﻣﻲ دﻫﻴﻢ‪ .‬ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﻢ ﻛﻪ‬
‫ﻣﻴﺸﻮد ‪:‬‬
‫اﺟﺮا ﻮ‬ ‫داﺧﻞ ﺣﻠﻘﻪ ﺮ‬
‫ﻋﺒﺎرات ﻞ‬‫ﺷﺮط‪ ،‬ر‬ ‫ن ﺮ‬‫ﺑﻮدن‬
‫درﺳﺖ ﻮ‬‫ﺻﻮرت ر‬
‫ﻲ و درر ﻮر‬
‫ﺑﺮرﺳﻲ‬
‫ﺷﺮط ﺮر‬
‫اﺑﺘﺪا ﺮ‬
‫‪while‬‬ ‫{ )‪(condition‬‬
‫;‪statement1‬‬
‫;‪statement2‬‬
‫……‬
‫}‬

(‫ ﺣﻠﻘﻪ ﭘﻴﺶ ﺷﺮط )ﻣﺜﺎل‬-3-1
/* P4.7 while statement */
#include <stdio.h>
main()
{
int n=0;
while (n < 10) {
printf (“%d\n”,
( %d\n , n);
++n;
}
}
Running program
0
1
2
3
4
5
6
7
8
9

‫‪ -3-2‬ﺣﻠﻘﻪ ﭘﺲ ﺷﺮط )‪(do while‬‬

‫در اﻳﻦ ﺣﻠﻘﻪ ﻫﺎ‪ ،‬اﺑﺘﺪا دﺳﺘﻮرات داﺧﻞ ﺣﻠﻘﻪ اﺟﺮا و ﺳﭙﺲ ﺷﺮط ﺑﺮرﺳﻲ ﻣﻲ ﺷﻮد ﻛﻪ در ﺻﻮرت‬
‫ﺣﻠﻘﻪ‬
‫اوﻟﻴﻦ دﺳﺘﻮر ﺑﻌﺪ ااز ﻠﻘ‬
‫ل ﺑﻪ ا ﻟ‬
‫اﺟﺮا و در ﻏﻏﻴﺮ ااﻳﻦ ﺻﻮرت‪ ،‬ﻛﻛﻨﺘﺮل‬
‫ﻣﺠﺪدا ا ا‬
‫ا‬ ‫ﺣﻠﻘﻪ‬
‫ﺷﺮط‪ ،‬ﻠﻘ‬
‫درﺳﺖ ﺑﻮدن ﺷ ط‬
‫ﻣﻲ رود‪ .‬ﻗﺎﻟﺐ اﻳﻦ دﺳﺘﻮر ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺖ‪:‬‬
‫‪do‬‬ ‫‪statement‬‬ ‫;)‪while (condition‬‬
‫و اﮔﺮ ﺑﻴﺶ از ﻳﻚ ﻋﺒﺎرت در داﺧﻞ ﺣﻠﻘﻪ داﺷﺘﻪ ﺑﺎﺷﻴﻢ‪ ،‬آن ﻫﺎ را در ﻣﻴﺎن } و { ﻗﺮار ﻣﻲ دﻫﻴﻢ‪.‬‬
‫{ ‪do‬‬
‫‪….‬‬
‫‪….‬‬
‫;)‪} while ( condition‬‬ ‫)‬
‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﻢ ﻛﻪ در ﻫﺮ دو ﺣﻠﻘﻪ ﭘﻴﺶ ﺷﺮط و ﭘﺲ ﺷﺮط ﺑﺎﻳﺴﺘﻲ ﺷﺮط ﺧﺮوج از ﺣﻠﻘﻪ را‬
‫ﻣﺤﻘﻖ ﻧﻤﺎﺋﻴﻢ‪ .‬در ﻏﻴﺮ اﻳﻦ ﺻﻮرت ﻳﻚ ﺣﻠﻘﻪ ﺑﻲ ﭘﺎﻳﺎن ﺧﻮاﻫﻴﻢ داﺷﺖ‪.‬‬
‫اﺟﺮا ﻣﻲ ﺷ ﻧﺪ‬
‫ﻣﺮﺗﺒﻪ ا ا‬
‫ﻳﻚ ﺗ ﻪ‬ ‫ﺣﺪاﻗﻞ ﻚ‬
‫ﻠﻘﻪ ﺪاﻗﻞ‬‫ات داﺧﻞ ﺣﻠﻘﻪ‬‫ﻋﺒﺎرات‬
‫ﺷﺮط‪ ،‬ﺎ‬
‫ﻠﻘﻪ ﭘﺲ ﺷ ط‬
‫ﺗﺬﻛﺮ ‪ :‬ددر ﺣﻠﻘﻪ‬
‫ﺗﺬﻛ‬
(‫ ﺣﻠﻘﻪ ﭘﺲ ﺷﺮط )ﻣﺜﺎل‬-3-2
/* P4.8 do-while statement */
#include <stdio.h>
main()
{
int n=0;
do {
printf (“%d\n”,
( %d\n , n);
++n;
} while (n < 10);
}
Running program
0
1
2
3
4
5
6
7
8
9

‫‪ -3-3‬ﺣﻠﻘﻪ ﻫﺎي ﺑﺎ ﺷﻤﺎرش ﻣﻌﻴﻦ )‪(for‬‬

‫ﺷﻮد‪ .‬ﻗﺎﻟﺐ اﻳﻦ‬
‫ﻦ‬ ‫ﺗﻜﺮارر ﻮ‬
‫ﻲ ﺮ‬ ‫ﻣﺮﺗﺒﻪ ﺑﺎﻳﺴﺘﻲ‬
‫ﭼﻨﺪ ﺮ‬
‫ﻢ ﺣﻠﻘﻪ ﭼ‬
‫ﻢ ﻛﻪ ﺑﺪاﻧﻴﻢ‬
‫ﺑﺮﻳﻢ‬
‫ﻲ ﺮ‬‫ﺑﻜﺎر ﻣﻲ‬
‫ﻲ ر‬ ‫ﻦ ﺣﻠﻘﻪ ﻫﺎ ررا ززﻣﺎﻧﻲ‬
‫اﻳﻦ‬
‫دﺳﺘﻮر ﺑﻪ ﺻﻮرت زﻳﺮ اﺳﺖ‪:‬‬
‫) ‪for ( statement1 ; condition ; statement2‬‬ ‫‪loop_statement‬‬
‫ﻋﺒﺎرت ‪ ،1‬ﻋﺒﺎرﺗﻲ اﺳﺖ ﻛﻪ در آﻏﺎز ﻛﺎر )ﻳﻌﻨﻲ در اوﻟﻴﻦ ﻣﺮﺗﺒﻪ ﻛﻪ دﺳﺘﻮر ‪ for‬اﺟﺮا ﻣﻲ ﺷﻮد( اﺟﺮا ﻣﻲ ﺷﻮد‪ .‬اﻳﻦ دﺳﺘﻮر‬
‫را ﻣﻌﻤﻮﻻ ﺑﺮاي ﻣﻘﺪاردﻫﻲ اوﻟﻴﻪ ﺑﻪ ﻣﺘﻐﻴﺮ ﺷﻤﺎرﻧﺪه ﺑﻜﺎر ﻣﻲ ﺑﺮﻳﻢ‪ .‬ﺷﺮط ﻳﺎ ‪ ، condition‬ﻋﺒﺎرﺗﻲ اﺳﺖ ﻣﻨﻄﻘﻲ ﻛﻪ اﮔﺮ‬
‫‪ ،loop_statement‬ﻛﻪ آآن را ﺑﺪﻧﻪ ﺣﻠﻘﻪ ﻣﻲ ﻧﺎﻣﻴﻢ‪ ،‬اﺟﺮا ﻣﻲ ﺷﻮد‪ .‬ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﻋﺒﺎرت‬
‫‪l‬‬ ‫‪t t‬‬ ‫درﺳﺖ ﺑﺎﺷﺪ‪ ،‬ﻋﺒﺎرت ‪t‬‬
‫ﻧﺎدرﺳﺖ ﺷﻮد‪ ،‬اﺟﺮاي دﺳﺘﻮر ﭘﺎﻳﺎن ﻣﻲ ﻳﺎﺑﺪ‪ .‬ﻋﺒﺎرت ‪ ،2‬ﻣﻌﻤﻮﻻ ﺑﺮاي ﺗﻐﻴﻴﺮ ﻣﻘﺪار ﺷﻤﺎرﻧﺪه ﺑﻪ ﻛﺎر ﻣﻲ رود‪ .‬اﻳﻦ ﻋﺒﺎرت‪،‬‬
‫ﻫﺮ ﺑﺎر ﻛﻪ ﺣﻠﻘﻪ ﺗﻜﺮار ﺷﻮد‪ ،‬ﭘﺲ از آﺧﺮﻳﻦ دﺳﺘﻮر ﺣﻠﻘﻪ‪ ،‬اﺟﺮا ﻣﻲ ﺷﻮد‪.‬‬
‫…… ) ‪for ( n = 0 ; n < 10 ; ++n‬‬

‫‪ -3-3‬ﺣﻠﻘﻪ ﺑﺎ ﺷﻤﺎرش ﻣﻌﻴﻦ )ﻣﺜﺎل(‬
‫*‪/‬‬ ‫‪P4.9‬‬ ‫‪for statement‬‬ ‫‪*/‬‬
‫)(‪main‬‬
‫{‬
‫;‪int n‬‬
‫‪for ( n = 0‬‬ ‫‪; n < 10‬‬ ‫;‬ ‫) ‪++n‬‬
‫‪printf (“%d\n”,‬‬
‫;)‪( %d\n , n‬‬
‫}‬
‫‪Running program‬‬
‫‪0‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪5‬‬
‫‪6‬‬
‫‪7‬‬
‫‪8‬‬
‫‪9‬‬
‫ﺑﻨﻮﻳﺴﻴﺪ‪.‬‬
‫ﻴﻦ ررا ﺑ ﻮﻳ ﻴ‬
‫ﺷﻤﺎرش ﻣﻌﻴﻦ‬
‫رش‬ ‫ﻫﺎي ﺑﺑﺎ‬
‫ﺷﺮط و ﺣﻠﻘﻪ ي‬
‫ﻫﺎي ﭘﻴﺶ ﺮ‬
‫ي ﺣﻠﻘﻪ ي‬
‫ﺑﺮاي‬
‫ل ﺑﺮ‬
‫ي ﻣﻌﺎدل‬
‫دﺳﺘﻮرﻫﺎي‬
‫ﻮر‬ ‫ﺗﻤﺮﻳﻦ ‪:‬‬
‫ﺮﻳﻦ‬

‫‪ -3-3‬ﺣﻠﻘﻪ ﻫﺎي ﺑﺎ ﺷﻤﺎرش ﻣﻌﻴﻦ )اداﻣﻪ(‬

‫ﺗﻤﺮﻳﻦ ‪ :‬دﺳﺘﻮرﻫﺎي ﻣﻌﺎدل ﺑﺮاي ﺣﻠﻘﻪ ﻫﺎي ﭘﻴﺶ ﺷﺮط و ﺣﻠﻘﻪ ﻫﺎي ﺑﺎ ﺷﻤﺎرش ﻣﻌﻴﻦ را ﺑﻨﻮﻳﺴﻴﺪ‪.‬‬
‫]‪for ( statement1 ; condition ; statement2 ) loop statement[s‬‬
‫; ‪statement1‬‬
‫{ ) ‪while ( condition‬‬
‫; ]‪loop_statement[s‬‬
‫; ‪statement2‬‬
‫}‬

‫‪ -3-3‬ﺣﻠﻘﻪ ﺑﺎ ﺷﻤﺎرش ﻣﻌﻴﻦ )اداﻣﻪ(‬

‫در ﻋﺒﺎرت ‪ ،for‬ﺑﻪ ﺟﺎي ﻋﺒﺎرت ‪ 1‬و ﻋﺒﺎرت ‪ 2‬ﻣﻲ ﺗﻮان ﺑﻴﺶ از ﻳﻚ دﺳﺘﻮر ﻧﻮﺷﺖ ﻛﻪ اﻳﻦ ﻋﺒﺎرات‬
‫را ﺑﺎ وﻳﺮﮔﻮل از ﻳﻜﺪﻳﮕﺮ ﺟﺪا ﻣﻲ ﻛﻨﻴﻢ‪ .‬ﻣﺜﺎل‪:‬‬
‫‪for ( n=0 , m=9 ; n<10 ; ++n , --m ) …..‬‬
‫در اﻳﻦ ﻣﺜﺎل‪ ،‬ﻧﺨﺴﺖ ﻋﺪدﻫﺎي ﺻﻔﺮ و ﻧﻪ ﺑﻪ ﻣﺘﻐﻴﺮﻫﺎي ‪ n‬و ‪ m‬واﮔﺬار ﻣﻲ ﺷﻮﻧﺪ‪ .‬ﺳﭙﺲ ﺗﺎ زﻣﺎﻧﻲ‬
‫ﻞ ﺣﻠﻘﻪ‪ ،‬ﺑﺑﻪ ‪n‬‬
‫ﻋﺒﺎرات داﺧﻞ‬
‫ي ﺒر‬ ‫اﺟﺮاي‬
‫ن ﺟﺮ‬‫ﭘﺎﻳﺎن‬
‫ﺷﻮد‪ .‬ﭘﺲ ازز ﭘ ﻳ‬
‫ﻲ ﻮ‬‫ﺗﻜﺮارر ﻣﻲ‬ ‫ﻛﻪ ‪ n‬ﻮﭼ‬
‫ﻛﻮﭼﻜﺘﺮﺮ ازز ‪ 10‬اﺳﺖ ﺣﻠﻘﻪ ﺮ‬
‫ﻳﻜﻲ اﺿﺎﻓﻪ و از ‪ m‬ﻳﻜﻲ ﻛﻢ ﻣﻲ ﺷﻮد‪.‬‬

‫‪ -3-3‬ﺣﻠﻘﻪ ﺑﺎ ﺷﻤﺎرش ﻣﻌﻴﻦ )ﻣﺜﺎل(‬
‫*‪/‬‬ ‫‪P4.10‬‬ ‫‪for statement‬‬ ‫‪*/‬‬
‫)(‪main‬‬
‫{‬
‫; ‪int n, m‬‬
‫) ‪for ( n = 0 , m = 9 ; n < 10 ; ++n , --m‬‬
‫‪printf (“n‬‬
‫‪( n = %d‬‬ ‫‪m = %d\n”,‬‬
‫;)‪%d\n , n , m‬‬
‫}‬
‫‪Running program‬‬
‫‪n‬‬ ‫=‬ ‫‪0‬‬ ‫‪m‬‬ ‫=‬ ‫‪9‬‬
‫‪n‬‬ ‫=‬ ‫‪1‬‬ ‫‪m‬‬ ‫=‬ ‫‪8‬‬
‫‪n‬‬ ‫=‬ ‫‪2‬‬ ‫‪m‬‬ ‫=‬ ‫‪7‬‬
‫‪n‬‬ ‫=‬ ‫‪3‬‬ ‫‪m‬‬ ‫=‬ ‫‪6‬‬
‫‪n‬‬ ‫=‬ ‫‪4‬‬ ‫‪m‬‬ ‫=‬ ‫‪5‬‬
‫‪n‬‬ ‫=‬ ‫‪5‬‬ ‫‪m‬‬ ‫=‬ ‫‪4‬‬
‫‪n‬‬ ‫=‬ ‫‪6‬‬ ‫‪m‬‬ ‫=‬ ‫‪3‬‬
‫‪n‬‬ ‫=‬ ‫‪7‬‬ ‫‪m‬‬ ‫=‬ ‫‪2‬‬
‫‪n‬‬ ‫=‬ ‫‪8‬‬ ‫‪m‬‬ ‫=‬ ‫‪1‬‬
‫‪n‬‬ ‫=‬ ‫‪9‬‬ ‫‪m‬‬ ‫=‬ ‫‪0‬‬
‫ﻴﻦ ررا ﺑ ﻮﻳ ﻴ‬
‫ﺷﻤﺎرش ﻣﻌﻴﻦ‬
‫رش‬ ‫ﻫﺎي ﺑﺑﺎ‬
‫ﺷﺮط و ﺣﻠﻘﻪ ي‬
‫ﻫﺎي ﭘﻴﺶ ﺮ‬
‫ي ﺣﻠﻘﻪ ي‬
‫ﺑﺮاي‬
‫ل ﺑﺮ‬
‫ي ﻣﻌﺎدل‬
‫دﺳﺘﻮرﻫﺎي‬
‫ﻮر‬ ‫ﺗﻤﺮﻳﻦ ‪:‬‬
‫ﺮﻳﻦ‬

‫‪ -4‬ﺣﻠﻘﻪ ﻫﺎي ﺗﻮدرﺗﻮ )‪(Nested Loop‬‬

‫ﺣﻠﻘﻪ ﻫﺎي ﺗﻮدرﺗﻮ ﻫﻨﮕﺎﻣﻲ ﺳﺎﺧﺘﻪ ﻣﻲ ﺷﻮﻧﺪ ﻛﻪ در درون ﻳﻚ ﺣﻠﻘﻪ‪ ،‬ﻳﻚ ﻋﺒﺎرت ﺣﻠﻘﻪ )ﭘﻴﺶ ﺷﺮط‬
‫‪ ،‬ﺣﻠﻘﻪ ﭘﺲ ﺷﺮط و ﻳﺎ ﺣﻠﻘﻪ ﺑﺎ ﺷﻤﺎرش ﻣﻌﻴﻦ‪ ،‬داﺷﺘﻪ ﺑﺎﺷﻴﻢ‪ .‬ﻣﺜﺎل ‪:‬‬
‫‪f‬‬
‫‪for‬‬ ‫‪( i = 0 ; i <= 10 ; ++i‬‬
‫) ‪i‬‬
‫) ‪for ( j = 0 ; j <= 10 ; ++j‬‬
‫‪……..‬‬
‫ن دﻫﺪ‪.‬‬
‫ﻳﺶ ﻧﺸﺎن‬
‫ﺮب ررا روي ﺻﻔﺤﻪ ﻧﻤﺎﻳﺶ‬
‫ول ﺿﺮب‬
‫ﺟﺪول‬
‫ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﺟ‬
‫اي ﺑ ﻮﻳ ﻴ‬
‫ﺑﺮﻧﺎﻣﻪ ي‬
‫ﺮﻳﻦ ‪ :‬ﺑﺮ‬
‫ﺗﻤﺮﻳﻦ‬

‫‪ -4‬ﺣﻠﻘﻪ ﻫﺎي ﺗﻮدرﺗﻮ )اداﻣﻪ(‬

‫ﺗﻤﺮﻳﻦ ‪ :‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﺟﺪول ﺿﺮب را روي ﺻﻔﺤﻪ ﻧﻤﺎﻳﺶ ﻧﺸﺎن دﻫﺪ‪.‬‬
‫‪/* P4.11 Multiplication table */‬‬
‫)(‪main‬‬
‫{‬
‫; ‪int i, j‬‬
‫) ‪for ( i = 0 ; i <= 10 ; ++i‬‬
‫) ‪for ( j = 0 ; j <= 10 ; ++j‬‬
‫; ) ‪printf (“%4d” , i * j‬‬
‫}‬
‫ﻲ دﻫﺪ؟‬
‫ﻧﺸﺎن ﻣﻲ‬
‫روي ﺻﻔﺤﻪ ن‬ ‫ﺿﺮب ررا رو‬
‫ﺟﺪول ﺮ‬
‫ﻲ ول‬‫ﺑﺪرﺳﺘﻲ‬
‫ﻮق ر‬
‫ﺑﺮﻧﺎﻣﻪ ﻓﻮق‬‫آﻳﺎ ﺮ‬


‫‪/* P4.11‬‬
‫‪/‬‬ ‫‪11 Multiplication table */‬‬ ‫‪/‬‬
‫)(‪main‬‬
‫{‬
‫; ‪int i , j‬‬
‫=< ‪for ( i = 0 ; i‬‬‫) ‪< 10 ; ++i‬‬
‫) ‪for ( j = 0 ; j <= 10 ; ++j‬‬
‫; ) ‪printf (“%4d” , i * j‬‬
‫‪printf‬‬
‫\“( ‪i tf‬‬
‫;)”‪(“\n‬‬
‫)”‬
‫}‬
‫آﻳﺎ ﺑﺮﻧﺎﻣﻪ ﻓﻮق ﺑﺪرﺳﺘﻲ ﺟﺪول ﺿﺮب را روي ﺻﻔﺤﻪ ﻧﺸﺎن ﻣﻲ دﻫﺪ؟‬

‫‪/* P4‬‬
‫‪P4.11‬‬‫‪11 Multiplication table */‬‬
‫)(‪main‬‬
‫{‬
‫; ‪int i , j‬‬
‫{ ) ‪for ( i = 0 ; i <= 10 ; ++i‬‬
‫< ‪for ( j = 0 ; j‬‬ ‫) ‪<= 10 ; ++J‬‬
‫; ) ‪printf (“%4d” , i * j‬‬
‫;)”‪printf (“\n‬‬
‫}‬
‫}‬
‫آﻳﺎ ﺑﺮﻧﺎﻣﻪ ﻓﻮق ﺑﺪرﺳﺘﻲ ﺟﺪول ﺿﺮب را روي ﺻﻔﺤﻪ ﻧﺸﺎن ﻣﻲ دﻫﺪ؟ ﺑﻠﻲ‬

‫‪ -5‬دﺳﺘﻮرﻫﺎي ﭘﺮش‬
‫ﺑﺮﻧﺎﻣﻪ ررا ﺑﻲ‬
‫اﺟﺮاي ﺑﺮ‬
‫ﻴﺮ ﺟﺮ ي‬
‫ﻲ ﻫﺴﺘﻨﺪ ﻛﻪ ﻣﺴﻴﺮ‬
‫ﻋﺒﺎراﺗﻲ‬
‫دﺳﺘﻮرﻫﺎ ‪ /‬ﺒ ر‬
‫ﭘﺮش‪ ،‬ﻮر‬‫دﺳﺘﻮرﻫﺎي ﭘﺮش‬
‫ﻮر ي‬
‫ﻫﻴﭻ ﺷﺮﻃﻲ ﺗﻐﻴﻴﺮ ﻣﻲ دﻫﻨﺪ‪ .‬اﻳﻦ ﻋﺒﺎرات ﺑﻪ ﺷﺮح زﻳﺮ ﻣﻲ ﺑﺎﺷﻨﺪ‪.‬‬
‫دﺳﺘﻮر ﺟﻬﺶ )‪.((goto‬‬ ‫‪ -1‬د ﺘ‬
‫‪ -2‬دﺳﺘﻮر ﺑﺮش‪/‬ﻗﻄﻊ )‪.(break‬‬
‫‪.(continue‬‬‫‪i‬‬ ‫‪ -3‬دﺳﺘﻮر اداﻣﻪ )‬
‫‪ -4‬دﺳﺘﻮر ﺑﺎزﮔﺸﺖ )‪.(return‬‬


‫ﺷﺮط‪ ،‬ﻣﺠﻤﻮع‬
‫ﭘﻴﺶ ﺷ ط‬
‫ﺣﻠﻘﻪ ﺶ‬ ‫ﻋﺒﺎرت ﻠﻘ‬
‫ﻛﻤﻚ ﺎ ت‬‫ﺑﺮﻧﺎﻣﻪ ااي ﺑﻨﻮﻳﺴﻴﺪ ﻛﻛﻪ ﺑﻪ ﻛ ﻚ‬
‫‪ -1‬ﻧﺎ‬
‫ﻋﺪدﻫﺎي ﻛﻮﭼﻜﺘﺮ از ‪ 100‬را ﻛﻪ ﺑﺮ ‪ 7‬ﺑﺨﺶ ﭘﺬﻳﺮ ﺑﺎﺷﻨﺪ را ﻧﻤﺎﻳﺶ دﻫﺪ‪.‬‬
‫‪ -2‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻳﻜﺼﺪ ﻋﺪد ﺻﺤﻴﺢ را از ورودي ﺧﻮاﻧﺪه‪،‬‬
‫ﻣﻴﺎﻧﮕﻴﻦ‪ ،‬ﺑﺰرﮔﺘﺮﻳﻦ و ﻛﻮﭼﻜﺘﺮﻳﻦ آن ﻫﺎ را ﭼﺎپ ﻧﻤﺎﻳﺪ‪.‬‬
‫‪ -3‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ دوﻣﻴﻦ ﻛﻮﭼﻜﺘﺮﻳﻦ را از ﻣﻴﺎن ﻳﻜﺼﺪ ﻋﺪد‬
‫ورودي ﺻﺤﻴﺢ ﻛﻪ ﺧﻮاﻧﺪه ﻣﻲ ﺷﻮد را ﭼﺎپ ﻧﻤﺎﻳﺪ‪.‬‬
‫‪ -4‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻓﺎﻛﺘﻮرﻳﻞ ﻋﺪد ‪ 7‬را ﻣﺤﺎﺳﺒﻪ و ﻧﻤﺎﻳﺶ دﻫﺪ‪.‬‬

‫ﺗﻤﺮﻳﻦ ﭘﺎﻳﺎن ﻓﺼﻞ)اداﻣﻪ(‬

‫‪ -4‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﺑﻪ ﻛﻤﻚ ﺣﺮف ﺳﺘﺎره‪ ،‬اﺷﻜﺎل زﻳﺮ را ﭼﺎپ ﻧﻤﺎﻳﺪ‪.‬‬
‫*‬
‫**‬
‫***‬
‫****‬
‫*‬
‫***‬
‫*****‬
‫********‬

‫ﻓﺼﻞ ﭘﻨﺠﻢ‬
‫ﺗﻮاﺑﻊ‬
‫)‪(Functions‬‬

‫ﺗﻌﺮﻳﻒ ﺗﺎﺑﻊ ‪ :‬ﺗﺎﺑﻊ‪ ،‬ﺑﺮﻧﺎﻣﻪ ﻫﺎي ﻛﻮﭼﻜﻲ ﻫﺴﺘﻨﺪ ﻛﻪ ﺑﺮاي اﻧﺠﺎم ﻛﺎري وﻳﮋه ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬
‫ﻳﻚ ﺗﺎﺑﻊ ﻣﻴﺘﻮاﻧﺪ ﭼﻨﺪ ﻣﻘﺪار وروردي در زﻣﺎن ﻓﺮاﺧﻮاﻧﻲ داﺷﺘﻪ و ﻧﻴﺰ ﻣﻴﺘﻮاﻧﺪ ﻳﻚ ﻣﻘﺪار را در‬
‫ﻫﺎ ﺑﺮ دو ﻧﻮع ﻫﺴﺘﻨﺪ ‪:‬‬
‫داﺷﺘﻪ ﺎﺑﺎﺷﺪ‪ .‬ﺎﺗﺎﺑﻊ ﺎ‬
‫ﭘﺎﻳﺎن در ﺧﺮوﺟﻲ ا‬
‫ﻫﻨﮕﺎم ﺎ ﺎ‬
‫ﮕﺎ‬
‫‪ -1‬ﺗﻮاﺑﻊ ﻛﺘﺎﺑﺨﺎﻧﻪ اي ‪ :‬ﻛﻪ از ﭘﻴﺶ آﻣﺎده ﺷﺪه اﻧﺪ‪ .‬اﻳﻦ ﺗﺎﺑﻊ ﻫﺎ ﺗﻮﺳﻂ ﺗﻮﻟﻴﺪ ﻛﻨﻨﺪﮔﺎن ﻣﺘﺮﺟﻢ ‪ c‬و‬
‫ﻳﺎ ﻧﺮم اﻓﺰار ﻧﻮﻳﺴﺎن دﻳﮕﺮ ﻧﻮﺷﺘﻪ و ﺗﻮﻟﻴﺪ ﻣﻲ ﮔﺮدد‪ .‬از ﺟﻤﻠﻪ ﺗﻮاﺑﻊ ﻛﺘﺎﺑﺨﺎﻧﻪ اي ﻣﻴﺘﻮاﻧﻴﻢ ‪،scanf‬‬
‫‪ sqrt ،getche ،printf‬و از اﻳﻦ دﺳﺖ را ﻧﺎم ﺑﺮد‪.‬‬
‫‪ -2‬ﺗﻮاﺑﻊ ﻧﻮﺷﺘﻪ ﺷﺪه ﺗﻮﺳﻂ ﻛﺎرﺑﺮ ‪ :‬اﻳﻦ ﺗﻮاﺑﻊ ﺗﻮﺳﻂ ﻛﺎرﺑﺮان ﺑﺮاي اﻧﺠﺎم ﻛﺎرﻫﺎي ﺧﺎص ﺧﻮد‪،‬‬
‫ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬

: ‫ﻓﺮﻣﺖ ﺗﺎﺑﻊ‬
return_type Function_Name ([argument_type argument][,…])
{
statements;
}
: ‫ﻣﺜﺎل‬
int sum ( int x, int y)

{
return x + y;
}

‫ﺗﺬﻛﺮ ‪:‬‬
‫اﮔﺮ ﺗﺎﺑﻊ ﺑﻌﺪ از ﺗﺎﺑﻊ ‪ main‬ﺗﻌﺮﻳﻒ ﺷﻮد‪ ،‬ﺑﺎﻳﺴﺘﻲ ﻳﻚ‬
‫‪) Prototype‬در واﻗﻊ ﺧﻂ اول ﺗﺎﺑﻊ( را ﺑﻌﺪ از ‪ include‬در ﻣﺘﻦ‬
‫ﻴﻢ‪.‬‬
‫ﻗﺮارر دﻫﻴﻢ‬
‫ﺑﺮﻧﺎﻣﻪ ﺮ‬
‫ﺑﺮ‬
‫ﻧﻮﺷﺘﻦ‬
‫ﻧﻴﺎزي ﺑﻪ ﻧ ﺷ‬
‫ﺷﻮد‪ ،‬ﻧ ﺎ‬ ‫ﺗﺎﺑﻊ ‪ main‬ﻧ ﺷ‬
‫ﻧﻮﺷﺘﻪ ﺷ‬ ‫ﻗﺒﻞ ااز ﺗﺎ‬
‫ﺗﺎﺑﻊ ﻗ ﻞ‬
‫اﮔﺮ ﺗﺎ‬
‫اﮔ‬
‫‪) Prototype‬در واﻗﻊ ﺧﻂ اول ﺗﺎﺑﻊ( در ﻣﺘﻦ ﺑﺮﻧﺎﻣﻪ ﻧﺪارﻳﻢ‪.‬‬

،‫ ﻧﻮﺷﺘﻪ ﻣﻴﺸﻮد‬main ‫ وﻗﺘﻲ ﺗﺎﺑﻊ ﺑﻌﺪ از ﺗﺎﺑﻊ‬: 5-1 ‫ﺑﺮﻧﺎﻣﻪ‬
.‫ ﺗﺎﺑﻊ ﻧﻮﺷﺘﻪ ﺷﻮد‬prototype ‫ﺑﺎﻳﺴﺘﻲ‬
/* P5.1 User_Defined function */
#include<stdio.h>
int sum(int x, int y);
main()
{
int a, b;
do {
printf(“\nEnter a & b : “);
scanf(“%d %d”, &a, &b);
printf(“a + b = %d\n”, sum(a, b));
} while (a);
}
int sum(int x, int y)

{
return x + y ;
}
:5-1 ‫اﺟﺮاي ﺑﺮﻧﺎﻣﻪ‬

Enter a & b : 12 28
a + b = 40
Enter a & b : 2000 3210

a + b = 5210
Enter a & b : 0 5
a + b = 5

: 5-2 ‫ﺑﺮﻧﺎﻣﻪ‬
/* P5.2 User_Defined function ver2 */
#include<stdio.h>
int sum(int x, int y);
main()
{
int a, b;
do {
printf(“\nEnter a & b : “);
scanf(“%d
scanf( %d %d”
%d , &a,
&a &b);
sum (a , b);
} while (a);
}
int sum(int x, int y)

{
printf (“a + b = %d\n” , x + y);
}


Enter a & b : 12 8
a + b = 20
Enter a & b : 234 615

a + b = 849
Enter a & b : 0 2
a + b = 2

#include<stdio.h>
fun (int q);
int main()
{
int p=100;
p 100;
printf(“\np1 = %d\n“, p);

fun(p);
printf(“p4 = %d\n”, p);
return
t 0
0;
}
fun (int q)
{
printf (“p2 = %d\n” , q);
q = 333;
printf(“p3 = %d\n”, q);
}

‫اﺟﺮاي ﺑﺮﻧﺎﻣﻪ ‪:5-3‬‬

‫‪p1‬‬ ‫=‬ ‫‪100‬‬
‫‪p2‬‬ ‫=‬ ‫‪100‬‬
‫‪p3‬‬ ‫=‬ ‫‪333‬‬
‫‪p4‬‬
‫‪p‬‬ ‫=‬ ‫‪100‬‬
‫ﺗﻤﺮﻳﻦ‪ : 1‬ﺗﺎﺑﻌﻲ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻳﻚ ﻛﺎراﻛﺘﺮ را ﮔﺮﻓﺘﻪ‪ ،‬در ﺻﻮرﺗﻲ ﻛﻪ ﻛﺎراﻛﺘﺮ ﮔﺮﻓﺘﻪ ﺷﺪه ﻳﻚ ﺣﺮف ﺑﺰرگ ‪A‬‬
‫ﺗﺎ ‪ Z‬ﺑﺎﺷﺪ‪ ،‬ﻣﻌﺪل ﻛﻮﭼﻚ آن را ﺑﺮﮔﺮداﻧﺪه و در ﻏﻴﺮ اﻳﻦ ﺻﻮرت ﺧﻮد ﻛﺎراﻛﺘﺮ را ﺑﺮﮔﺮداﻧﺪ‪.‬‬
‫ﺗﻤﺮﻳﻦ‪ : 2‬ﺗﺎﺑﻌﻲ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻳﻚ ﻛﺎراﻛﺘﺮ را ﮔﺮﻓﺘﻪ‪ ،‬در ﺻﻮرﺗﻲ ﻛﻪ ﻛﺎراﻛﺘﺮ ﮔﺮﻓﺘﻪ ﺷﺪه رﻗﻢ ﺑﺎﺷﺪ‪ ،‬ﻣﻘﺪار‬
‫ﺑﺮﮔﺮداﻧﺪ‪.‬‬
‫ﻣﻘﺪار ‪ False‬ﺑ ﮔ داﻧﺪ‬‫ﺻﻮرت ﻣﻘﺪا‬
‫‪ True‬و ددر ﻏﻏﻴﺮ اﻳﻦ ﺻﻮ ت‬

‫• ﭼﮕﻮﻧﻪ ﺑﺼﻮرت ‪ Pass by Ref.‬ﻳﻚ ﺗﺎﺑﻊ را ﻓﺮاﺧﻮاﻧ‬

‫ﻓﺮاﺧﻮاﻧﻲ ﻛﻨﻴﻢ؟‬
‫ﺑﻪ ﻋﺒﺎرت دﻳﮕﺮ داده ﻫﺎﺋﻲ را ﻛﻪ ﺑﻪ ﺗﺎﺑﻊ ﻣﻲ ﻓﺮﺳﺘﻴﻢ در ﻫﻨﮕﺎم‬
‫ﺑﺎزﮔﺸﺖ ﻣﻘﺎدﻳﺮ ﺧﻮد را از ﭘﺎراﻣﺘﺮﻫﺎي ﻣﺘﻨﺎﻇﺮ ﺑﮕﻴﺮﻧﺪ؟‬
‫ارﺳﺎل ﻛﻛﻨﻴﻢ‪ .‬ﺑﻪ‬

‫ﻏﺎﻟﺐ آآدرس ا ﺎل‬
‫ﻫﺎ ارا در ﻏﺎﻟ‬
‫داده ﺎ‬
‫اﻳﻨﻜﺎر ﺎﺑﺎﻳﺴﺘﻲ ا‬ ‫• ا‬
‫ﺑﺮاي ا ﻜﺎ‬
‫ﻣﺜﺎل ﺑﻌﺪ ﺗﻮﺟﻪ ﻧﻤﺎﺋﻴﺪ‪.‬‬
‫ﻊ ‪ main‬ﺮ‬
‫ﺗﻌﺮﻳﻒ ﺷﺪه اﺳﺖ‪.‬‬ ‫ﻗﺒﻞ ازز ﺗﺎﺑﻊ‬
‫ﺗﺎﺑﻊ ﻞ‬
‫ﻣﺜﺎل ﺑﻌﺪ‪ ،‬ﻊ‬
‫در ل‬ ‫• ﺗﺬﻛﺮﺮ ‪ :‬ر‬
• #include<stdio.h>
• int swap(int &a , int &b)

• {
• int temp=a;
• a = b;
• b = temp;
t
• return 0;
• }
• main()
• {
• int x=100, y = 200;
• printf("x = %d y = %d\n",x , y);
• swap(x , y);
• printf("x = %d y = %d\n",x , y);
• }


.‫ ﺳﺮﺗﺎﺳﺮي ﺗﻌﺮﻳﻒ ﻛﻨﻴﻢ‬/ Global ‫• ﻣﻴﺘﻮاﻧﻴﻢ ﻣﺘﻐﻴﺮﻫﺎ را ﺑﺼﻮرت‬

#include<stdio.h>
int swap();
int x , y;
main()
{
x=100; y = 200;
printf("x = %d y = %d\n",x , y);
swap();
printf("x = %d y = %d\n",x , y);
}
int swap()
{
int temp=x;
x = y;
y = temp;
return 0;
}

: 5-4 ‫ ﺑﺮﻧﺎﻣﻪ‬: (Recursive) ‫ﺗﻮاﺑﻊ ﺑﺎزﮔﺸﺘﻲ‬
#include<stdio.h>
Double fact (int n);
int main()
{
int num = 1;
while (num) {
printf(“\nEnter a number < 0 for quit > : “);
scanf(%d”, &num);
printf(“%d! = %.0f\n”, num, fact(num)); }
return
t 0
0;
}
Double fact (int n)

{
if (n <= 1)
return 1;
else
return n * fact(n – 1);
}


Enter a number < 0 for quit > : 5
5! = 120
Enter a number < 0 for q

quit > : 8
8! = 40320

14! = 87178291200

0! = 1

‫روش ﻛﺎر در ﺗﻮاﺑﻊ ﺑﺎزﮔﺸﺘﻲ ‪:‬‬
‫ﺑﺎزﮔﺸﺘﻲ‬
‫ﻣﻘﺪار ﺎ ﮔﺸ‬
‫ﻘ ا‬ ‫ﭘﺎراﻣﺘﺮ‬
‫ﻣﻘﺪار ﺎ ا‬
‫ﻘ ا‬ ‫ﻓﺮاﺧﻮاﻧﻲ‬
‫ﺷﻤﺎره ﻓ اﺧ اﻧ‬
‫ﺷ ﺎ‬
‫)‪4 * fact(3‬‬ ‫‪4‬‬ ‫‪1‬‬
‫)‪3 * fact(2‬‬ ‫‪3‬‬ ‫‪2‬‬
‫)‪2 * fact(1‬‬ ‫‪2‬‬ ‫‪3‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪4‬‬

‫ﺗﻤﺮﻳﻦ در ﻛﻼس ‪ :‬ﺗﺎﺑﻌﻲ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻳﻚ ﻋﺪد ﺻﺤﻴﺢ را ﮔﺮﻓﺘﻪ و ﺑﺪون اﺳﺘﻔﺎده از‬
‫آراﻳﻪ‪ ،‬ﻣﻘﺪار دودوﺋﻲ آن را ﭼﺎپ ﻧﻤﺎﻳﺪ‪ .‬اﻳﻦ ﺗﺎﺑﻊ را ﺑﺼﻮرت ﺑﺎزﮔﺸﺘﻲ ﺑﻨﻮﻳﺴﻴﺪ‪.‬ﺑﺮﻧﺎﻣﻪ‬
‫زﻳﺮﺑﺎ ‪ DevC++‬ﺗﺴﺖ ﺷﺪه اﺳﺖ‪.‬‬

‫ اﻳﻦ ﺑﺮﻧﺎﻣﻪ ﺑﺎ‬.‫ ﺗﺎﺑﻌﻲ ﺑﺎزﮔﺸﺘﻲ ﻛﻪ ﻳﻚ ﻋﺪد ﺻﺤﻴﺢ را ﺑﻪ ﻣﺒﻨﺎي دو ﻣﻲ ﺑﺮد‬: ‫ﺗﻤﺮﻳﻦ‬
.‫ اﻳﻦ ﺑﺮﻧﺎﻣﻪ ﺗﻮﺳﻂ داﻧﺸﺠﻮﻳﺎن ﻧﻮﺷﺘﻪ ﺷﻮد‬.‫ ﺗﺴﺖ ﺷﺪه اﺳﺖ‬Dev-C++
#include<stdio.h>
#include<conio.h>
long mabna2 (int no)

{
if (no<=0 )
return 0;
else return ((no % 2)) + ((10 * mabna2(( ((int)) no / 2));
)); }
main()
{
int n;
printf("Enter an integer no : ");
scanf("%d" , &n);
printf("Base of %d is %d",n , mabna2(n));
getch(); }


‫ﺻﻮرﺗﻲ ﻛﻪ ﻛﺎراﻛﺘﺮ ﮔﺮﻓﺘﻪ ﺷﺪه‬ ‫ﺗﺎﺑﻌﻲ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻳﻚ ﻛﺎراﻛﺘﺮ را ﮔﺮﻓﺘﻪ‪ ،‬در ﺻﻮرﺗ‬ ‫‪ -1‬ﺗﺎﺑﻌ‬
‫ﺣﺮف ﺻﺪادار ﺑﺎﺷﺪ ﻣﻘﺪار ﻳﻚ و در ﻏﻴﺮ اﻳﻦ ﺻﻮرت ﻣﻘﺪار ﺻﻔﺮ ﺑﺮﮔﺮداﻧﺪ‪.‬‬
‫‪ -2‬ﺗﺎﺑﻌﻲ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻳﻚ ﻛﺎراﻛﺘﺮ را ﮔﺮﻓﺘﻪ‪ ،‬ﻛﺎراﻛﺘﺮ ﺑﻌﺪي آن را ﺑﺮﮔﺮداﻧﺪ‪.‬‬
‫‪ -3‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﭘﻨﺞ ﻋﺪد را ﺧﻮاﻧﺪه‪ ،‬ﻣﻴﺎﻧﮕﻴﻦ آن ﻫﺎ را ﭼﺎپ ﻧﻤﺎﻳﺪ‪ .‬ﻛﺎر‬
‫اﻧﺠﺎمم‬
‫ﻲ ﺠ‬‫ﺑﻊ اﺻﻠﻲ‬
‫ﻴﻦ درر ﺗﺎﺑﻊ‬
‫ﻣﻴﺎﻧﮕﻴﻦ‬
‫پ ﻴ‬ ‫ﭼﺎپ‬
‫ﺑﻊ و ﻛﺎرر ﭼ‬
‫ﻴﻦ درر ﺗﺎﺑﻊ‬
‫ﻣﻴﺎﻧﮕﻴﻦ‬
‫ﻣﺤﺎﺳﺒﻪ ﻴ‬
‫ﺒ‬ ‫ن ﻋﺪدﻫﺎ و‬ ‫ﺧﻮاﻧﺪن‬
‫ﻮ‬
‫ﺷﻮد‪.‬‬
‫ون اﺳﺘﻔﺎده ازز‬
‫ﮔﺮﻓﺘﻪ و ﺑﺑﺪون‬
‫ﻴﺢ ررا ﺮ‬ ‫‪ p‬ﺑ ﻮﻳ ﻴ‬
‫ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻳﻳﻚ ﻋﺪد ﺻﺤﻴﺢ‬ ‫ﻲ ﺑﺑﻨﺎمم ‪printbit‬‬ ‫‪ -4‬ﺑ‬
‫ﺗﺎﺑﻌﻲ‬
‫آراﻳﻪ‪ ،‬ﻣﻘﺪار دودوﺋﻲ آن را ﭼﺎپ ﻧﻤﺎﻳﺪ‪.‬‬

‫ﻓﺼﻞ ﺷﺸﻢ‬
‫آ اﻳﻪ‬
‫آراﻳﻪ‬
‫)‪(Array‬‬

‫ﺗﻌﺮﻳﻒ آراﻳﻪ‪:‬‬
‫ﺑﻪ ﻣﺠﻤﻮﻋﻪ اي از داده ﻫﺎي ﻫﻢ ﻧﻮع ﻛﻪ زﻳﺮ ﻳﻚ ﻧﺎم ﮔﺮد آﻣﺪه ﺑﺎﺷﻨﺪ‪ ،‬آراﻳﻪ ﮔﻔﺘﻪ ﻣﻲ ﺷﻮد‪.‬‬
‫ﺑﺮاي ﻣﺜﺎل ﺑﻪ ﻣﺠﻤﻮﻋﻪ ﻋﻨﺎﺻﺮ زﻳﺮ‪ ،‬ﻣﺠﻤﻮﻋﻪ ﻣﺘﻐﻴﺮﻫﺎي آراﻳﻪ ‪ ar‬ﮔﻔﺘﻪ ﻣﻲ ﺷﻮد‪.‬‬
‫] [‪ar‬‬ ‫] [‪ar‬‬ ‫] [‪ar[ ] ar[ ] ar‬‬

‫آراﻳﻪ ﻳﻚ ﺑﻌﺪي را ﺑﻪ ﺻﻮرت زﻳﺮ ﻧﻴﺰ ﻣﻲ ﺗﻮان ﻧﺸﺎن داد‪:‬‬
‫] [‪ar‬‬
‫] [‪ar‬‬
‫] [‪ar‬‬
‫] [‪ar‬‬
‫] [‪ar‬‬

‫ﺗﻌﺮﻳﻒ آراﻳﻪ )اداﻣﻪ( ‪:‬‬

‫ﺑﺮاي ﺗﻌﺮﻳﻒ آراﻳﻪ در زﺑﺎن ‪ ،C‬ﻓﺮﻣﺖ زﻳﺮ را ﺑﻪ ﻛﺎر ﻣﻲ ﺑﺮﻳﻢ‪.‬‬
‫‪data_type‬‬ ‫]‪Array_Name [No_of_Elements‬‬
‫;]‪int ar[5‬‬
‫اﻳﻦ ﺗﻌﺮﻳﻒ ﺑﻪ اﻳﻦ ﻣﻌﻨﻲ اﺳﺖ ﻛﻪ آراﻳﻪ ‪ ar‬داراي ‪ 5‬ﻋﻨﺼﺮ ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ اوﻟﻴﻦ ﻋﻨﺼﺮ ﺑﺎ اﻧﺪﻳﺲ ‪ 0‬و‬
‫ﮔﻴﺮﻧﺪ‪.‬‬
‫ﺻﺤﻴﺢ ﻣﻣﻲ ﮔ ﻧﺪ‬
‫ﻣﻘﺎدﻳﺮ ﺻﺤ ﺢ‬
‫ﻋﻨﺎﺻﺮ ﻣﻘﺎدﻳ‬
‫ﻫﻤﮕﻲ ﻋﻨﺎﺻ‬ ‫اﻧﺪﻳﺲ ‪ 4‬ﻣﺸﺨﺺ ﻣﻣﻲ ﮔ دد‬
‫ﮔﺮدد و ﻫﻤﮕ‬ ‫ﻋﻨﺼﺮ ﺑﺎ اﻧﺪﻳ‬
‫آﺧﺮﻳﻦ ﻋﻨﺼ‬
‫آﺧ ﻳﻦ‬
‫]‪ar[0‬‬ ‫]‪ar[1] ar[2‬‬ ‫]‪ar[3‬‬ ‫]‪ar[4‬‬

‫ﻫﺮ ﻋﻨﺼﺮ آراﻳﻪ ﻣﺎﻧﻨﺪ ﻳﻚ ﻣﺘﻐﻴﺮ ﻣﻌﻤﻮﻟﻲ اﺳﺖ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ ﺗﻤﺎم ﻗﻮاﻧﻴﻦ‬
‫ﻣﺮﺑﻮط ﺑﻪ ﻣﺘﻐﻴﺮﻫﺎ‪ ،‬در ﻣﻮرد ﻋﻨﺎﺻﺮ آراﻳﻪ ﻧﻴﺰ ﺻﺎدق اﺳﺖ‪.‬‬
‫ﺑﻨﺎﺑﺮاﻳﻦ ‪:‬‬
‫;‪ar[0] = 25‬‬
‫;]‪b = ar[0‬‬
‫;‪ar[1] = ar[0] * 2‬‬
‫;]‪ar[4] = ar[0] + ar[1‬‬
‫ﻣﻲ ﺗﻮاﻧﻴﻢ در ﻫﻤﺎن ﺑﺨﺶ ﺗﻌﺮﻳﻒ‪ ،‬ﺑﻪ ﻋﻨﺎﺻﺮ آراﻳﻪ ﻣﻘﺪاردﻫﻲ ﻛﻨﻴﻢ‪.‬‬
‫;}‪int ar[6] = { 5, 3, 9, 12, 4, 3‬‬


‫ﺑﺎ اﻳﻦ ﺗﻌﺮﻳﻒ ﺧﻮاﻫﻴﻢ داﺷﺖ‪:‬‬
‫;}‪int ar[5]= { 5, 3, -9, 12, 4‬‬
‫]‪ar[0‬‬ ‫]‪ar[1] ar[2‬‬ ‫]‪ar[3‬‬ ‫]‪ar[4‬‬
‫‪5‬‬ ‫‪3‬‬ ‫‪-9‬‬ ‫‪12‬‬ ‫‪4‬‬


‫در ﺗﻌﺮﻳﻒ آراﻳﻪ و ﻣﻘﺪاردﻫﻲ ﺑﻪ آن ﻣﻲ ﺗﻮان از ﻧﻮﺷﺘﻦ ﺗﻌﺪاد ﻋﻨﺎﺻﺮ آراﻳﻪ ﺧﻮدداري ﻧﻤﻮد‪.‬‬
‫;}‪int ar[]= { 5, 3, -9, 12, 4‬‬
‫]‪ar[0‬‬ ‫]‪ar[1] ar[2‬‬ ‫]‪ar[3‬‬ ‫]‪ar[4‬‬
‫‪5‬‬ ‫‪3‬‬ ‫‪-9‬‬ ‫‪12‬‬ ‫‪4‬‬

/* P6.1 Array */
#include<stdio.h>
void main()
{
int b, a[6] = {5, 3, 9, 12, 4, 3};
printf(“a[3]
printf( a[3] = %d\n”
%d\n , a[3]);
printf(“a[5] = %d\n”, a[5]);
b = a[3];
a[5] = 100;
printf(“b
printf( b = %d\n”
%d\n , b);
printf(“a[5] = %d\n”, a[5]);
}
Running Program:
a[3] = 12
a[5] = 3
b = 12
a[5] = 100

‫آآراﻳﻪ و ﺣﻠﻘﻪ‬
‫اﮔﺮ ﺑﺨﻮاﻫﻴﻢ ﻫﻤﻪ ﻋﻨﺎﺻﺮ آراﻳﻪ را ﭘﺮدازش ﻛﻨﻴﻢ‪ ،‬ﺑﻬﺘﺮ اﺳﺖ آن را در درون ﺣﻠﻘﻪ ﺑﻪ ﻛﺎر ﮔﻴﺮﻳﻢ‪ .‬در‬
‫ﺷﻮد‪..‬‬
‫اﻳﻦ ﺻﻮرت‪ ،‬ﺷﻤﺎرﻧﺪه ﺣﻠﻘﻪ ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ ﻋﻨﻮان اﻧﺪﻳﺲ آراﻳﻪ اﺳﺘﻔﺎده ﺷﻮد‬
‫ﺑﺮﻧﺎﻣﻪ ‪: 6-2‬‬
‫‪/* P6.2 Array & Loops*/‬‬
‫>‪#include<stdio.h‬‬
‫)(‪void main‬‬
‫{‬
‫;}‪int i, a[6] = {5, 3, 9, 12, 4, 3‬‬
‫)‪for (i = 0 ; i <= 5 ; ++i‬‬
‫;)]‪printf(“a[%d] = %d\n”, i , a[i‬‬
‫}‬
‫‪Running Program:‬‬
‫‪a[0] = 5‬‬
‫‪a[1] = 3‬‬
‫‪a[2] = 9‬‬
‫‪a[3] = 12‬‬
‫‪a[4] = 4‬‬
‫‪[5] = 100‬‬
‫]‪a[5‬‬

‫ﺑﺮﻧﺎﻣﻪ ‪ : 6-3‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻋﻼوه ﺑﺮ ﻛﺎر اﻧﺠﺎم ﺷﺪه در ﻣﺜﺎل ﺑﺎﻻ‪ ،‬ﻣﺠﻤﻮع و‬
‫ﻣﻴﺎﻧﮕﻴﻦ آﻧﻬﺎ را ﻧﻴﺰ ﭼﺎپ ﻧﻤﺎﻳﺪ‪.‬‬
‫‪/ P6.3 Array‬‬
‫*‪/‬‬ ‫‪y elements & sum & average*/‬‬
‫‪g /‬‬
‫)(‪void main‬‬
‫{‬
‫;}‪int i, sum=0, a[] = {5, 3, 9, 12, 4, 3‬‬
‫)‪for (i = 0 ; i <= 5 ; ++i‬‬
‫{‬
‫;]‪sum += a[i‬‬
‫;)]‪printf(“a[%d] = %d\n”, i , a[i‬‬
‫}‬
‫‪printf(“\nSum‬‬
‫(‪printf‬‬ ‫”‪\nSum = %d\n‬‬
‫;)‪%d\n , sum‬‬
‫;)‪printf(“Average = %f\n”, sum / i‬‬
‫}‬
‫ﻲ ﻛﻨﺪ؟‬
‫پ ﻣﻲ‬
‫ﭼﺎپ‬
‫درﺳﺖ ررا ﭼ‬
‫ﻧﻈﺮ و ر‬
‫ﻣﻮرد ﺮ‬
‫ﻧﺘﻴﺠﻪ ﻮر‬
‫ﺑﺮﻧﺎﻣﻪ ﺑﺑﺎﻻ ﻴﺠ‬
‫آﻳﺎ ﺑﺮ‬
‫ﻳ‬

(‫ )درﺳﺖ‬: 6-3 ‫ﺑﺮﻧﺎﻣﻪ‬
/* P6.3 Array elements & sum & average*/
#include<stdio.h>
void main()
{
int i, sum=0, a[] = {5, 3, 9, 12, 4, 3};
for (i = 0 ; i <= 5 ; ++i) {
sum +=
+ a[i];
printf(“a[%d] = %d\n”, i , a[i]); }
printf(“Sum = %d\n”, sum);
printf(“Average = %.2f\n”, (float)sum / i);
}
Running Program:
a[0] = 5
a[1] = 3
a[2] = 9
a[3] = 12
a[4] = 4
a[5] = 100
Sum = 36
Average = 6.00
6 00

‫ ﻧﻤﺎﻳﺶ ﻣﻲ دﻫﺪ؟‬/ ‫ ﺑﺮﻧﺎﻣﻪ زﻳﺮ ﭼﻪ ﻛﺎري اﻧﺠﺎم ﻣﻲ دﻫﺪ‬: 6-4 ‫ﺑﺮﻧﺎﻣﻪ‬
/* P6.4 */
#include<stdio.h>
void main()
{
int i, num[10];
for (i = 0 ; i <= 9 ; ++i) {
printf(“num[%d]
printf( num[%d] = ”,
, i);
scanf(“%d”, &num[i]); }
printf(“\n”);
for (i = 0 ; i <= 9 ; ++i)

printf(“%3d”,
i tf(“%3d” num[i]);
[i])
printf(“\n”);
for (i = 9 ; i >= 0 ; --i)

printf(“%3d”, num[i]);
p
printf(“\n”);

: ‫ اﺟﺮاي ﺑﺮﻧﺎﻣﻪ‬: 6-4 ‫ﺑﺮﻧﺎﻣﻪ‬

Running Program:
nam[0] = 12
nam[1] = 9
nam[2] = 6
nam[3] = 7
nam[4] = 11
nam[5] = 15
nam[6] = 43
nam[7] = 80
nam[8] = 1
nam[9]
[9] = 5
12 9 6 7 11 15 43 80 1 5
5 1 80 43 15 11 7 6 9 12

/* P6.5 */
#include<stdio.h>
int fun1(int x, int y);
main()
{
int i , ar[6] = {8,90,34,-75,55,2,};
/*for
/ for (i=0; i<=6 ; ++i)
{
printf("\n%dth No : ",i);
scanf("%d",&ar[i]);
}*/
for (i=0; i<=5 ; ++i)
{
printf("\nAr[%d] = %d",i,ar[i]);
/*printf("\n2 Vahed addition is = %d", fun1(ar[i],2));*/
}
}
int fun1(int x, int y)
{
printf("Input No = %d %d",x , y);
return
t x + y;
}
}
‫ﺑﺮﻧﺎﻣﻪ ﻣﺮﺗﺐ ﻛﺮدن ﻣﻘﺎدﻳﺮ ﻳﻚ آراﻳﻪ ﺑﺎ اﺳﺘﻔﺎده از ارﺳﺎل ﻳﻚ آراﻳﻪ ﺑﻪ ﺗﺎﺑﻊ ﺑﻪ روش‬
(‫ﺷﻮد‬
‫ﻧﻮﺷﺘﻪ ﻮ‬ ‫ن ﻮ‬
‫داﻧﺸﺠﻮﻳﺎن‬
‫ﺠﻮﻳ‬ ‫ﺗﻮﺳﻂ‬‫ﺑﺮﻧﺎﻣﻪ ﻮ‬ ‫ ) ﻳﻦ‬Bubble Sort
‫اﻳﻦ ﺑﺮ‬
#include<stdio.h>
#include<conio.h>
int bubble(int no[ ])
{ int k , j;
for (k=9 ; k>0 ; k--)
for (j=0 ; j<k ; j++)
if (no[j] > no[j+1]) {
int temp = no[j];
no[j] = no [j+ 1];
no[j+1] = temp;
} }
main()
{ int i;
int num[10];
for (i=0 ; i <= 9 ; ++i) {
printf("Enter an integer no for num[%d] : ", i);
scanf("%d"
scanf( %d , &num[i]); }
bubble(num);
for (i=0 ; i <=9 ; i++)
printf("\nnum[%d] = %d", i , num[i]);
getch();
}

‫آراﻳﻪ ﻛﺎراﻛﺘﺮي‪:‬‬
‫آراﻳﻪ ﻛﺎراﻛﺘﺮي آراﻳﻪ اي ﻫﺴﺘﻨﺪ ﻛﻪ ﻋﻨﺎﺻﺮ آراﻳﻪ داراي داده ﻫﺎي ﻛﺎراﻛﺘﺮي ﻣﻲ ﺑﺎﺷﻨﺪ‪ .‬در زﺑﺎن ‪،C‬‬
‫اﻳﻦ آراﻳﻪ ﻫﺎ را ﺑﻪ ﺟﺎي رﺷﺘﻪ ﺑﻪ ﻛﺎر ﻣﻲ ﺑﺮﻳﻢ‪ .‬در اﻳﻦ ﺣﺎﻟﺖ‪ ،‬ﻫﺮ ﻛﺎراﻛﺘﺮ در ﻳﻚ ﻋﻨﺼﺮ آراﻳﻪ ﺟﺎي‬
‫ﻣﻲ ﮔﻴﺮد‪ .‬ﻣﺜﺎل ‪:‬‬
‫;]‪char ar[7‬‬
‫;} ’‪char ar[7] = {‘A’ , ‘l’ , ‘i‬‬
‫]‪ar[0‬‬ ‫]‪ar[1‬‬ ‫]‪ar[2] ar[3] ar[4‬‬ ‫]‪ar[5‬‬ ‫]‪ar[6‬‬
‫‪A‬‬ ‫‪l‬‬ ‫‪i‬‬ ‫‪\0‬‬ ‫?‬ ‫?‬ ‫?‬

‫آراﻳﻪ ﻛﺎراﻛﺘﺮي‪) :‬اداﻣﻪ(‬

‫ي ن‬
‫آن‬ ‫ﻲ ‪) 0‬ﻳ ﻲ‬
‫ﻳﻌﻨﻲ ﻫﻤﻪ ﺑﻴﺑﻴﺖ ﻫﺎي‬ ‫ي ﻛﺪ اﺳﻜﻲ‬‫داراي‬ ‫ﺷﻤﺎره ‪ ، 3‬ر‬
‫ﻛﺎراﻛﺘﺮﺮ ﭘﻮچ ﻛﻪ ر‬ ‫ﻋﻨﺼﺮ ر‬
‫در ﺮ‬ ‫ر‬
‫ﺻﻔﺮ دودوﺋﻲ اﺳﺖ( ﻗﺮار ﻣﻲ ﮔﻴﺮد‪ .‬ﺑﺮﻧﺎﻣﻪ ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﺑﻪ اﻳﻦ ﺻﻔﺮ ﻣﻲ رﺳﺪ ﻣﻴﻔﻬﻤﺪ‬
‫ﻛﻪ ﺑﻪ ﭘﺎﻳﺎن رﺷﺘﻪ رﺳﻴﺪه اﺳﺖ‪ .‬ﺑﻘﻴﻪ ﻋﻨﺎﺻﺮ داراي ﻣﻘﺪار ﻗﺒﻠﻲ ﺧﻮد ﻣﻲ ﺑﺎﺷﻨﺪ‪.‬‬
‫;]‪char ar[7‬‬
‫;} ’‪char ar[7] = {‘A’ , ‘l’ , ‘i‬‬
‫]‪ar[0‬‬ ‫]‪ar[1‬‬ ‫]‪ar[2] ar[3] ar[4‬‬ ‫]‪ar[5‬‬ ‫]‪ar[6‬‬
‫‪A‬‬ ‫‪l‬‬ ‫‪i‬‬ ‫‪\0‬‬ ‫?‬ ‫?‬ ‫?‬

/* P6.5 */
#include<stdio.h>
void main()
()
{
char i, num[10] = {‘F’ , ‘e’ , ‘r’ , ‘d’ , ‘o’ , ‘w’ , ‘s’ , ‘i’ } ;
for (i = 0 ; i <= 9 ; ++i)
printf(“%c = %d\n”, name[i] , name[i]);
printf(“\nName = %s\n”, name);
}
Running Program
F = 70
e = 101
r = 114
d = 100
o = 111
w = 119
s = 115
i = 105
= 0
= 0
Name = Ferdowsi

‫آراﻳﻪ دو ﺑﻌﺪي‪:‬‬
‫ﺗﻌﺪاي ﺳﻄﺮﺮ و‬
‫ي ي‬ ‫داراي‬
‫ﮔﺮﻓﺖ ﻛﻪ ر‬
‫ﻧﻈﺮ ﺮ‬
‫در ﺮ‬
‫ﺟﺪوﻟﻲ ر‬
‫ﻫﻤﭽﻮن و ﻲ‬
‫ﺗﻮان ﭽﻮن‬
‫ﻣﻲ ﻮ ن‬
‫ﺑﻌﺪي ررا ﻲ‬
‫دو ي‬ ‫آراﻳﻪ و‬
‫ر‬
‫ﺗﻌﺪادي ﺳﺘﻮن ﺑﺎﺷﺪ‪.‬‬
‫]‪ar[0][0‬‬ ‫]‪ar[0][1‬‬ ‫]‪ar[0][2‬‬
‫]‪ar[1][0‬‬ ‫]‪ar[1][2‬‬
‫]‪ar[2][0‬‬ ‫]‪ar[2][2‬‬
‫]‪ar[2][1‬‬
‫]‪ar[3][0‬‬ ‫]‪ar[3][2‬‬

‫آراﻳﻪ دو ﺑﻌﺪي‪) :‬اداﻣﻪ(‬

‫{ = ]‪int ar[4][3‬‬
‫‪{15, 6, 13 },{9, 17, 2},‬‬

‫} }‪{4, 5, 4}, {10, 11, 12‬‬
‫]‪ar[0][0‬‬ ‫]‪ar[0][1‬‬ ‫]‪ar[0][2‬‬
‫‪15‬‬ ‫‪6‬‬ ‫‪13‬‬
‫]‪ar[1][0‬‬
‫‪9‬‬ ‫‪17‬‬ ‫‪2‬‬ ‫]‪ar[1][2‬‬
‫]‪ar[2][0‬‬
‫‪4‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫]‪ar[2][2‬‬
‫]‪ar[2][1‬‬
‫]‪ar[3][0‬‬
‫‪10‬‬ ‫‪11‬‬ ‫‪12‬‬ ‫]‪ar[3][2‬‬

‫آراﻳﻪ دو ﺑﻌﺪي‪) :‬اداﻣﻪ(ﻣﻘﺪاردﻫﻲ ﺑﺎﻻ را ﺑﻪ ﺻﻮرت زﻳﺮ ﻧﻴﺰ ﻣﻲ ﺗﻮاﻧﻴﻢ ﺑﻨﻮﻳﺴﻴﻢ‪.‬‬

‫;}‪int ar[4][3] ={15, 6, 13, 9, 17, 2, 4, 5, 4, 10, 11, 12‬‬
‫]‪ar[0][0‬‬ ‫]‪ar[0][1‬‬ ‫]‪ar[0][2‬‬
‫‪15‬‬ ‫‪6‬‬ ‫‪13‬‬
‫]‪ar[1][0‬‬
‫‪9‬‬ ‫‪17‬‬ ‫‪2‬‬ ‫]‪ar[1][2‬‬
‫]‪ar[2][0‬‬
‫‪4‬‬ ‫‪5‬‬ ‫‪4‬‬ ‫]‪ar[2][2‬‬
‫]‪ar[2][1‬‬
‫]‪ar[3][0‬‬
‫‪10‬‬ ‫‪11‬‬ ‫‪12‬‬ ‫]‪ar[3][2‬‬

‫آراﻳﻪ دو ﺑﻌﺪي‪) :‬اداﻣﻪ(‬

‫ﭼﻨﺎﻧﭽﻪ ﺗﻌﺪاد داده ﻫﺎ و ﻋﻨﺼﺮﻫﺎي آراﻳﻪ ﺑﺮاﺑﺮ ﺑﺎﺷﻨﺪ‪ ،‬ﻣﻲ ﺗﻮان از ﻧﻮﺷﺘﻦ ﺗﻌﺪاد ﺳﻄﺮﻫﺎ و‬
‫ﺳﺘﻮن ﻫﺎي آراﻳﻪ ﺧﻮدداري ﻛﺮد‪.‬‬
‫{= ][][‪float x‬‬
‫‪{1.25,‬‬
‫‪{1‬‬ ‫‪25 12.2,‬‬
‫}‪12 2 42.3‬‬‫}‪42 3‬‬
‫}‪{5.6, 4.11, 98.7‬‬
‫;}‬
‫ﺑﺎﺷﺪ‪.‬‬
‫ﺳﻄﺮ و ﺳﻪ ﺳﺘﻮن ﻣﻲ ﺎﺷ‬‫داراي دو ﻄ‬
‫اﻋﺸﺎري ااﺳﺖ ﻛﻛﻪ ا ا‬
‫آراﻳﻪ ااي دو ﺑﻌﺪي و ا ﺸﺎ‬
‫آراﻳﻪ ‪ ،x‬آ ا‬
‫ﻣﺜﺎل‪ ،‬آ ا‬
‫در ااﻳﻦ ﺎل‬
‫ﺑﺮاي دﺳﺘﻴﺎﺑﻲ ﺑﻪ ﻋﻨﺎﺻﺮ آراﻳﻪ دوﺑﻌﺪي‪ ،‬ﻧﺨﺴﺖ ﺑﺎﻳﺪ ﻧﺎم آراﻳﻪ‪ ،‬ﺳﭙﺲ ﺷﻤﺎره ﺳﻄﺮ و ﭘﺲ از آن ﺷﻤﺎره‬
‫ﺳﺘﻮﻧﻲ ﻛﻪ ﻋﻨﺼﺮ در آن ﺟﺎي دارد را ﻧﻮﺷﺖ‪.‬‬
‫; ]‪u = t[2][1‬‬
‫]‪t[1][2‬‬
‫; ‪[ ][ ] = 200‬‬

:(‫آراﻳﻪ دو ﺑﻌﺪي )اداﻣﻪ‬
: ‫ﻣﻘﺪاردﻫﻲ ﺑﻪ ﻋﻨﺎﺻﺮ آراﻳﻪ دو ﺑﻌﺪي از ورودي‬
/*P6.5
/*P6 5 Two_Dimensional
Two Dimensional Array */
#include<stdio.h>
void main()
{
int i, j, ar[4][3];
for (i = 0 ; i <= 3 ; ++i)
for (j = 0 ; j <<= 2 ; ++j) {
printf(“ar[%d][%d] = “, i , j);
scanf(“%d”, ar[i][j]);
…………
…………
}

:(‫آراﻳﻪ دو ﺑﻌﺪي )اداﻣﻪ‬
: ‫ﻣﻘﺪاردﻫﻲ ﺑﻪ ﻋﻨﺎﺻﺮ آراﻳﻪ دو ﺑﻌﺪي از ورودي و ﭼﺎپ ﻣﻘﺎدﻳﺮ‬
/*P6.5 Two_Dimensional Array */
#include<stdio.h>
void main()
{
int i, j, ar[4][3];
for
o ( (i = 0 ; i <= 3 ; ++i)
)
for (j = 0 ; j <= 2 ; ++j)
{
printf(“ar[%d][%d] = “, i , j);
scanf(“%d”,
( , ar[i][j]);
[ ][j]);
}
for (i = 0 ; i <= 3 ; ++i)

for (j = 0 ; j <= 2 ; ++j)
j)
printf(“ar[%d][%d] = %d“, i , j, ar[i][j]);

‫آراﻳﻪ ﭼﻨﺪ ﺑﻌﺪي ‪:‬‬

‫]……[]‪data-type array-name [dimension-1][dimension-2‬‬
‫ﺜﺎل‪:‬‬
‫{=]‪int r[2][3][2‬‬
‫{‬
‫‪{1 2},‬‬
‫‪{1,‬‬ ‫}‪2‬‬
‫‪{3, 4},‬‬
‫}‪{5, 6‬‬
‫‪},‬‬
‫{‬
‫‪{6, 7},‬‬
‫‪{8 9},‬‬
‫‪{8,‬‬ ‫}‪9‬‬
‫}‪{10, 11‬‬
‫;}‬
‫ﻋﻨﺼﺮ ﻣﻲ ﺎﺷ‬
‫‪ 2*3*2=12‬ﻨ‬
‫داراي ‪2*3*2 12‬‬
‫ﻒ ﻛﻛﺮده ااﻳﻢ ﻛﻛﻪ ا ا‬
‫آراﻳﻪ ااي ﺳﻪ ﺑﻌﺪي و ﺻﺤﻴﺢ ﺑﻪ ﻧﺎﻧﺎم ‪ r‬ﺗﺗﻌﺮﻳﻒ‬
‫ﻣﺜﺎل آ ا‬
‫در ااﻳﻦ ﺜﺎل‬

‫ﻧﺤﻮه ارﺳﺎل آراﻳﻪ ﺑﻪ ﺗﺎﺑﻊ‬
‫ﻊ‬ ‫ ﻮ‬- ‫آراﻳﻪ‬
• #include <iostream.h>
• #include <conio.h> ‫ اﻳﻦ ﺑﺮﻧﺎﻣﻪ ﻳﻚ آراﻳﻪ را ﺑﻪ ﻳﻚ‬: ‫ﻣﺜﺎﻟﻲ از ﻧﺤﻮه ارﺳﺎل آراﻳﻪ ﺑﻪ ﺗﺎﺑﻊ‬
• int linearSearch(int array[ ]], int,
int int );
‫آراﻳﻪ ﺟﺴﺘﺠﻮﻮ‬
‫رون ر‬
‫ن ررا درون‬
‫ آن‬،‫ﻦ ﻳﻚ ﻋﺪد‬ ‫ﮔﺮﻓﺘﻦ‬‫ل ﻣﻴﻜﻨﺪ و ﺑﺎ ﺮ‬
‫ﻊ رارﺳﺎل‬
‫ﺗﺎﺑﻊ‬
• main() {
‫ اﻧﺪﻳﺲ آن و‬،‫ در ﺻﻮرت ﭘﻴﺪا ﻛﺮدن ﻣﻘﺪار ورودي در آراﻳﻪ‬.‫ﻣﻴﻜﻨﺪ‬
• const int arraySize = 7;
.‫ را ﺑﺮﻣﻴﮕﺮداﻧﺪ‬-1 ‫در ﻏﻴﺮ اﻳﻨﺼﻮرت ﻣﻘﺪار‬
• int a[ arraySize ]={2,6,4,3,12,10,5};
• int searchKey;
• cout << "Enter integer search key: "; cin >> searchKey;
• int element = linearSearch(a, searchKey, arraySize);

• if ( element != -1 )
• cout << "Found
Found value in element " << element << endl;
• else
• cout << "Value not found" << endl;
• char ch=getch();
• }
•
• int linearSearch(int array[ ] , int key, int sizeOfArray ) {
• for ( int j = 0; j < sizeOfArray; j++ )
• if ( array[ j ] == key ) ‫ﻣﻘﺪار ﺑﺎزﮔﺸﺘﻲ‬
• ret rn jj;
return
• return -1; }

‫‪ – 1‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﺗﻌﺪاد ﺻﺪ ﻋﺪد اﻋﺸﺎري را از ورودي ﺧﻮاﻧﺪه‪ ،‬ﺑﺰرگ ﺗﺮﻳﻦ‪ ،‬ﻛﻮﭼﻚ ﺗﺮﻳﻦ‬
‫و اﻧﺪﻳﺲ ﻣﻮﻗﻌﻴﺖ اﻳﻦ اﻋﺪاد در آآراﻳﻪ را ﭼﺎپ ﻧﻤﺎﻳﺪ‪.‬‬
‫‪ -2‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ دوﻣﻴﻦ ﺑﺰرگ ﺗﺮﻳﻦ را از ﻳﻚ ﻣﺠﻤﻮﻋﻪ ﻋﻨﺎﺻﺮ آراﻳﻪ ﺻﺪ ﻋﻨﺼﺮي ﺻﺤﻴﺢ‬
‫پ ﻧﻤﺎﻳﺪ‪.‬‬
‫ﭼﺎپ‬
‫نﭼ‬‫ﺲ آن‬
‫ﻫﻤﺮاه اﻧﺪﻳﺲ‬
‫ﺷﻮد ررا ﺑﻪ ﺮ‬‫ﻲ ﻮ‬
‫درﻳﺎﻓﺖ ﻣﻲ‬ ‫ي ر‬‫ورودي‬
‫ن ازز ورو‬
‫ﻛﻪ ﻣﻘﺎدﻳﺮﺮ آن‬
‫‪ -3‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻛﺎراﻛﺘﺮﻫﺎي ﺑﺎ ﻛﺪ اﺳﻜﻲ ‪ 0‬ﺗﺎ ‪ 255‬را در ﻳﻚ آراﻳﻪ ‪ 256‬ﻋﻨﺼﺮه ﻗﺮار‬
‫دﻫﺪ و در ﻧﻬﺎﻳﺖ ﻫﺮ ﻋﻨﺼﺮ را ﺑﺎ ﻣﻘﺪارش در ﻫﺮ ﺳﻄﺮ ﭼﺎپ ﻧﻤﺎﻳﺪ‪.‬‬
‫ﭼﺎپ ﻧ ﺎ ﺪ‬
‫ﺿﺮب ارا ﺎ‬‫ﺟﺪول ﺿ‬
‫ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﺪ ل‬
‫ﺑﺮﻧﺎﻣﻪ ااي ﻨ ﺪ‬‫‪ -4‬ﻧﺎ ﻪ‬
‫‪ -5‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻳﻜﺼﺪ ﻋﺪد ﺻﺤﻴﺢ را از ورودي ﺧﻮاﻧﺪه و آن ﻫﺎ را ﺑﻪ ﺻﻮرت ﺣﺒﺎﺑﻲ‬
‫ﻣﺮﺗﺐ و ﭼﺎپ ﻧﻤﺎﻳﺪ‪.‬‬
‫‪ -6‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻳﻜﺼﺪ ﻋﺪد ﺻﺤﻴﺢ را از ورودي ﺧﻮاﻧﺪه و آن ﻫﺎ را ﺑﻪ ﺻﻮرت درﺟﻲ‪-‬‬
‫درﺟﺎ ﻣﺮﺗﺐ و ﭼﺎپ ﻧﻤﺎﻳﺪ‪.‬‬

‫ﻓﺼﻞ ﻫﻔﺘﻢ‬
‫ﺗﻮﻛﺎر ‪ /‬ﻛﺘﺎﺑﺨﺎﻧﻪ اي‬

‫ﺗﻮاﺑﻊ ﺗﻮﻛﺎ‬
‫‪Library Function‬‬

‫ﻓﺎﻳﻞ ﻫﺎﺋﻲ ﻛﻪ ﻣﺘﺸﻜﻞ از ﭘﺮوﻧﺪه ﻫﺎ و ﺗﻮاﺑﻊ ﻛﺎرﺑﺮدي ﻫﺴﺘﻨﺪ‪ ،‬در‬

‫ﻋﺒﺎرﺗﻨﺪ ازز‪:‬‬
‫آن ﻫﺎ ر‬‫ﺗﺮﻳﻦ ن‬
‫ﻣﻬﻢ ﺮ ﻦ‬
‫دارﻧﺪ‪ .‬ﻬﻢ‬
‫وﺟﻮد ر‬‫ﺑﺴﻴﺎر و ﻮ‬
‫ر‬ ‫زﺑﺎن ‪C++‬‬
‫ز ن‬
‫‪stdio.h‬‬ ‫‪ -1‬ورودي ﺧﺮوﺟﻲ اﺳﺘﺎﻧﺪارد‬
‫‪string h‬‬
‫‪string.h‬‬ ‫‪ -2‬رﺷﺘﻪ‬
‫‪math.h‬‬ ‫‪ -3‬ﺗﻮاﺑﻊ رﻳﺎﺿﻲ‬
‫‪stdlib.h‬‬
‫‪dlib h‬‬ ‫‪ -4‬ﻛﺘﺎﺑﺨﺎﻧﻪ اﺳﺘﺎﻧﺪارد‬
‫‪ctype.h‬‬ ‫‪ -5‬ﻧﻮع‬
‫ع ﻛﺎراﻛﺘﺮي‬
‫‪time.h‬‬ ‫‪ -6‬زﻣﺎن‬

‫ﭘﺮوﻧﺪه ﺗﻮاﺑﻊ رﻳﺎﺿﻲ‬
‫ﭘﺮوﻧﺪه ﺗﻮاﺑﻊ رﻳﺎﺿﻲ ﺑﺎ ﻧﺎم ‪ math.h‬وﺟﻮد دارد و ﺣﺎوي ﺗﻮاﺑﻌﻲ ﺑﺮاي ﻋﻤﻠﻴﺎت رﻳﺎﺿﻲ ﻣﻴﺒﺎﺷﺪ‪.‬‬
‫‪-‬ﺗﺎﺑﻊ ﻛﻤﺎن ﻛﺴﻴﻨﻮس‬

‫‪acos(d)Æ‬‬
‫‪( ) d‬‬
‫ﻛﻤﺎﻧﻲ ﻛﻪ ﻛﺴﻴﻨﻮس آن ﻣﻌﻠﻮم اﺳﺖ‪ ،‬ﻣﺤﺎﺳﺒﻪ ﻣﻴﻜﻨﺪ‪ .‬ﻛﺴﻴﻨﻮس ﺑﺎﻳﺴﺘﻲ ﺑﻴﻦ ‪ -1‬و ‪1‬‬
‫‪-‬ﺗﺎﺑﻊ ﻛﻤﺎن ﺳﻴﻨﻮس‬

‫‪asin(d)Æ d‬‬
‫ﻛﻤﺎﻧﻲ ﻛﻪ ﺳﻴﻨﻮس آن ﻣﻌﻠﻮم اﺳﺖ‪ ،‬ﻣﺤﺎﺳﺒﻪ ﻣﻴﻜﻨﺪ‪ .‬ﺳﻴﻨﻮس ﺑﺎﻳﺴﺘﻲ ﺑﻴﻦ ‪ -1‬و ‪1‬‬
‫‪-‬ﺗﺎﺑﻊ ﻛﻤﺎن ﻛﺴﻴﻨﻮس‬

‫‪cos(d) Æ d‬‬
‫‪h(d) Æ d‬‬
‫)‪cosh(d‬‬
‫ﻛﺴﻴﻨﻮس ﭘﺎراﻣﺘﺮ را ﺑﺮﻣﻴﮕﺮداﻧﺪ‪ .‬در ﺗﺎﺑﻊ دوم‪ ،‬ﻛﺴﻴﻨﻮس ﻫﺬﻟﻮﻟﻴﺎﺋﻲ ﭘﺎراﻣﺘﺮ ﻣﺤﺎﺳﺒﻪ‬
‫ﺷﻮد‪.‬‬
‫ﻣﻲ ﺷ‬
‫ﺗﻮاﺑﻊ ﺳﻴﻨﻮس‬
‫‪-‬ﺗ ا‬
‫‪sin(d)Æ d‬‬
‫‪sinh(d) Æ d‬‬
‫ﺳﻴﻨﻮس ﭘﺎراﻣﺘﺮ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪ .‬ﺷﻜﻞ دوم ﺗﺎﺑﻊ ﺑﺮاي ﻣﺤﺎﺳﺒﻪ ﺳﻴﻨﻮس ﻫﺬﻟﻮﻟﻴﺎﺋﻲ‬
‫رود‪.‬‬
‫ﻣﻲ رو‬
‫ﺑﻜﺎر ﻲ‬
‫ﺑ ر‬
‫‪-‬ﺗﺎﺑﻊ ﻛﻤﺎن ﻛﺘﺎﻧﮋاﻧﺖ‬

‫‪atan(d) Æ d‬‬
‫‪t 2(d1 d2) Æ d‬‬
‫)‪atan2(d1,d2‬‬
‫ﻛﻤﺎﻧﻲ ﻛﻪ ﺗﺎﻧﮋاﻧﺖ آن ﻣﻌﻠﻮم اﺳﺖ‪ ،‬ﻣﺤﺎﺳﺒﻪ ﻣﻴﻜﻨﺪ‪ .‬در ﺗﺎﺑﻊ دوم‪ ،‬ﻛﻤﺎن ﺗﺎﻧﮋاﻧﺖ‬
‫ﻣﻴﻜﻨﺪ‪.‬‬ ‫‪ d1/d2‬ا ﺎ‬
‫راﻣﺤﺎﺳﺒﻪ ﻜ‬
‫‪-‬ﺗﺎﺗﺎﺑﻊ ﺣﺪ ﺎﻻ‬
‫ﺑﺎﻻ‬
‫‪ceil(d)Æ d‬‬
‫دﻗﺘﻲ‬
‫ﻛﺮده‪ ،‬آن راا ﺑﻪ ﻋﺪدي دو دﻗﺘ‬
‫ﭘﻴﺪا ﻛ ده‬
‫ﭘﺎراﻣﺘﺮ ارا ﭘ ﺪا‬
‫ﺑﺰرﮔﺘﺮ از ﭘﺎ اﻣﺘ‬
‫ﺻﺤﻴﺢ ﺑﺰ ﮔﺘ‬
‫ﻛﻮﭼﻜﺘﺮﻳﻦ ﻋﺪد ﺻﺤ ﺢ‬
‫ﻛﻮﭼﻜﺘ ﻳﻦ‬
‫ﺗﺒﺪﻳﻞ و ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪ .‬ﻣﺜﺎل‪:‬‬
‫‪ceil(2 3) Æ 3‬‬
‫)‪ceil(2.3‬‬
‫‪-‬ﺗﻮاﺑﻊ ﺗﺎﻧﮋاﻧﺖ‬
‫‪tan(d) Æ d‬‬
‫‪tanh(d) Æ d‬‬
‫ﺗﺎﻧﮋاﻧﺖ ﭘﺎراﻣﺘﺮ را ﻣﺤﺎﺳﺒﻪ ﻣﻲ ﻛﻨﺪ‪ .‬ﺗﺎﺑﻊ دوم ﺑﺮاي ﻣﺤﺎﺳﺒﻪ ﺗﺎﻧﮋاﻧﺖ‬
‫زواﻳﺎ ﺑﺮﺣﺴﺐ‬
‫ﺗﻮاﺑﻊ رﻳﺎﺿﻲ‪ ،‬ا‬‫ﻫﺬﻟﻮﻟﻴﺎﺋﻲ ﺑﻜﺎر ﻣﻲ رود‪ .‬ﭼﻨﺎن ﻛﻪ ﮔﮔﻔﺘﻴﻢ‪ ،‬در ا‬
‫رادﻳﺎن ﻣﻲ ﺑﺎﺷﺪ‪ .‬ﺑﺮاي ﺗﺒﺪﻳﻞ درﺟﻪ ﺑﻪ رادﻳﺎن‪ ،‬ﻓﺮﻣﻮل زﻳﺮ را ﺑﻜﺎر ﻣﻴﺒﺮﻳﻢ‪.‬‬
‫‪r = d * pi / 180‬‬
‫در اﻳﻦ ﻓﺮﻣﻮل‪ r ،‬زاوﻳﻪ ﺑﺮﺣﺴﺐ رادﻳﺎن‪ d ،‬زاوﻳﻪ ﺑﺮﺣﺴﺐ درﺟﻪ و ‪ pi‬ﺛﺎﺑﺖ‬
‫ﭘﻲ ﻣﻲ ﺑﺎﺷﺪ‪ pii .‬ﺑﻪ ﺻﻮرت ﺛﺎﺑﺖ ﻧﻤﺎدﻳﻦ ﺗﻌﺮﻳﻒ ﺷﺪه اﺳﺖ‪ .‬از اﻳﻦ رو‬
‫ﻧﻴﺎزي ﺑﻪ ﺗﻌﺮﻳﻒ دوﺑﺎره آن ﻧﻴﺴﺖ‪.‬‬

‫‪-‬ﺗﺎﺑﻊ ﻗﺪرﻣﻄﻠﻖ اﻋﺸﺎري‬

‫‪( )Æd‬‬
‫)‪fabs(d‬‬
‫ﻗﺪرﻣﻄﻠﻖ اﻋﺸﺎري ﭘﺎراﻣﺘﺮ را ﻣﺤﺎﺳﺒﻪ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫‪-‬ﺗﺎﺑﻊ ﺣﺪ ﭘﺎﺋﻴﻦ‬
‫‪floor(d)Æ d‬‬
‫ﺑﺰرﮔﺘﺮﻳﻦ ﻋﺪد ﺻﺤﻴﺢ ﻛﻮﭼﻜﺘﺮ از ﭘﺎراﻣﺘﺮ را ﭘﻴﺪا ﻛﺮده‪ ،‬آن را ﺑﻪ ﻋﺪدي دو‬
‫ﮔﺮداﻧﺪ‪ .‬ﺜﺎل‬
‫ﺗﺒﺪﻳﻞ و ﺑﺮﻣﻲ ﮔ اﻧ‬
‫دﻗﺘﻲ ﺗ ﻞ‬
‫ﻗ‬
‫‪ceil(2.3) Æ 2.0‬‬
‫‪-‬ﺗﺎﺑﻊ ﺑﺎﻗﻴﻤﺎﻧﺪ اﻋﺸﺎري‬

‫(‬ ‫‪)Æd‬‬
‫)‪fmod(d1,d2‬‬
‫ﺑﺎﻗﻴﻤﺎﻧﺪه ﺗﻘﺴﻴﻢ ‪ d1‬و ‪ d2‬را ﻣﺤﺎﺳﺒﻪ ﻣﻲ ﻛﻨﺪ‪ .‬ﻋﻼﻣﺖ ﺑﺎﻗﻴﻤﺎﻧﺪه ﻫﻤﺎﻧﻨﺪ‬
‫‪ d1‬اﺳﺖ‪.‬‬
‫ﻃﺒﻴﻌﻲ‬ ‫‪--‬ﻟﮕﺎ ﻳﺘ‬

‫ﻟﮕﺎرﻳﺘﻢ ﻃ ﻌ‬
‫‪log(d)Æ d‬‬
‫ﻣﺤﺎﺳﺒﻪ ﻣﻲ ﻛﻛﻨﺪ‪.‬‬
‫ﭘﺎراﻣﺘﺮ راا ﺎ‬
‫ﻟﮕﺎرﻳﺘﻢ ﻃﻃﺒﻴﻌﻲ )در ﺎﭘﺎﻳﻪ ﻧﭙﺮ( ﺎ ا‬
‫ﻟﮕﺎ‬

‫‪-‬ﻟﮕﺎرﻳﺘﻢ در ﭘﺎﻳﻪ ‪10‬‬

‫‪log10(d)Æ d‬‬
‫ﻟﮕﺎرﻳﺘﻢ ﭘﺎراﻣﺘﺮ را در ﭘﺎﻳﻪ ‪ 10‬ﻣﺤﺎﺳﺒﻪ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫‪-‬ﺗﺎﺑﻊ ﺗﻮان‬
‫‪(d1 d2) Æ d‬‬
‫)‪pow(d1,d2‬‬
‫‪ d1‬را ﺑﻪ ﺗﻮان ‪ d2‬رﺳﺎﻧﺪه‪ ،‬ﻧﺘﻴﺠﻪ را ﺑﺮﻣﻴﮕﺮداﻧﺪ‪ .‬اﮔﺮ ‪ d1‬ﺑﺮاﺑﺮ ﺻﻔﺮ ﺑﺎﺷﺪ‪،‬‬
‫‪ d2‬ﺑﺎﻳﺪ ﻋﺪدي ﻣﺜﺒﺖ ﺑﺎﺷﺪ‪ ،‬و اﮔﺮ ‪ d1‬ﻣﻨﻔﻲ ﺑﺎﺷﺪ‪ d2 ،‬ﺑﺎﻳﺪ ﻋﺪدي‬
‫ﺻﺤﻴﺢ ﺑﺎﺷﺪ‪.‬‬

‫‪-‬ﺗﺎﺑﻊ رﻳﺸﻪ دوم‬

‫‪q ( )Æd‬‬
‫)‪sqrt(d‬‬
‫رﻳﺸﻪ دوم ﭘﺎراﻣﺘﺮ را ﻣﺤﺎﺳﺒﻪ ﻣﻴﻜﻨﺪ‪ .‬ﭘﺎراﻣﺘﺮ ﺑﺎﻳﺴﺘﻲ ﻋﺪدي ﻣﺜﺒﺖ ﺑﺎﺷﺪ‪.‬‬
‫‪-‬ﺗﺎﺑﻊ ﻧﻤﺎﺋﻲ‬
‫‪exp(d)Æ d‬‬
‫ﻋﺪد ﻧﭙﺮ ) ‪ ( e = 2.718282‬را ﺑﻪ ﺗﻮان ﭘﺎراﻣﺘﺮ رﺳﺎﻧﺪه‪ ،‬ﻧﺘﻴﺠﻪ را‬
‫ﺷﻮد‪ e ) .‬ﺎﭘﺎﻳﻪ‬
‫ﻣﺤﺎﺳﺒﻪ ﻣﻲ ﺷ‬
‫ﭘﺎراﻣﺘﺮ ﺎ‬
‫اﮔﺎرﻳﺘﻢ ﺎ ا‬
‫ﻛﺎر آآﻧﺘﻲ اﮔﺎ‬
‫ﺑﺮﻣﻴﮕﺮداﻧﺪ‪ .‬ﺎﺑﺎ ااﻳﻦ ﻛﺎ‬
‫ﮕ ا‬
‫ﻟﮕﺎرﻳﺘﻢ ﻃﺒﻴﻌﻲ اﺳﺖ(‪.‬‬

/* P7.1 Mathematical Function */
#include<stdio.h>
#include<math.h>
void main() {
printf("acos(
printf( acos(.5)
5) = %f\n"
%f\n ,acos(.5));
acos( 5));
printf("asin(.5) = %f\n",asin(.5));
printf("atan(.5) = %f\n",atan(.5));
printf("ceil(1.2) = %f\n",ceil(1.2));
printf("cos(1.047198) = %f\n",cos(1.047198));
printf("cosh(.5) = %f\n",cosh(.5));
printf("cot(.5) = %f\n", 1 / tan(.5));
printf("exp(.5) = %f\n",exp(.5));
printf("fabs(-.5) = %f\n",fabs(.5));
printf("floor(1.2)
printf( floor(1.2) = %f\n
%f\n",floor(1.2));
,floor(1.2));
printf("fmod(7.,4.) = %f\n",fmod(7.,4.));
printf("log(1.648721) = %f\n",log(1.648721));
printf("log10(1.648721) = %f\n",log10(1.648721));
printf("pow(2.,3.) = %f\n",pow(2.,3.));
printf("sin(.523599)
i tf(" i ( 523599) = %f\
%f\n",sin(.523599));
" i ( 523599))
printf("sinh(.523599) = %f\n",sinh(.523599));
printf("sqrt(9.) = %f\n",sqrt(9.));
printf("tan(.463648) = %f\n",tan(.463648));
printf("tanh(.463648)
p ( ( ) = %f\n",tanh(.463648));
\ , ( ))
}

‫ﭘﺮوﻧﺪه ﺗﻮاﺑﻊ رﺷﺘﻪ اي‬
‫ﭘﺮوﻧﺪه ﺗﻮاﺑﻊ رﺷﺘﻪ اي ‪ string.h‬اﺳﺖ ﻛﻪ ﺣﺎوي ﺗﻮاﺑﻌﻲ ﺟﻬﺖ ﻋﻤﻠﻴﺎت رﺷﺘﻪ اي ﻣﻴﺒﺎﺷﺪ‪.‬‬
‫‪-‬ﺗﺎﺑﻊ ﻫﺎي ﭘﻴﻮﻧﺪ رﺷﺘﻪ‬

‫‪strcat(s1,s2) Æ p‬‬
‫‪strncat(s1,s2,i) Æ p‬‬
‫در ﺗﺎﺑﻊ اول‪ ،‬رﺷﺘﻪ ‪ s2‬ﺑﻪ ﭘﺎﻳﺎن رﺷﺘﻪ اول ﭘﻴﻮﻧﺪ داده ﻣﻲ ﺷﻮد و ﻧﺸﺎﻧﮕﺮ‪ ،‬ﻧﺸﺎﻧﻲ ‪ s1‬را ﻧﺸﺎن‬
‫ﻣﻴﺪﻫﺪ‪ .‬در ﺗﺎﺑﻊ دوم‪ i ،‬ﻧﺸﺎن دﻫﻨﺪه ﺗﻌﺪاد ﻛﺎراﻛﺘﺮﻫﺎﺋﻲ اﺳﺖ ﻛﻪ از ‪ s2‬ﺑﻪ ‪ s1‬اﻟﺤﺎق ﻣﻲ ﺷﻮد‪.‬‬
‫‪-‬ﺗﻮاﺑﻊ ﺟﺴﺘﺠﻮي ﻛﺎراﻛﺘﺮ در رﺷﺘﻪ‬

‫‪strchr(s,c) Æ p‬‬
‫‪t h( )Æp‬‬
‫)‪strrchr(s,c‬‬
‫در ﺗﺎﺑﻊ اول‪ ،‬اوﻟﻴﻦ ﺑﺎر ﻛﻪ ﻛﺎراﻛﺘﺮ در رﺷﺘﻪ ﭘﻴﺪاﺷﻮد‪ ،‬ﻧﺸﺎﻧﻲ آن در اﺷﺎره ﮔﺮ ‪ p‬ﮔﺬاﺷﺘﻪ ﻣﻲ ﺷﻮد‪.‬‬
‫در ﺗﺎﺑﻊ دوم‪ ،‬آﺧﺮﻳﻦ ﺑﺎر ﻛﻪ ﻛﺎراﻛﺘﺮ در رﺷﺘﻪ ﭘﻴﺪاﺷﻮد‪ ،‬ﻧﺸﺎﻧﻲ آن در اﺷﺎره ﮔﺮ ‪ p‬ﮔﺬاﺷﺘﻪ ﻣﻲ ﺷﻮد‪.‬‬
‫ﺷﻮد‪.‬‬
‫ﻧﺸﺎﻧﮕﺮ ﭘﻮچ ﻣﻲ ﺷ‬
‫ﭘﻴﺪا ﻧﺸﻮد‪ ،‬ﺎ ﮕ‬
‫رﺷﺘﻪ ا‬ ‫ﻛﺎراﻛﺘﺮ در ﺷ‬
‫اﮔﺮ ﻛﺎ اﻛ‬
‫اﮔ‬
‫‪-‬ﺗﺎﺑﻊ ﻫﺎي ﻣﻘﺎﻳﺴﻪ رﺷﺘﻪ‬
‫‪strcmp(s1,s2) Æ i‬‬
‫‪strncmp(s1 s2 i) Æ i‬‬
‫)‪strncmp(s1,s2,i‬‬
‫ﺑﺴﺘﻪ ﺑﻪ اﻳﻦ ﻛﻪ ‪ s1 = s2 ، s1 > s2‬و ﻳﺎ ‪ s1 < s2‬ﺑﺎﺷﺪ‪ ،‬ﻣﻘﺪار ﻣﺜﺒﺖ‪ ،‬ﺻﻔﺮ و‬
‫ﻣﻘﺎﻳﺴﻪ ﻣﻲ‬
‫ﻲ‬ ‫ﻢ ﻳ‬ ‫دوم‪ i ،‬ر‬
‫ﻛﺎراﻛﺘﺮﺮ ازز دوو ررﺷﺘﻪ ﺑﺑﺎ ﻫﻢ‬ ‫ﺑﻊ وم‬
‫ﺷﻮد‪ . .‬درر ﺗﺎﺑﻊ‬
‫ﻲ ﻮ‬‫ﺑﺮﮔﺮداﻧﺪه ﻣﻲ‬ ‫ﻳﻳﺎ ﻣﻨﻔﻲ‬
‫ﻲ ﺑﺮ ﺮ‬
‫رﺷﺘﻪ‬
‫ﺑﺮداري ااز ﺷ‬
‫ﺗﻮاﺑﻊ ﻛﻛﭙﻲ ا‬
‫‪-‬ﺗ ا‬
‫‪strcpy(s1,s2) Æ p‬‬
‫‪strncpy(s1 s2 i) Æ p‬‬
‫)‪strncpy(s1,s2,i‬‬
‫در ﺗﺎﺑﻊ اول‪ ،‬از رﺷﺘﻪ ‪ s2‬در ‪ s1‬ﻛﭙﻲ ﺑﺮداري ﺷﺪه‪ ،‬ﻧﺸﺎﻧﮕﺮ ﻧﺸﺎﻧﻲ ‪ s1‬را ﻧﺸﺎن ﻣﻲ‬
‫دﻫﺪ‪ ..‬در ﺷﻜﻞ دوم ﺗﺎﺑﻊ‪ i ،‬ﻛﺎراﻛﺘﺮ از ‪ s2‬ﺑﻪ ‪ s1‬ﻣﻨﺘﻘﻞ ﻣﻲ ﺷﻮد‪.‬‬

‫‪-‬ﺗﺎﺑﻊ ﻃﻮل رﺷﺘﻪ‬

‫‪strlen(s) Æ i‬‬
‫ﻃﻮل رﺷﺘﻪ )ﺗﻌﺪاد ﻛﺎراﻛﺘﺮﻫﺎي ﺟﺎري رﺷﺘﻪ( را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬‬
‫‪-‬ﺗﻮاﺑﻊ ﺟﺴﺘﺠﻮي رﺷﺘﻪ در رﺷﺘﻪ‬

‫‪strstr(s1,s2) Æ p‬‬
‫ن درر ﻧﺸﺎﻧﮕﺮﺮ ﮔﺬاﺷﺘﻪ‬
‫ﻲ آن‬
‫ﺷﻮد‪ ،‬ﻧﺸﺎﻧﻲ‬ ‫ﻫﻤﺎﻧﻨﺪ ‪ s2‬درر ‪ s1‬ﭘﻴ‬
‫ﭘﻴﺪا ﻮ‬ ‫ي ﻤ‬‫اﮔﺮﺮ ررﺷﺘﻪ اي‬
‫ﻣﻲ ﺷﻮد‪ .‬در ﻏﻴﺮ اﻳﻦ ﺻﻮرت‪ ،‬ﻧﺸﺎﻧﮕﺮ ﭘﻮچ ﻣﻲ ﺷﻮد‪.‬‬

/* P7.2 Mathematical Function */
#include<stdio.h>
#include<string.h>
void main() {
char s1[80] = “Welcome to c “;
char s2[80] = “Programming ! “;
char s3[] = “Welcome to home “;
char *p;
strcat(s1,s2);
puts(s1);
p = strchr(s1
strchr(s1,’m’);
m );
puts(p);
p = strchr(s2,’m’);
printf(“\n%d\n”, strcmp(s1,s3));
printf(“\n%d\n”, strcmp(s3,s1));
printf(“\n%d\n”, strcmp(s1,s3,10));
p p
strcpy(s2,s3);
puts(s2);
strncpy(s2, “This is my school”, 11);
puts(s2);
printf(“\n%d\n\n”, strlen(s3);
p = strstr(s1,
t t ( 1 “c “ pro”);
”)
printf(“%s\n\n” , p);
puts(strtok(s1, “1’)); /*This function split one string to many substring */
}

‫ﺗﻮاﺑﻊ ﻛﺘﺎﺑﺨﺎﻧﻪ اﺳﺘﺎﻧﺪارد )‪(stdlib.h‬‬
‫‪-‬ﺗﺎﺑﻊ رﻫﺎ ﻛﺮدن‬

‫)(‪abort‬‬
‫‪-‬ﺗﺎﺑﻊ ﻫﺎي ﻗﺪر ﻣﻄﻠﻖ‬
‫)‪abs(x‬‬
‫)‪l b (i‬‬
‫)‪labs(i‬‬
‫ﻗﺪرﻣﻄﻠﻖ ﭘﺎراﻣﺘﺮ را ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪ .‬در ﺗﺎﺑﻊ ﻧﺨﺴﺖ‪ ،‬ﭘﺎراﻣﺘﺮ‪ ،‬ﻋﺪدي ﺻﺤﻴﺢ و در ﺗﺎﺑﻊ دوم‪ ،‬ﭘﺎراﻣﺘﺮ‪،‬‬
‫ﻲ ﺑﺑﺎﺷﺪ‪.‬‬
‫ﻴﺢ و ﺑﺑﻠﻨﺪ ﻣﻲ‬
‫ي ﺻﺤﻴﺢ‬‫ﻋﺪدي‬

‫‪-‬ﺗﺎﺑﻊ ﺗﺒﺪﻳﻞ رﺷﺘﻪ ﺑﻪ ﻋﺪدي دو دﻗﺘﻲ‬
‫‪atof(s) Æ d‬‬
‫رﺷﺘﻪ را ﺑﻪ ﻋﺪدي دو دﻗﺘﻲ ﺗﺒﺪﻳﻞ ﻣﻲ ﻛﻨﺪ‪ .‬رﺷﺘﻪ ﺑﺎﻳﺪ از ﻛﺎراﻛﺘﺮﻫﺎي ﻗﺎﺑﻞ ﺗﺒﺪﻳﻞ ﺑﻪ ﻋﺪد دو دﻗﺘﻲ‬
‫)ﻣﺜﻞ ﻛﺎراﻛﺘﺮﻫﺎي ‪ 0‬ﺗﺎ ‪ ( 9‬ﺳﺎﺧﺘﻪ ﺷﺪه ﺑﺎﺷﺪ‪ .‬ﻛﺎر ﺗﺒﺪﻳﻞ ﻫﻨﮕﺎﻣﻲ ﺑﻪ ﭘﺎﻳﺎن ﻣﻲ رﺳﺪ ﻛﻪ ﻛﺎراﻛﺘﺮي‬
‫ل‪:‬‬‫ﻛﺎراﻛﺘﺮﻫﺎ درر ررﺷﺘﻪ ﺑﺑﺎﺷﺪ‪ .‬ﻣﺜﺎل‬
‫ﻳﻦ ر ﺮ‬ ‫ﺟﺰ اﻳﻦ‬
‫‪atof(“2.5meter”) Æ 2.5‬‬
‫‪-‬ﺗﺎﺑﻊ ﺗﺒﺪﻳﻞ رﺷﺘﻪ ﺑﻪ ﻋﺪد ﺻﺤﻴﺢ‬
‫‪atoi(s) Æ i‬‬
‫رﺷﺘﻪ را ﺑﻪ ﻋﺪدي دو دﻗﺘﻲ ﺗﺒﺪﻳﻞ ﻣﻲ ﻛﻨﺪ‪ .‬رﺷﺘﻪ ﺑﺎﻳﺪ از ﻛﺎراﻛﺘﺮﻫﺎي ﻗﺎﺑﻞ ﺗﺒﺪﻳﻞ ﺑﻪ ﻋﺪد دو دﻗﺘﻲ‬
‫ﻛﺎراﻛﺘﺮي‬
‫ﭘﺎﻳﺎن ﻣﻲ رﺳﺪ ﻛﻛﻪ ﻛﺎ اﻛ‬
‫ﻫﻨﮕﺎﻣﻲ ﺑﻪ ﺎ ﺎ‬
‫ﻞ ﮕﺎ‬ ‫ﻛﺎر ﺗﺗﺒﺪﻳﻞ‬
‫ﺑﺎﺷﺪ‪ .‬ﻛﺎ‬
‫ﺷﺪه ﺎﺷ‬ ‫ﻛﺎراﻛﺘﺮﻫﺎي ‪ 0‬ﺗﺎ ‪ ( 9‬ﺎﺧ‬
‫ﺳﺎﺧﺘﻪ ﺷ‬ ‫ﺜﻞ ﻛﺎ اﻛ ﺎ‬
‫)ﻣﺜﻞ‬
‫ﺟﺰ اﻳﻦ ﻛﺎراﻛﺘﺮﻫﺎ در رﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬ﻣﺜﺎل ‪:‬‬
‫(‬ ‫‪) Æ 12‬‬
‫)”‪atoi(“12-8-74‬‬
‫‪-‬ﺗﺎﺑﻊ ﺗﺒﺪﻳﻞ رﺷﺘﻪ ﺑﻪ ﻋﺪد ﺻﺤﻴﺢ ﺑﻠﻨﺪ‬

‫‪( )Æi‬‬
‫)‪atol(s‬‬
‫رﺷﺘﻪ را ﺑﻪ ﻋﺪدي دو دﻗﺘﻲ ﺗﺒﺪﻳﻞ ﻣﻲ ﻛﻨﺪ‪ .‬رﺷﺘﻪ ﺑﺎﻳﺪ از ﻛﺎراﻛﺘﺮﻫﺎي ﻗﺎﺑﻞ ﺗﺒﺪﻳﻞ ﺑﻪ‬
‫ﻋﺪد دو دﻗﺘﻲ )ﻣﺜﻞ ﻛﺎراﻛﺘﺮﻫﺎي ‪ 0‬ﺗﺎ ‪ ( 9‬ﺳﺎﺧﺘﻪ ﺷﺪه ﺑﺎﺷﺪ‪ .‬ﻛﺎر ﺗﺒﺪﻳﻞ ﻫﻨﮕﺎﻣﻲ ﺑﻪ‬
‫ﭘﺎﻳﺎن ﻣﻲ رﺳﺪ ﻛﻪ ﻛﺎراﻛﺘﺮي ﺟﺰ اﻳﻦ ﻛﺎراﻛﺘﺮﻫﺎ در رﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬ﻣﺜﺎل ‪:‬‬
‫‪atol(“12-8-74”) Æ 12L‬‬
‫‪-‬ﺗﺎﺑﻊ ﺧﺮوج‬
‫)‪exit(i‬‬
‫ﺑﺮﻧﺎﻣﻪ را ﺑﻪ ﺻﻮرت ﻃﺒﻴﻌﻲ ﺑﻪ ﭘﺎﻳﺎن ﻣﻲ رﺳﺎﻧﺪ‪ .‬ﭘﺎراﻣﺘﺮ ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﻓﺮاﺧﻮاﻧﻨﺪه‪-‬ﻛﻪ‬
‫ﻣﻌﻤﻮﻻ ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﻣﻲ ﺑﺎﺷﺪ‪ -‬ﺑﺮﮔﺸﺖ داده ﻣﻲ ﺷﻮد‪.‬‬

‫ﺗﺎﺑﻊ ﺗﺼﺎدﻓﻲ‬
‫‪rand() Æ i‬‬
‫ﻫﺮ ﺑﺎر ﻛﻪ ﺗﺎﺑﻊ را ﻓﺮاﺧﻮاﻧﻴﻢ‪ ،‬ﻋﺪدي ﺗﺼﺎدﻓﻲ را ﻛﻪ ﻣﻘﺪار آن ﺻﺤﻴﺢ و ﻏﻴﺮ‬
‫ﮔﺮداﻧﺪ‪.‬‬
‫اﺳﺖ‪ ،‬ﺑﺑﺮﻣﻲ ﮔ داﻧﺪ‬
‫ﻣﻨﻔﻲ ا ﺖ‬‫ﻨﻔ‬

‫ﻓﺎﻳﻞ ﺗﺎﺑﻊ ﻫﺎي زﻣﺎن )‪(time.h‬‬

‫‪-‬ﺗﺎﺑﻊ زﻣﺎن‬
‫‪time(p) Æ i‬‬
‫اﮔﺮ دﺳﺘﮕﺎه داراي ﺳﺎﻋﺖ ﺳﺨﺖ اﻓﺰاري ﺑﺎﺷﺪ‪ ،‬زﻣﺎﻧﻲ را ﻛﻪ آن ﺳﺎﻋﺖ ﻧﺸﺎن ﻣﻲ دﻫﺪ‪ ،‬و در ﻏﻴﺮ اﻳﻦ‬
‫ﺷﻮد‪.‬‬
‫ﻲ ﻮ‬‫ﻣﺤﺎﺳﺒﻪ ﻣﻲ‬
‫ﺒ‬ ‫ﻣﻌﻴﻨﻲ‬
‫ﻲ‬ ‫رﻳﺦ ﻴ‬
‫ﺛﺎﻧﻴﻪ اﺳﺖ و ازز ﺗﺎرﻳﺦ‬
‫ﺐ ﻴ‬ ‫ﺑﺮﺣﺴﺐ‬
‫ن ﺑﺮ‬
‫ﮔﺮداﻧﺪ‪ .‬ززﻣﺎن‬
‫ﺑﺮﻣﻲ ﺮ‬
‫ﻣﻘﺪار ‪ -1‬ررا ﺑﺮ ﻲ‬
‫ر‬ ‫ﺻﻮرت‬
‫ﻮر‬
‫ﻧﺸﺎﻧﮕﺮ از ﻧﻮع ﺻﺤﻴﺢ ﺑﻠﻨﺪ اﺳﺖ ﻛﻪ ﻧﺸﺎﻧﻲ ﻫﻤﻴﻦ زﻣﺎن را داراﺳﺖ‪.‬‬
‫ﺑﻪ ﺷﺘﻪ‬
‫رﺷﺘﻪ‬ ‫زﻣﺎن ﻪ‬
‫ﻞز ﺎ‬‫ﺗﺒﺪﻳﻞ‬
‫‪-‬ﺗﺎﺗﺎﺑﻊ ﺗ ﺪ‬
‫‪ctime(p) Æ s‬‬
‫ﻦ ﻛﺎرر‬
‫ﻲ ﻛﻨﺪ‪ .‬ﺑﺎ اﻳﻦ‬
‫ﻞ ﻣﻲ‬
‫ﺦ و ﺳﺎﻋﺖ ﺗﺒﺪﻳﻞ‬‫ﺗﺎرﻳﺦ‬
‫دارد ازز ﺛﺎﻧﻴﻪ ﺑﻪ ر‬
‫ﻗﺮارر ر‬
‫ن درر ﻧﺸﺎﻧﮕﺮﺮ ﺮ‬
‫ﻲ آن‬
‫ﻲ ررا ﻛﻪ ﻧﺸﺎﻧﻲ‬
‫ززﻣﺎﻧﻲ‬
‫ﺗﺎرﻳﺦ روز و ﺳﺎﻋﺖ ﺑﻪ ﺻﻮرت رﺷﺘﻪ اي ﻫﻤﺎﻧﻨﺪ رﺷﺘﻪ زﻳﺮ ﺑﻪ دﺳﺖ ﻣﻲ آﻳﺪ‪.‬‬
‫‪Sun Jan 01 11:37:13 1995‬‬
‫ﺳﺎل ‪. 1995‬‬
‫ﺛﺎﻧﻴﻪ ﺎل‬
‫ﻘﻪ و ‪ 13‬ﺛﺎﻧ ﻪ‬
‫دﻗﻴﻘﻪ‬
‫ﺳﺎﻋﺖ ‪ 11‬و ‪ 37‬دﻗ‬
‫ژاﻧﻮﻳﻪ‪ ،‬ﺎ ﺖ‬
‫ﻳﻜﺸﻨﺒﻪ ‪ 1‬ژاﻧ ﻪ‬
‫ﻳﻌﻨﻲ ‪ :‬ﻜﺸﻨ ﻪ‬‫ﻨ‬
‫ﻓﺎﻳﻞ ﺗﺎﺑﻊ ﻫﺎي ﻧﻮع ﻛﺎراﻛﺘﺮي )‪(ctype.h‬‬

‫ﻓﺎﻳﻞ ﻧﻮع ﻛﺎراﻛﺘﺮي را زﻣﺎﻧﻲ ﺑﻪ ﻛﺎر ﻣﻲ ﺑﺮﻳﻢ ﻛﻪ ﺑﺨﻮاﻫﻴﻢ ﺑﺮرﺳﻲ ﻧﻤﺎﺋﻴﻢ ﻳﻚ ﻛﺎراﻛﺘﺮ ﭼﻪ ﻧﻮع‬
‫ﻛﺎراﻛﺘﺮي اﺳﺖ‪ :‬ﺣﺮف اﺳﺖ؟ رﻗﻢ اﺳﺖ؟ و ﻳﺎ از ﻧﻮع ﻛﺎراﻛﺘﺮﻫﺎي ﻛﻨﺘﺮﻟﻲ اﺳﺖ؟ و ‪....‬‬
‫‪-‬ﺗﺎﺑﻊ ﺗﻌﻴﻴﻦ اﻳﻨﻜﻪ ﻛﺎراﻛﺘﺮ ﺣﺮﻓﻲ‪-‬رﻗﻤﻲ اﺳﺖ؟‬
‫‪( ) Æ i‬‬
‫)‪iisalnum(c‬‬
‫‪l‬‬
‫اﮔﺮ ﻛﺎراﻛﺘﺮ ﺣﺮف ﻳﺎ رﻗﻢ ﺑﺎﺷﺪ‪ ،‬ﻣﻘﺪار درﺳﺖ )ﻋﺪدي ﻏﻴﺮ ﺻﻔﺮ( و در ﻏﻴﺮ اﻳﻦ ﺻﻮرت‪ ،‬ﻣﻘﺪار‬
‫ﮔﺮداﻧﺪ‪.‬‬
‫ﻲ ﺮ‬‫ﺑﺮﻣﻲ‬
‫ﻧﺎدرﺳﺖ )ﺻﻔﺮﺮ( ﺑﺮ‬
‫ر‬
‫‪-‬ﺗﺎﺑﻊ ﺗﻌﻴﻴﻦ اﻳﻨﻜﻪ ﻛﺎراﻛﺘﺮ ﺣﺮﻓﻲ اﺳﺖ؟‬
‫‪isalpha(c) Æ i‬‬
‫اﮔﺮ ﻛﺎراﻛﺘﺮ ﺣﺮف ﺑﺎﺷﺪ‪ ،‬ﻣﻘﺪار درﺳﺖ )ﻋﺪدي ﻏﻴﺮ ﺻﻔﺮ( و در ﻏﻴﺮ اﻳﻦ ﺻﻮرت‪ ،‬ﻣﻘﺪار ﻧﺎدرﺳﺖ‬
‫)ﺻﻔﺮ( ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬‬

‫‪-‬ﺗﺎﺑﻊ ﺗﻌﻴﻴﻦ اﻳﻨﻜﻪ ﻛﺎراﻛﺘﺮ ﻛﻨﺘﺮﻟﻲ اﺳﺖ؟‬
‫‪iscntrl(c) Æ i‬‬
‫اﮔﺮ ﻛﺎراﻛﺘﺮ ﻛﻨﺘﺮﻟﻲ ﺑﺎﺷﺪ)ﻛﺪ اﺳﻜﻲ آن ﻛﻮﭼﻜﺘﺮ از ‪ 32‬ﻳﺎ ﺑﺮاﺑﺮ ‪ 127‬ﺑﺎﺷﺪ(‪ ،‬ﻣﻘﺪار درﺳﺖ )ﻋﺪدي‬
‫ﻏﻴﺮ ﺻﻔﺮ( و در ﻏﻴﺮ اﻳﻦ ﺻﻮرت‪ ،‬ﻣﻘﺪار ﻧﺎدرﺳﺖ )ﺻﻔﺮ( ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬‬
‫‪-‬ﺗﺎﺑﻊ ﺗﻌﻴﻴﻦ اﻳﻨﻜﻪ ﻛﺎراﻛﺘﺮ رﻗﻤﻲ اﺳﺖ؟‬

‫‪g ( ) Æ i‬‬
‫)‪isdigit(c‬‬
‫اﮔﺮ ﻛﺎراﻛﺘﺮ ﻳﻜﻲ از ﻛﺎراﻛﺘﺮﻫﺎي ‪ 0‬ﺗﺎ ‪ 9‬ﺑﺎﺷﺪ‪ ،‬ﻣﻘﺪار درﺳﺖ )ﻋﺪدي ﻏﻴﺮ ﺻﻔﺮ( و در ﻏﻴﺮ اﻳﻦ‬
‫ﺻﻮرت‪ ،‬ﻣﻘﺪار ﻧﺎدرﺳﺖ )ﺻﻔﺮ( ﺑﺮﻣﻲ ﮔﺮداﻧﺪ‪.‬‬

‫‪-‬ﺗﺎﺑﻊ ﺗﻌﻴﻴﻦ اﻳﻨﻜﻪ ﻛﺎراﻛﺘﺮ ﺣﺮف ﻛﻮﭼﻚ اﺳﺖ؟‬
‫‪islower(c) Æ i‬‬
‫اﮔﺮ ﻛﺎراﻛﺘﺮ ﺣﺮف ﻛﻮﭼﻚ ﺑﺎﺷﺪ )ﻳﻌﻨﻲ ‪ a‬ﺗﺎ ‪ ،(z‬ﻣﻘﺪار درﺳﺖ )ﻋﺪدي ﻏﻴﺮ ﺻﻔﺮ( و در ﻏﻴﺮ اﻳﻦ‬
‫‪-‬ﺗﺎﺑﻊ ﺗﻌﻴﻴﻦ اﻳﻨﻜﻪ ﻛﺎراﻛﺘﺮ ﺣﺮف ﺑﺰرگ اﺳﺖ؟‬

‫‪pp ( ) Æ i‬‬
‫)‪isupper(c‬‬
‫اﮔﺮ ﻛﺎراﻛﺘﺮ ﺣﺮف ﺑﺰرگ ﺑﺎﺷﺪ )ﻳﻌﻨﻲ ‪ A‬ﺗﺎ ‪ ،(Z‬ﻣﻘﺪار درﺳﺖ )ﻋﺪدي ﻏﻴﺮ ﺻﻔﺮ( و در ﻏﻴﺮ اﻳﻦ‬

‫‪-‬ﺗﺎﺑﻊ ﺗﺒﺪﻳﻞ ﺑﻪ ﺣﺮوف ﻛﻮﭼﻚ‬

‫‪tolower(c) Æ i‬‬
‫اﮔﺮ ﻛﺎراﻛﺘﺮ ﻳﻜﻲ از ﺣﺮوف ﺑﺰرگ ) ‪ A‬ﺗﺎ ‪ ( Z‬ﺑﺎﺷﺪ‪ ،‬آن را ﺑﻪ ﺣﺮف ﻛﻮﭼﻚ ﻣﻌﺎدل ﺧﻮد )ﻳﻌﻨﻲ ‪ a‬ﺗﺎ‬
‫‪ (z‬ﺗﺒﺪﻳﻞ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫‪-‬ﺗﺎﺑﻊ ﺗﺒﺪﻳﻞ ﺑﻪ ﺣﺮوف ﻛﻮﭼﻚ‬

‫‪toupper(c) Æ i‬‬
‫اﮔﺮ ﻛﺎراﻛﺘﺮ ﻳﻜﻲ از ﺣﺮوف ﻛﻮﭼﻚ) ‪ a‬ﺗﺎ ‪ ( z‬ﺑﺎﺷﺪ‪ ،‬آن را ﺑﻪ ﺣﺮف ﺑﺰرگ ﻣﻌﺎدل ﺧﻮد )ﻳﻌﻨﻲ ‪ A‬ﺗﺎ‬
‫‪ (Z‬ﺗﺒﺪﻳﻞ ﻣﻣﻲ ﻛﻨﺪ‪.‬‬

‫ﻓﺼﻞ ﻫﺸﺘﻢ‬
‫ﻧﺸﺎﻧﮕﺮ‬
‫ﻧﺸﺎﻧﮕ‬
‫‪Pointer‬‬

‫ﻧﺸﺎﻧﮕﺮ ‪ :‬ﻣﺘﻐﻴﺮي اﺳﺖ ﻛﻪ ﺑﺮاي ﻧﮕﻬﺪاري ﻧﺸﺎﻧﻲ داده ﻫﺎ در ﺣﺎﻓﻈﻪ ﺑﻪ ﻛﺎر ﻣﻴﺮود‪ .‬ﺑﻪ ﻋﺒﺎرن دﻳﮕﺮ‪،‬‬
‫ﻧﺸﺎﻧﮕﺮ آدرس و ﻳﺎ ﻣﻜﺎن داده ﻫﺎ در ﺣﺎﻓﻈﻪ را ﻧﺸﺎن ﻣﻲ دﻫﺪ‪ .‬ﻓﺮﻣﺖ ﺗﻌﺮﻳﻒ ﻧﺸﺎﻧﮕﺮ ﭼﻨﻴﻦ اﺳﺖ ‪:‬‬
‫‪ ; Æ //* data_type‬ﻧﺎم ﻧﺸﺎﻧﮕﺮ * ﻧﻮع داده‬
‫;‪data type * pointer_name‬‬
‫‪pointer name; *//‬‬
‫;‪int *p‬‬
‫;‪char *ch‬‬
‫در اﻳﻦ ﻣﺜﺎل‪ p ،‬ﻧﺸﺎﻧﮕﺮي اﺳﺖ ﻛﻪ ﻣﻲ ﺗﻮاﻧﺪ ﻧﺸﺎﻧﻲ ﻣﺘﻐﻴﺮﻫﺎي ﺻﺤﻴﺢ را ﻧﮕﻬﺪاري ﻧﻤﺎﻳﺪ و ‪ ch‬ﻫﻢ‬
‫ﻧﺸﺎﻧﮕﺮي اﺳﺖ ﻛﻪ ﻣﻲ ﺗﻮاﻧﺪ ﺑﺮاي ﻧﮕﻬﺪاري آدرس ﻛﺎراﻛﺘﺮﻫﺎ ﺑﻪ ﻛﺎر رود‪.‬‬
‫;‪x = *p‬‬
‫در اﻳﻦ ﻣﺜﺎل ﺧﻮاﺳﺘﻪ اﻳﻢ داده اي را ﻛﻪ ﻧﺸﺎﻧﻲ آن در ‪ p‬ﻗﺮار دادرد ﺑﻪ ‪ x‬واﮔﺬار ﻧﻤﺎﺋﻴﻢ‪.‬‬

‫;‪int a , *p‬‬
‫;‪p‬‬
‫;‪a = 100‬‬
‫;‪p = &a‬‬
‫&‬
‫اﻛﻨﻮن در ﻫﻤﻪ ﺟﺎ ﻣﻲ ﺗﻮاﻧﻴﻢ ‪ *p‬را ﺑﻪ ﺟﺎي ‪ a‬ﺑﻪ ﻛﺎر ﺑﺮﻳﻢ‪.‬‬
‫;‪x = a‬‬
‫;‪y = *p‬‬
‫;‪p‬‬
‫ﺑﺎ دو دﺳﺘﻮر ﻓﻮق‪ ،‬ﻫﻢ ‪ x‬و ﻫﻢ ‪ y‬ﺑﺮاﺑﺮ ‪ 100‬ﻣﻲ ﺷﻮﻧﺪ‪.‬‬

‫در ﺷﻜﻞ زﻳﺮ ﻓﺮض ﻛﺮده اﻳﻢ ﻛﻪ ﻣﺘﻐﻴﺮ ‪ p‬در آدرس ‪ 65520‬و ﻣﺘﻐﻴﺮ ‪a‬‬
‫دارد‪.‬‬ ‫رس ‪ 65522‬ﺮ‬
‫ﻗﺮارر ر‬ ‫درر آدرس‬
‫‪65520‬‬ ‫‪65522‬‬
‫‪65522‬‬ ‫‪100‬‬
‫‪p‬‬ ‫‪a‬‬

:8-1 ‫ﺑﺮﻧﺎﻣﻪ‬
/* P8.1 Pointer Example */
#include <stdio.h>
int main(void)
{
int a,*p;
a = 100;
p = &a;
printf(“address
printf( address of a = %5u\n
%5u\n”,
, &a); /
/* u is unsigned Integer & equal d */
/
printf(“value of a = %d\n\n”, a);
printf(“address of p = %5u\n”, &p);
printf(“value of p = %5u\n”, p);
}
Running Program
address of a = 65522
value of a = 100
address of p = 65520
value of p = 65522

/* P8.2 Pointer & variables */
#include <stdio.h>
int main(void)
{
int a, *p, x, y;
a = 100;
p = &a;
x = a;
y = *p;
printf(“x = %d\n”,
\ x);
printf(“y = %d\n”, y);
printf(“\na = %d\n”, a);
++*p;
printf(“a = %d\n”, a);
}
Running Program
x = 100
y = 100
a = 100
a = 101

‫در ﻣﺜﺎل ﻗﺒﻞ ﺗﻮﺟﻪ ﻧﻤﺎﺋﻴﺪ ﻛﻪ دﺳﺘﻮر ‪ ،++*p‬ﻋﺪد ‪ 1‬را ﺑﻪ ‪ a‬اﻓﺰوده اﺳﺖ‪.‬‬
‫اﮔﺮ ﺑﺨﻮاﻫﻴﻢ ﻋﻤﻠﮕﺮ اﻓﺰاﻳﺶ و ﻳﺎ ﻛﺎﻫﺶ را ﭘﺲ از ﻧﺸﺎﻧﮕﺮ ﺑﻪ ﻛﺎر ﺑﺮﻳﻢ‪ ،‬ﺑﺎﻳﺪ‬
‫ﻧﺸﺎﻧﮕﺮ را درون ﭘﺮاﻧﺘﺰ ﻗﺮار دﻫﻴﻢ‪.‬‬
‫‪(*p)++‬‬
‫(‬ ‫‪p)++‬‬
‫‪(*p)--‬‬
‫ﻋﻤﻠﮕﺮﻫﺎي ‪++‬‬
‫اوﻟﻮﻳﺖ ﻠﮕ ﺎ‬ ‫اوﻟﻮﻳﺖ ﻫﺎﺎ ﺻﺤﺒﺖ ﻧﻧﻤﻮدﻳﻢ‪ ،‬ا ﻟ‬ ‫ﻫﻤﺎﻧﮕﻮﻧﻪ ﻛﻛﻪ در ﻣﻮرد ا ﻟ‬
‫ﺎﻧﮕ ﻧ‬
‫و ‪ --‬از * ﺑﻴﺸﺘﺮ اﺳﺖ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ اﮔﺮ از ﭘﺮاﻧﺘﺰ ﺑﺮاي ﺗﻐﻴﻴﺮ اوﻟﻮﻳﺖ ﻋﻤﻠﮕﺮﻫﺎ‬
‫ﻳﺎﻓﺘﻪ )ﺑﻪ ﺎ ت‬
‫ﻋﺒﺎرت‬ ‫ﺶ ﺎﻓﺘ‬
‫ﻛﺎﻫﺶ‬ ‫اﻓﺰاﻳﺶ و ﻳﺎﺎ ﻛﺎ‬
‫ﻧﺸﺎﻧﮕﺮ اﻓ ا ﺶ‬
‫ﻣﻘﺪار ﻧﺸﺎﻧﮕ‬
‫ﻧﺨﺴﺖ ﻘ ا‬
‫ﻧﻜﻨﻴﻢ‪ ،‬ﻧﺨ ﺖ‬ ‫اﺳﺘﻔﺎده ﻧﻜ‬
‫ا ﺘﻔﺎ‬
‫دﻳﮕﺮ‪ ،‬ﻧﺸﺎﻧﻲ ﺗﻐﻴﻴﺮ ﻣﻲ ﻛﻨﺪ(‪ ،‬ﺳﭙﺲ ﺑﻪ ﻣﺤﺘﻮﻳﺎت ﻧﺸﺎﻧﻲ ﻣﺮاﺟﻌﻪ ﻣﻴﮕﺮدد‪.‬‬

/* P8.3 Pointer increment */
#include <stdio.h>
int main(void)
{
int b = 20, a = 10, *p;
p = &a;
printf(“address of a = %5u\n”, &a);
printf(“address of b = %5u\n\n”, &b);
++*p;
printf(“a = %d p = %u\n”,
\ a, p);
*p++;
printf(“a = %d p = %u\n”, a, p);
++*p;
printf(“b = %d p = %u\n”, b, p);
}
Running Program
address of a = 65520
address of b = 65522
a = 11 p = 65520
a = 11 p = 65522
b = 21 p = 65522

‫ﻧﺸﺎﻧﮕﺮ و ﻣﺤﺎﺳﺒﻪ ‪:‬‬

‫ﺗﻨﻬﺎ‬
‫وﻟﻲ ﻬ‬
‫ﺑﺮد‪ .‬و ﻲ‬
‫دﻳﮕﺮ‪ ،‬درر ﻣﺤﺎﺳﺒﻪ ﺑﻪ ﻛﺎرر ﺮ‬
‫ﻣﺘﻐﻴﺮﻫﺎي ﺮ‬
‫ﺮ ي‬ ‫ﻫﻤﭽﻮن‬
‫ﺗﻮان ﭽﻮن‬ ‫ﻣﻲ ﻮ ن‬
‫ﻫﻢ ﻲ‬
‫ﻧﺸﺎﻧﮕﺮﻫﺎ ررا ﻢ‬
‫ﺮ‬
‫ﻛﺎري ﻛﻪ ﺑﺮ روي آن ﻫﺎ ﻣﻲ ﺗﻮان اﻧﺠﺎم داد‪ ،‬ﺟﻤﻊ و ﺗﻔﺮﻳﻖ اﺳﺖ‪ .‬از اﻳﻦ رو ﻧﺸﺎﻧﮕﺮﻫﺎ‬
‫ﻣﻲ ﺗﻮاﻧﻨﺪ ﺑﺎ ﻋﻤﻠﮕﺮﻫﺎي ‪ ++ ،- ،+‬و ‪ --‬ﺑﻪ ﻛﺎر روﻧﺪ‪.‬‬
‫ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﺑﻪ ﻳﻚ ﻧﺸﺎﻧﮕﺮ ﻋﺪد ‪ n‬را ﻣﻲ اﻓﺰاﺋﻴﻢ‪ ،‬ﺑﺴﺘﻪ ﺑﻪ ﻧﻮع ﻧﺸﺎﻧﮕﺮ‪ n ،‬ﻳﺎ ‪ 2n‬و ﻳﺎ‬
‫‪ .....‬ﺑﻪ آن اﻓﺰوده ﻣﻲ ﺷﻮد‪ .‬ﻣﺜﻼ اﮔﺮ ﻧﺸﺎﻧﮕﺮ از ﻧﻮع ﻛﺎراﻛﺘﺮي‪ ،‬ﺻﺤﻴﺢ‪ ،‬اﻋﺸﺎري‪ ،‬دو‬
‫دﻗﺘﻲ و ‪ ....‬ﺑﺎﺷﺪ‪ ،‬ﻣﻘﺪار اﻓﺰاﻳﺶ ﺑﻪ ﺗﺮﺗﻴﺐ ﺑﺮاﺑﺮ ‪ 8n ،4n ،2n ،n‬و ‪ ...‬ﻣﻲ ﺷﻮد‪ .‬ﺑﻌﺪ‬
‫ﻧﮕﻬﺪاري ﻛﻛﻨﺪ‪.‬‬
‫ﻫﺎ راا ﻫﻢ ﮕ ا‬
‫ﺳﺎﺧﺘﺎرﻫﺎ و ااﻧﺠﻤﻦ ﺎ‬
‫ﺗﻮاﻧﺪ آآدرس ﺎﺧ ﺎ ﺎ‬ ‫ﻧﺸﺎﻧﮕﺮ ﻣﻲ ا‬
‫ﺧﻮاﻫﻴﻢ دﻳﺪ ﻛﻛﻪ ﺎ ﮕ‬
‫ﺧا‬

/* P8.3 Pointer Arithmetic */
#include <stdio.h>
int main(void)
{
char c = ‘*’, *p;
p = &c;
printf(“c = %c p = %u\n” , *p, p);
p += 10;
printf(“c = %c p = %u\n” , *p, p);
p -= 10;
printf(“c
i tf(“ = %
%c p = %
%u\n”
\ ” , *
*p, p);
)
}
Running Program
c = * p = 65523
c = p = 65533
c = * p = 65523

‫ﻧﺸﺎﻧﮕﺮ و ﻣﺤﺎﺳﺒﻪ )اداﻣﻪ(‪:‬‬

‫دارﻧﺪ‪،‬‬
‫ﺟﺎي ر‬
‫در ﺣﺎﻓﻈﻪ ي‬ ‫ﻫﺎﺋﻲ ﻛﻪ ر‬
‫ن ﺑﺮﺮ ﻫﻤﻪ داده ﻲ‬
‫ﺗﻮان‬
‫ﻣﻲ ﻮ‬
‫ﺶ ﻧﺸﺎﻧﮕﺮﺮ ﻲ‬ ‫ﺶ و ﻛﺎﻫﺶ‬
‫اﻓﺰاﻳﺶ‬
‫ﺑﺎ ﺰ‬
‫دﺳﺖ ﻳﺎﻓﺖ‪ .‬در ﺑﺮﻧﺎﻣﻪ ﺻﻔﺤﻪ ﺑﻌﺪ‪ ،‬ﺑﻪ ﻛﻤﻚ ﻧﺸﺎﻧﮕﺮ ﻋﺪدﻫﺎي ‪ 1‬ﺗﺎ ‪ 10‬را در ﺣﺎﻓﻈﻪ‬
‫ﮔﺬاﺷﺘﻪ‪ ،‬ﺳﭙﺲ آن ﻫﺎ را از ﺣﺎﻓﻈﻪ ﺑﺮداﺷﺘﻪ و ﭼﺎپ ﻣﻲ ﻛﻨﻴﻢ‪.‬‬

/* P8.5 Pointer as Array */
#include <stdio.h>
int main(void)
{
char n, a[100], *p;
p = &a[0] + 10;
for (n = 1; n <= 10 ; ++n) {
*p
p = n;
--p; }
for (n = 1; n <= 10 ; ++n) {
++p;
printf(“%4d”, *p); }
printf(“\n”);
i tf(“\ ”)
for (n = 1; n <= 10 ; ++n) {
printf(“%4d”, *p);
--p;}
}
Running Program
10 9 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 9 10

‫ﻧﺸﺎﻧﮕﺮ و آراﻳﻪ ‪:‬‬
‫در زﺑﺎن ‪ c‬ﻧﺎم آراﻳﻪ ﻧﺸﺎﻧﮕﺮي اﺳﺖ ﻛﻪ ﻧﺸﺎﻧﻲ ﻧﺨﺴﺘﻴﻦ ﻋﻨﺼﺮ آراﻳﻪ را دارا ﻣﻴﺒﺎﺷﺪ‪.‬‬
‫در زﻳﺮ روش دﺳﺘﻴﺎﺑﻲ ﺑﻪ ﻋﻨﺎﺻﺮ آراﻳﻪ اي را ﻫﻢ ﺑﻪ ﺷﻴﻮه ﻧﺸﺎﻧﮕﺮي و ﻫﻢ ﺑﻪ روش‬
‫آراﻳﻪ اي ﻧﺸﺎن داده اﻳﻢ‪.‬‬
‫]‪a[0‬‬
‫* = ]‪[0‬‬ ‫‪*a‬‬
‫)‪a[1] = *(a+1‬‬
‫)‪a[2] = *(a+2‬‬
‫……‬
‫)‪a[n] = *(a+n‬‬

/* P8.6 Arrays as Pointers */
#include<stdio.h>
int main(void) {
int n,a[10]={1,2,3,4,5,6,7,8,9,10};
for (n=0; n<10 ; ++n)
printf(“a[%d] = %2d *(a + %d)= %2d\n”, n, a[n], n, *(a + n);
}
Running Program
a[0]
[ ] = 1 *(a
( + 0)
) = 1
a[1] = 2 *(a + 1) = 2
a[2] = 3 *(a + 2) = 3
a[3] = 4 *(a + 3) = 4
a[4] = 5 *(a + 4) = 5
a[5] = 6 *(a + 5) = 6
a[6] = 7 *(a + 6) = 7
a[7] = 8 *(a + 7) = 8
a[8] = 9 *(a + 8) = 9
a[9] = 10 *(a + 9) = 10

‫ ﻧﺸﺎﻧﮕﺮ را ﻧﻴﺰ ﻣﻲ ﺗﻮان ﻫﻤﺎﻧﻨﺪ آراﻳﻪ ﺑﻪ ﻛﺎر‬،‫ﺑﺎﻳﺪ داﻧﺴﺖ ﻫﻤﺎن ﮔﻮﻧﻪ ﻛﻪ آراﻳﻪ را ﻣﻲ ﺗﻮان ﻫﻤﭽﻮن ﻧﺸﺎﻧﮕﺮ ﺑﻪ ﻛﺎر ﺑﺮد‬
.‫ﮔﺮﻓﺖ‬
/* P8.7 Pointers and Arrays */
#include<stdio.h>
i
int main(void)
i ( id) {
int n, *p, a[10]={1,2,3,4,5,6,7,8,9,10};
p = a;
for (n=0; n<10 ; ++n)
printf(“a[%d]
p ( [ ] = %2d p[%d]
p[ ] = %2d\n”,
\ , n,
, a[n],
[ ], n,
, p[
p[n];
];
}
Running Program
a[0] = 1 p[0] = 1
a[1] = 2 p[1] = 2
a[2] = 3 p[2] = 3
a[3] = 4 p[3] = 4
a[4] = 5 p[4] = 5
a[5] = 6 p[5] = 6
a[6]
[ ] = 7 p[6]
p[ ] = 7
a[7] = 8 p[7] = 8
a[8] = 9 p[8] = 9
a[9] = 10 p[9] = 10

.‫ واﮔﺬار ﻧﻤﺎﺋﻴﻢ‬p ‫ ﻧﺸﺎﻧﻲ ﻧﺨﺴﺘﻴﻦ ﻋﻨﺼﺮ آن را ﺑﻪ ﻧﺸﺎﻧﮕﺮ‬،‫اﻟﺒﺘﻪ ﻣﻲ ﺗﻮاﻧﺴﺘﻴﻢ ﺑﻪ ﺟﺎي ﻧﺎم آراﻳﻪ‬
/* P8.8 Pointers and Arrays */
#include<stdio.h>
int main(void) {
int n, *p, a[10]={1,2,3,4,5,6,7,8,9,10};
p = &a[0];
for (n=0; n<10 ; ++n)
printf(“a[%d]
p t ( a[ d] = %2d
d p[
p[%d]
d] = %2d\n”,
d\ , n,
, a[
a[n],
], n,
, p[
p[n];
];
}
Running Program
a[0] = 1 p[0] = 1
a[1] = 2 p[1] = 2
a[2] = 3 p[2] = 3
a[3] = 4 p[3] = 4
a[4] = 5 p[4] = 5
a[5]
[5] = 6 p[5]
[5] = 6
a[6] = 7 p[6] = 7
a[7] = 8 p[7] = 8
a[8] = 9 p[8] = 9
a[9] = 10 p[9] = 10

‫ﻧﺸﺎﻧﮕﺮ و رﺷﺘﻪ ‪:‬‬
‫ﭘﻴﺶ از اﻳﻦ دﻳﺪﻳﻢ ﻛﻪ در زﺑﺎن ‪ ،C‬آراﻳﻪ ﻫﺎي ﻛﺎراﻛﺘﺮي را ﺑﻪ ﺟﺎي رﺷﺘﻪ ﺑﻪ ﻛﺎر ﻣﻲ ﺑﺮﻳﻢ‪ .‬از آن ﺟﺎﺋﻲ ﻛﻪ آراﻳﻪ و ﻧﺸﺎﻧﮕﺮ‬
‫را ﻣﻲ ﺗﻮان ﺑﻪ ﺟﺎي ﻫﻢ ﺑﻪ ﻛﺎر ﺑﺮد‪ ،‬ﭘﺲ ﻧﺸﺎﻧﮕﺮﻫﺎي ﻛﺎراﻛﺘﺮي ﻣﻲ ﺗﻮاﻧﻨﺪ ﺑﻪ ﺟﺎي رﺷﺘﻪ ﺑﻪ ﻛﺎر ﮔﺮﻓﺘﻪ ﺷﻮﻧﺪ‪.‬‬
‫ل‪:‬‬
‫ﻣﺜﺎل‬
‫‪/* P8.9 Pointers and Strings */‬‬
‫{ )‪int main(void‬‬
‫;”‪char *nam, name[20]=“Anahita‬‬
‫;‪nam = name‬‬
‫;)‪printf(“%s \n%s \n”, nam, name‬‬
‫}‬
‫‪Running Program‬‬
‫‪Anahita‬‬
‫‪Anahita‬‬

‫ﻧﺸﺎﻧﮕﺮ و رﺷﺘﻪ )اداﻣﻪ( ‪:‬‬
‫ﻳﻜﻲ از ﺗﻔﺎوت ﻫﺎي آراﻳﻪ و ﻧﺸﺎﻧﮕﺮ اﻳﻦ اﺳﺖ ﻛﻪ اﮔﺮ ﺑﺨﻮاﻫﻴﻢ رﺷﺘﻪ اي را ﺑﻪ ﻛﻤﻚ دﺳﺘﻮر واﮔﺬاري در آراﻳﻪ ﺑﮕﺬارﻳﻢ‪،‬‬
‫ﻧﺸﺪﻧﻲ اﺳﺖ‪ ،‬وﻟﻲ در ﻧﺸﺎﻧﮕﺮ اﻳﻦ ﻛﺎر را ﻣﻲ ﺗﻮان اﻧﺠﺎم داد‪.‬‬
‫ل‪:‬‬
‫ﻣﺜﺎل‬
‫;]‪char *name2, name1[10‬‬
‫;”‪/* name1 = “Farshad‬‬ ‫‪Error! */‬‬
‫;”‪name2 = “Farshad‬‬
‫‪printf(“%s\n”,‬‬
‫\‬ ‫;)‪name2‬‬
‫}‬
‫‪Farshad‬‬

‫ﻧﺸﺎﻧﮕﺮ و رﺷﺘﻪ )اداﻣﻪ( ‪:‬‬
‫ﺑﺮاي ﮔﺬاﺷﺘﻦ رﺷﺘﻪ در آراﻳﻪ ﻛﺎراﻛﺘﺮي‪ ،‬ﻳﺎ ﺑﺎﻳﺪ ﻛﺎراﻛﺘﺮﻫﺎ را ﻳﻜﻲ ﻳﻜﻲ ﺑﻪ آراﻳﻪ ﻣﻨﺘﻘﻞ ﻛﻨﻴﻢ و ﻳﺎ اﻳﻨﻜﻪ ﺑﺎ اﺳﺘﻔﺎده از‬
‫ﺗﺎﺑﻊ ‪ strcpy‬اﻳﻦ ﻛﺎر را اﻧﺠﺎم دﻫﻴﻢ‪ .‬اﻳﻦ ﺗﺎﺑﻊ در ﻓﺎﻳﻞ ‪ string.h‬ﻗﺮار دارد‪.‬‬
‫ل‪:‬‬
‫ﻣﺜﺎل‬
‫>‪#include<string.h‬‬
‫;]‪char nam[10‬‬
‫;)”‪strcpy(nam, “Farshad‬‬
‫‪printf(“%s\n”,‬‬
‫\‬ ‫;)‪nam‬‬
‫}‬
‫‪Farshad‬‬

‫آراﻳﻪ ﻧﺸﺎﻧﮕﺮي‪ ،‬آراﻳﻪ اي اﺳﺖ ﻛﻪ ﻫﺮ ﻋﻨﺼﺮ آن ﻳﻚ ﻧﺸﺎﻧﮕﺮ‬ ‫آراﻳﻪ ﻧﺸﺎﻧﮕﺮي‪:‬‬

‫ﻣﻴﺒﺎﺷﺪ‪ .‬ﻣﺜﺎل ‪:‬‬
‫;]‪char *city[5‬‬
‫در اﻳﻦ ﻣﺜﺎل‪ ،‬ﭼﻮن ﻧﺸﺎﻧﮕﺮﻫﺎ از ﻧﻮع ﻛﺎراﻛﺘﺮي ﻣﻲ ﺑﺎﺷﻨﺪ‪ ،‬ﻣﻲ ﺗﻮاﻧﻨﺪ ﺑﻪ ﺟﺎي رﺷﺘﻪ ﺑﻪ ﻛﺎر‬
‫روﻧﺪ‪ .‬در ﻧﺘﻴﺠﻪ ﻣﺜﺎل ﺑﺎﻻ را ﻣﻣﻲ ﺗﻮان ﺑﻪ ﻋﻨﻮان آراﻳﻪ رﺷﺘﻪ اي ﺑﻪ ﻛﺎر ﺑﺮد‪ .‬در ﻣﺜﺎل ﺻﻔﺤﻪ‬
‫ﺑﻌﺪ‪ ،‬از اﻳﻦ روش ﺑﺮاي ﻧﮕﻬﺪاري ﻧﺎم ﭘﻨﺞ ﺷﻬﺮ ﺑﺰرگ اﻳﺮان اﺳﺘﻔﺎده ﻛﺮده اﻳﻢ‪.‬‬

(‫ ﭼﺸﻤﻚ زن را ﺑﻪ ﺳﻄﺮ ﺑﻌﺪ ﻣﻲ ﺑﺮد‬،‫ ﭘﺲ از ﭼﺎپ رﺷﺘﻪ‬puts ‫ )ﺗﺎﺑﻊ‬:(‫ﻣﺜﺎل )آراﻳﻪ ﻧﺸﺎﻧﮕﺮي‬
/* P8.12 Pointers Arrays */
#include<stdio.h>
int main(void)
( ) {
int i;
char *city[]= {“Tehran”,”Mashad”,”Esfahan”,”Tabriz”,Shiraz”};
puts(“Five Great Cities”);
p
puts(“-----------------”);
( )
for (i=0; i < 5 ; ++i)
printf(“ %s\n”, city[i]);
}
Running Program
Five Great Cities
-----------------
Tehran
Mashad
Esfahan
Tabriz
Shiraz

‫آراﻳﻪ ﻧﺸﺎﻧﮕﺮي‪:‬‬
‫آراﻳﻪ ﻧﺸﺎﻧﮕﺮي ﻣﻲ ﺗﻮاﻧﺪ ﺑﻴﺶ از ﻳﻚ ﺑﻌﺪ داﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬در ﺑﺮﻧﺎﻣﻪ ﺻﻔﺤﻪ ﺑﻌﺪ‪ ،‬آراﻳﻪ دو‬
‫ﺑﻌﺪي و ﻧﺸﺎﻧﮕﺮي ﺑﻪ ﻧﺎم ﻓﺮﻫﻨﮓ ﺗﻌﺮﻳﻒ ﻛﺮده اﻳﻢ ﻛﻪ در آن‪ ،‬ﭼﻨﺪ واژه اﻧﮕﻠﻴﺴﻲ را ﻫﻤﺮاه‬
‫ﺑﺎ ﻣﻌﺎدل ﻫﺎي ﻓﺎرﺳﻲ آن ﻫﺎ ﻧﻮﺷﺘﻪ اﻳﻢ‪.‬‬

(‫ ﭼﺸﻤﻚ زن را ﺑﻪ ﺳﻄﺮ ﺑﻌﺪ ﻣﻲ ﺑﺮد‬،‫ ﭘﺲ از ﭼﺎپ رﺷﺘﻪ‬puts ‫ )ﺗﺎﺑﻊ‬:(‫ )آراﻳﻪ ﻧﺸﺎﻧﮕﺮي‬2 ‫ﻣﺜﺎل‬
/* P8.13 English – Persian Dictionary */
#include<stdio.h>
int main(void)
( ) {
int i;
char *Farhang[][2]= {“Flower”,“Gol”,”Apple”,”Sib”,”Peach”,”Holu”};
puts(“\nEnglish Persian”);
p
puts(“-----------------------”);
( )
for (i=0; i < 3 ; ++i)
printf(“-10s %-10s\n”, farhang[i][0], farhang[i][1]);
}
Running Program
English Persian
-----------------
Flower Gol
Apple Sib
Peach Holu

‫ﭘﺎراﻣﺘﺮ ﻧﺸﺎﻧﮕﺮي ‪:‬‬

‫اﮔﺮ ﭘﺎراﻣﺘﺮﻫﺎي ﺗﺎﺑﻊ از ﻧﻮع ﻧﺸﺎﻧﮕﺮي ﺑﺎﺷﻨﺪ‪ ،‬آن ﻫﺎ را ﭘﺎراﻣﺘﺮ ﻧﺸﺎﻧﮕﺮي ﻣﻲ ﻧﺎﻣﻴﻢ‪ .‬ﭘﺎراﻣﺘﺮ ﻧﺸﺎﻧﮕﺮي‬
‫را ﻫﻨﮕﺎﻣﻲ ﺑﻪ ﻛﺎر ﻣﻲ ﺑﺮﻳﻢ ﻛﻪ ﺑﺨﻮاﻫﻴﻢ ﺑﻪ ﺟﺎي ﻳﻚ داده‪ ،‬ﻧﺸﺎﻧﻲ آآن را ﺑﻪ ﺗﺎﺑﻊ ﺑﻔﺮﺳﺘﻴﻢ‪.‬‬
‫;)‪fun (int *p‬‬
‫در اﻳﻦ ﻣﺜﺎل‪ fun ،‬ﺗﺎﺑﻌﻲ اﺳﺖ ﻛﻪ داراي ﻳﻚ ﭘﺎراﻣﺘﺮ ﻧﺸﺎﻧﮕﺮي از ﻧﻮع ﺻﺤﻴﺢ ﺑﻪ ﻧﺎم ‪ n‬ﻣﻲ ﺑﺎﺷﺪ‪.‬‬
‫ﻧﻤﻲ ﺗﻮاﻧﻨﺪ ﭘﺎراﻣﺘﺮﻫﺎي ﺧﻮد را ﺗﻐﻴﻴﺮ دﻫﻨﺪ‪ ،‬ﻣﮕﺮ اﻳﻦ ﻛﻪ از ﻧﻮع آراﻳﻪ اي ﻳﺎ‬ ‫ﺗﺬﻛﺮ ‪ :‬ﺗﺎﺑﻊ ﻫﺎ ﻧﻤ‬
‫ﻧﺸﺎﻧﮕﺮي ﺑﺎﺷﻨﺪ و ﻳﺎ آدرس آن ﻫﺎ را ﺑﻪ ﺗﺎﺑﻊ ﺑﻔﺮﺳﺘﻴﻢ‪ .‬در ﻣﺜﺎل ﺑﺎﻻ‪ ،‬ﭼﻮن ‪ p‬ﭘﺎراﻣﺘﺮ ﻧﺸﺎﻧﮕﺮي اﺳﺖ‪،‬‬
‫ﻣﻘﺪار آن در ﺗﺎﺑﻊ )در واﻗﻊ ﻣﻘﺪاري ﻛﻪ اﻳﻦ ﻧﺸﺎﻧﮕﺮ ﻧﺸﺎﻧﻲ آن را دارد( ﻣﻲ ﺗﻮاﻧﺪ در ﺗﺎﺑﻊ ﺗﻐﻴﻴﺮ ﻛﻨﺪ‪.‬‬

/* P8.14 Pointer as Parameter */
#include<stdio.h>
void fun (int *q);
int main()
{
int a
a=100,
100, *p
p = &a;
printf(“\np1 = %d\n“, *p);

fun(p);
printf(“p4 = %d\n”, *p);
return
t 0
0;
}
void fun (int *q)

{
printf (“p2 = %d\n” , *q);
*q = 333;
printf(“p3 = %d\n”, *q);
}

‫اﺟﺮاي ﺑﺮﻧﺎﻣﻪ ‪:8-14‬‬

‫‪p1‬‬
‫‪1‬‬ ‫=‬ ‫‪100‬‬
‫‪p2‬‬ ‫=‬ ‫‪100‬‬
‫‪p3‬‬ ‫=‬ ‫‪333‬‬
‫‪p4‬‬ ‫=‬ ‫‪333‬‬

‫ﻧﺸﺎﻧﮕﺮ ﺗﺎﺑﻌﻲ ‪:‬‬
‫ﻧﺸﺎﻧﮕﺮ ﺗﺎﺑﻌﻲ‪ ،‬ﻧﺸﺎﻧﮕﺮي اﺳﺖ ﻛﻪ ﺑﺮاي ﻧﮕﻬﺪاري ﻧﺸﺎﻧﻲ ﺗﺎﺑﻌﻬﺎ ﺑﻪ ﻛﺎر ﻣﻲ رود‪ .‬از اﻳﻦ ﻧﺸﺎﻧﮕﺮ ﺑﻴﺸﺘﺮ در ﻛﺎرﻫﺎي ﻧﺮم اﻓﺰار ﻧﻮﻳﺴﻲ‪،‬‬
‫ﻣﺜﻞ ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ‪ ،‬ﻣﺘﺮﺟﻢ ﻫﺎ‪ ،‬ﺑﺎزي ﻫﺎي ﻛﺎﻣﭙﻴﻮﺗﺮي و ‪ ...‬اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد‪ .‬ﻓﺮﻣﺖ ﻧﻮﺷﺘﺎري آن ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺖ‪:‬‬
‫;)ﭘﺎراﻣﺘﺮﻫﺎ()ﻧﺸﺎﻧﮕﺮ *( ﻧﻮع‬
‫( ‪int‬‬ ‫)‪(*p‬‬ ‫( )‪p‬‬ ‫;)‪(int n‬‬ ‫)‬
‫در اﻳﻦ ﻣﺜﺎل‪ p ،‬ﻧﺸﺎﻧﮕﺮ ﺗﺎﺑﻌﻲ اﺳﺖ ﻛﻪ ﻣﻲ ﺗﻮاﻧﺪ ﺑﺮاي ﻧﮕﻬﺪاري ﻧﺸﺎﻧﻲ ﺗﺎﺑﻊ ﻫﺎي ﻧﻮع ﺻﺤﻴﺢ ﻛﻪ داراي ﻳﻚ ﭘﺎراﻣﺘﺮ‬
‫ﺻﺤﻴﺢ ﺑﺎﺷﻨﺪ ﺑﻪ ﻛﺎر رود‪ .‬ﺑﺮاي ﻣﺜﺎل‪ ،‬اﮔﺮ ﺗﺎﺑﻌﻲ را ﺑﻪ ﺷﻜﻞ زﻳﺮ ﺗﻌﺮﻳﻒ ﻛﻨﻴﻢ‪:‬‬
‫)‪int fun (int n‬‬
‫آن ﮔﺎه ﻣﻲ ﺗﻮاﻧﻴﻢ آن را ﺑﻪ ﻛﻤﻚ ﻧﺸﺎﻧﮕﺮ ﺑﻪ ﺻﻮرت زﻳﺮ ﺗﻌﺮﻳﻒ ﻛﻨﻴﻢ‪:‬‬
‫;‪p = fun‬‬
‫( = ‪x‬‬ ‫)‪(*p‬‬
‫)‪p) (y‬‬‫;)‪(y‬‬
‫اﻳﻦ دو دﺳﺘﻮر‪ ،‬روي ﻫﻢ ﻛﺎر دﺳﺘﻮر زﻳﺮ را اﻧﺠﺎم ﻣﻲ دﻫﻨﺪ‪:‬‬
‫;)‪x = fun (y‬‬

‫ﻧﺸﺎﻧﮕﺮ ﺗﻬﻲ ‪:‬‬

‫ﻧﺸﺎﻧﮕﺮ ﺗﻬﻲ‪ ،‬ﻧﺸﺎﻧﮕﺮي اﺳﺖ ﻛﻪ از ﻧﻮع ﺗﻬﻲ )‪ (void‬ﺗﻌﺮﻳﻒ ﺷﺪه ﺑﺎﺷﺪ‪ .‬ﻣﺜﺎل ‪:‬‬
‫;‪void *vp‬‬
‫در اﻳﻦ ﻣﺜﺎل‪ vp ،‬ﻧﺸﺎﻧﮕﺮ ﻧﻮع ﺗﻬﻲ اﺳﺖ‪ ،‬ﻳﻌﻨﻲ در ﺣﻘﻴﻘﺖ ﻧﻮع داده اي را ﻛﻪ اﻳﻦ ﻧﺸﺎﻧﮕﺮ ﻧﺸﺎن‬
‫ﻛﺎر‬
‫ﺗﻮان ﺑﻪ ﻛﺎ‬
‫داده ﻣﻲ ا‬‫دادن ﻫﺮ ﮔﮔﻮﻧﻪ ا‬‫ﻧﺸﺎن ا‬
‫ﺑﺮاي ﺎ‬‫ﻧﺸﺎﻧﮕﺮﻫﺎي ﺗﻬﻲ ارا ا‬
‫ﻧﻜﺮده ااﻳﻢ‪ .‬ﺎ ﮕ ﺎ‬
‫ﻣﻲ دﻫﺪ ارا ﺗﻌﻴﻴﻦ ﻜ‬
‫ﺑﺮد‪ ،‬در ﺣﺎﻟﻲ ﻛﻪ ﻧﺸﺎﻧﮕﺮﻫﺎي ﻧﻮع دﻳﮕﺮ ﻣﻌﻤﻮﻻ ﺑﺮاي ﻧﺸﺎن دادن داده ﻫﺎي ﻫﻤﻨﻮع ﺧﻮد ﺑﻪ ﻛﺎر‬
‫ﻣﻴﺮوﻧﺪ‪.‬‬
‫در ﺑﺮﻧﺎﻣﻪ ﺻﻔﺤﻪ ﺑﻌﺪ‪ ،‬ﻧﺸﺎﻧﮕﺮ ﺗﻬﻲ را ﻳﻚ ﺑﺎر ﺑﺮاي ﻧﮕﻬﺪاري ﻧﺸﺎﻧﻲ ﻋﺪد ﺻﺤﻴﺢ ‪ ،n‬و ﺑﺎر دﻳﮕﺮ ﺑﺮاي‬
‫ﻧﮕﻬﺪاري ﻧﺸﺎﻧﻲ ﻋﺪد اﻋﺸﺎري ‪ m‬ﺑﻪ ﻛﺎر ﺑﺮده اﻳﻢ‪ .‬اﻟﺒﺘﻪ ﺑﺮاي ﭼﺎپ اﻋﺪاد‪ ،‬دوﺑﺎره ﻧﺸﺎﻧﻲ آن ﻫﺎ را در‬
‫ﺧﻮد آن ﻫﺎ ﮔﺬاﺷﺘﻪ ااﻳﻢ‪.‬‬
‫ﻫﻤﻨﻮع ﺧ د‬
‫ﻧﺸﺎﻧﮕﺮﻫﺎي ﻫ ﻨ ع‬
‫ﻧﺸﺎﻧﮕ ﻫﺎي‬

: ‫ﻣﺜﺎل‬
/* P8.15 void pointers */
#include<stdio.h>
int main()
() {
int i , *ip;
float m = 20.5, *fp;
void *vp;
vp
p = &n;
ip = vp;
printf(“n = %d\n” , *ip);
vp = &m;
fp
p = vp;
p
printf(“m = %.1f\n”, *fp);
return 0;
}
Running Program
n = 10
m = 20.5

‫ﺗﻤﺮﻳﻨﺎت ﭘﺎﻳﺎن ﻓﺼﻞ‬
‫‪ -1‬ﺑﺮﻧﺎﻣﻪ اي ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﺑﻪ ﻛﻤﻚ دﺳﺘﻮر ﺣﻠﻘﻪ )‪ (while‬و ﻧﺸﺎﻧﮕﺮ‪ ،‬اﻋﺪاد ﻳﻚ ﺗﺎ ده را ﭼﺎپ‬
‫دﻫﻴﺪ‪.‬‬
‫اﻧﺠﺎم دﻫ ﺪ‬ ‫ﻛﺎر راا ﺎﺑﺎ ‪ for‬ﻧ ﺰ‬
‫ﻧﻴﺰ اﻧ ﺎ‬ ‫ﻦ ﻛﺎ‬
‫ﻧﻤﺎﻳﺪ‪ .‬ااﻳﻦ‬
‫ﻧ ﺎﺪ‬
‫‪ -2‬اﮔﺮ ‪ fp ،ip ،cp‬و ‪ dp‬ﺑﻪ ﺗﺮﺗﻴﺐ ﻧﺸﺎﻧﮕﺮﻫﺎي ﻛﺎراﻛﺘﺮي‪ ،‬ﺻﺤﻴﺢ‪ ،‬اﻋﺸﺎري و دو دﻗﺘﻲ ﺑﺎﺷﻨﺪ‪،‬‬
‫دﺳﺘﻮرﻫﺎي زﻳﺮ ﭼﻪ ﻛﺎر را اﻧﺠﺎم ﻣﻲ دﻫﻨﺪ؟‬
‫;‪cp++‬‬
‫;‪ip++‬‬
‫;‪fp++‬‬
‫;‪dp++‬‬
‫‪-3‬ﺗﺎﺑﻊ ﻣﻘﺎﻳﺴﻪ رﺷﺘﻪ ﻫﺎ )‪ (strcmp‬را ﻳﻚ ﺑﺎر ﺑﻪ ﻛﻤﻚ رﺷﺘﻪ و ﻳﻚ ﺑﺎر ﺑﻪ ﻛﻤﻚ ﻧﺸﺎﻧﮕﺮ‬
‫‪ -4‬ﺗﺎﺑﻊ ﻛﭙﻲ رﺷﺘﻪ ﻫﺎ )‪ (strcpy‬را ﻳﻚ ﺑﺎر ﺑﻪ ﻛﻤﻚ ﭘﺎراﻣﺘﺮ آراﻳﻪ اي و ﻳﻚ ﺑﺎر ﺑﻪ ﻛﻤﻚ ﭘﺎراﻣﺘﺮ‬
‫ﺮي ﺑ ﻮﻳ ﻴ‬
‫ﻧﺸﺎﻧﮕﺮي‬
‫ﻓﺼﻞ ﻧﻬﻢ‬
‫ﻓﺎﻳﻞ ﻫﺎ‬
‫‪Files‬‬

:‫اﻧﻮاع ﻓﺎﻳﻞ ﻫﺎ‬

-File
File of Character
-Text File
-File
Fil off Record
R d

‫ﻓﺎﻳﻞ ﻫﺎي ﻛﺎراﻛﺘﺮي‬
‫ﻓﺎﻳﻞ ﻫﺎي ﻛﺎراﻛﺘﺮي را ﻓﺎﻳﻞ ﻫﺎي دودوﺋﻲ ﻧﻴﺰ ﻣﻲ ﻧﺎﻣﻨﺪ ‪ .‬ﺑﺮاي‬

‫ﻛﺎراﻛﺘﺮ داﺧﻞ آن ﻫﺎ ﻣﻣﻲ ﺗﻮان از ﺗﺎﺑﻊ ‪ fputc‬و ﺑ اي‬
‫ﺑﺮاي‬ ‫ﻧﻮﺷﺘﻦ ﻳﻚ ﻛﺎراﻛﺘ‬
‫ﺧﻮاﻧﺪن ﻳﻚ ﻛﺎراﻛﺘﺮ از داﺧﻞ آن ﻣﻲ ﺗﻮان از ‪ fgetc‬اﺳﺘﻔﺎده ﻛﺮد‪.‬‬

‫ﻓﺎﻳﻞ ﻫﺎي ﻣﺘﻨﻲ )‪(Text Files‬‬
‫ﻓﺎﻳﻞ ﻫﺎي ﻣﺘﻨﻲ‪ ،‬ﻓﺎﻳﻞ ﻫﺎﺋﻲ ﻫﺴﺘﻨﺪ ﻛﻪ از ﺗﻌﺪادي ﺳﻄﺮ ﺗﺸﻜﻴﻞ ﺷﺪه اﻧﺪ و‬
‫اﻧﺪازه ﻫﺮ ﺳﻄﺮ ﻣﻲ ﺗﻮاﻧﺪ ﻣﺘﻔﺎوت ﺑﺎﺷﺪ‪ .‬ﺑﺮاي ﻛﺎر ﺑﺎ ﻓﺎﻳﻞ ﻫﺎي ﻣﺘﻨﻲ‪ ،‬ﻣﻌﻤﻮﻻ‬
‫ﻳﻚ ﺳﻄﺮ از ﻓﺎﻳﻞ را ﻣﻲ ﺧﻮاﻧﻴﻢ و ﻳﺎ داﺧﻞ ﻓﺎﻳﻞ ﻣﻲ ﻧﻮﻳﺴﻴﻢ‪ .‬در اﻳﻦ ﻓﺎﻳﻞ ﻫﺎ‪،‬‬
‫ﺳﻄﺮﻫﺎ در ﻫﻨﮕﺎم ذﺧﻴﺮه ﺷﺪن ﺑﻪ دﻧﺒﺎل ﻫﻢ ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ و ﺳﻄﺮﻫﺎ ﺑﺎ‬
‫ﻛﺎراﻛﺘﺮ ‪ ) Line Feed‬ﺎﺑﺎ ﻛﺪ ‪1‬‬
‫‪ (10‬از‬ ‫ﻛﺎراﻛﺘﺮ ‪ ) CR‬ﺎﺑﺎ ﻛﺪ ‪ (13‬و ﻛﺎ اﻛﺘ‬
‫اﺳﺘﻔﺎده از ددو ﻛﺎ اﻛﺘ‬
‫ا ﺘﻔﺎد‬
‫ﻳﻜﺪﻳﮕﺮ ﺟﺪا ﻣﻲ ﺷﻮﻧﺪ‪.‬‬
‫ﺧﻮاﻧﺪن‪/‬ﭘ ﺎﻳﺶ‬
‫ﭘﻴﻤﺎﻳﺶ‬ ‫ﻣﺘﻨﻲ از ﺗﺎﺑﻊ ‪ fprintf‬و ﺑ اي‬
‫ﺑﺮاي ﺧ اﻧﺪن‬ ‫ﭘﺮوﻧﺪه ﻫﺎي ﺘﻨ‬
‫ﻧﻮﺷﺘﻦ ددر ﭘ وﻧﺪه‬
‫ﺑﺮاي ﻧ ﺷﺘﻦ‬
‫ﺑ اي‬
‫از ﭘﺮوﻧﺪه ﻫﺎي ﻣﺘﻨﻲ از ﺗﺎﺑﻊ ‪ fscanf‬اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻴﻢ‪.‬‬

‫ﻓﺎﻳﻞ ﻫﺎي رﻛﻮردي‬

‫‪ -‬ﺗﻌﺮﻳﻒ رﻛﻮرد ؟‬
‫ﻓﺎﻳﻞ ﻫﺎي رﻛﻮردي ﺷﺎﻣﻞ ﺗﻌﺪادي رﻛﻮرد ﻫﺴﺘﻨﺪ ﻛﻪ ﻫﻤﮕﻲ آن ﻫﺎ داراي ﻳﻚ‬
‫ﺳﺎﺧﺘﺎر )ﻫﻢ اﻧﺪازه‪ ،‬داراي ﻓﻴﻠﺪﻫﺎي ﻳﻜﺴﺎن و ﻫﻢ ﺗﺎﻳﭗ( ﻣﻲ ﺑﺎﺷﻨﺪ‪ .‬در اﻳﻦ‬
‫ﻓﺎﻳﻞ ﻫﺎ‪ ،‬رﻛﻮردﻫﺎ ﺑﻲ ﻫﻴﭻ ﻧﺸﺎﻧﻪ اي ﺑﻪ دﻧﺒﺎل ﻳﻜﺪﻳﮕﺮ ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮﻧﺪ‪.‬‬
‫ﺑﺮاي ﻛﺎر ﺑﺎ ﻓﺎﻳﻞ ﻫﺎي رﻛﻮردي‪ ،‬ﻳﺎ ﻳﻚ ﻳﺎ ﭼﻨﺪ رﻛﻮرد را در آن ﻣﻲ ﻧﻮﻳﺴﻴﻢ و‬
‫ﺧﻮاﻧﻴﻢ‪.‬‬
‫را ااز آآن ﻣﻲ ا‬
‫رﻛﻮرد ا‬
‫ﻳﺎ ﭼﻨﺪ ﻛ‬
‫ﻳﻚ ﺎ‬
‫اﻳﻨﻜﻪ ﻚ‬
‫ﻳﺎ ا ﻜ‬
‫ﺎ‬
‫ﺑﺮاي ﻛﺎر ﺑﺎ ﻓﺎﻳﻞ ﻫﺎي رﻛﻮردي از ﺗﻮاﺑﻊ ‪) fread‬ﺧﻮاﻧﺪن ﻳﻚ رﻛﻮرد از ﻓﺎﻳﻞ(‬
‫اﺳﺘﻔﺎده ﻣﻲ ﻛﻛﻨﻴﻢ‪.‬‬
‫ﻓﺎﻳﻞ( ا ﻔﺎ‬
‫رﻛﻮرد در ﻓﺎ ﻞ‬
‫ﻳﻚ ﻛ‬ ‫‪ )fwrite‬ﺷ‬
‫ﻧﻮﺷﺘﻦ ﻚ‬ ‫و ‪f it‬‬
‫ﺗﺬﻛﺮ ‪ :‬ﺑﻪ ﻓﺎﻳﻞ ﻫﺎي رﻛﻮردي ﻧﻴﺰ ﻓﺎﻳﻞ ﻫﺎي دودوﺋﻲ ﮔﻔﺘﻪ ﻣﻲ ﺷﻮد‪.‬‬

‫روش ﻫﺎي دﺳﺘﻴﺎﺑﻲ ﺑﻪ اﻃﻼﻋﺎت داﺧﻞ ﻓﺎﻳﻞ ﻫﺎ‬
‫‪ -1‬ﺗﺮﺗﻴﺒﻲ )‪(Sequential‬‬
‫ﺗﺼﺎدﻓﻲ )‪(Random‬‬
‫ﻣﺴﺘﻘﻴﻢ ‪ /‬ﺗ ﺎ ﻓ‬
‫ﻘ‬ ‫‪-2‬‬
‫ﺑﺮاي ﭘﺮدازش ﻓﺎﻳﻞ ﻫﺎي ﺗﺼﺎدﻓﻲ و ﺧﻮاﻧﺪ ﻳﻚ رﻛﻮرد ﻣﺸﺨﺺ‪ ،‬ﻣﻲ‬

‫ﻊ ‪ fseek‬اﺳﺘﻔﺎده ﻛﻨﻴﻢ‬
‫ﻢ‪.‬‬ ‫ﺗﻮاﻧﻴﻢ از ﺗﺎﺑﻊ‬
‫ﻢ‬

‫روش ﻫﺎي ﭘﺮدازش ﻓﺎﻳﻞ ﻫﺎ‬
‫‪ -1‬ﻧﻮﺷﺘﻦ‬
‫ﺧﻮاﻧﺪن‬
‫ن‬ ‫‪ -2‬ﻮا‬
‫‪ -3‬اﻟﺤﺎق ﻛﺮدن‪/‬ﭘﻴﻮﺳﺖ ﻛﺮدن‬
‫‪ -4‬ﺑﻪ روز ﻛﺮدن ‪ /‬اﺻﻼح ﻛﺮدن‬
‫اﻧﺠﺎم‬
‫ﻛﺘﺎﺑﺨﺎﻧﻪ ااي اﻧ ﺎ‬
‫ﺗﺎﺑﻊ ﻛﺘﺎ ﺨﺎﻧ‬
‫ﺗﻌﺪادي ﺗﺎ‬
‫ﻛﻤﻚ ﺗ ا‬
‫ﭘﺮوﻧﺪه ﻫﺎ ﺑﻪ ﻛ ﻚ‬
‫ﻧ‬ ‫ازش‬
‫ﭘﺮدازش‬
‫ﻣﻴﺸﻮﻧﺪ ﻛﻪ در ﻓﺎﻳﻞ ورودي = ﺧﺮوﺟﻲ اﺳﺘﺎﻧﺪار )‪(stdlib.h‬‬
‫وﺟﻮد دارﻧﺪ‪.‬‬
‫ﺗﻮاﺑﻊ ﭘﺮدازش ﻓﺎﻳﻞ ﻫﺎي ﺳﻄﺮي )ﻣﺘﻨﻲ(‬
‫‪ -1‬ﺑﺎزﻛﺮدن ﭘﺮوﻧﺪه )‪(fopen‬‬

‫ﭘﺮوﻧﺪه )‪(fprintf‬‬
‫ﻧﻮﺷﺘﻦ در ﻧ‬‫‪ -2‬ﻧ ﺷ‬
‫‪ -3‬ﭘﻴﻤﺎﻳﺶ ﭘﺮوﻧﺪه )‪(fscanf‬‬
‫‪ -4‬ﭘﺎﻳﺎن ﭘﺮوﻧﺪه )‪(feof‬‬
‫ﭘﺮوﻧﺪه )‪(fclose‬‬
‫ﺑﺴﺘﻦ ﭘﺮو‬
‫‪ -5‬ﺑ ﻦ‬

(fopen) ‫ﺗﺎﺑﻊ ﺑﺎز ﻛﺮدن ﭘﺮوﻧﺪه‬

:‫ﻊ ﺑﻪ ﺻﻮرت زﻳﺮ اﺳﺖ‬
‫اﻳﻦ ﺗﺎﺑﻊ‬
‫ﻓﺮﻣﺖ ﻧﻮﺷﺘﺎري ﻦ‬
variable_file_name = fopen (file_name , pattern);
: ‫ﻣﺜﺎل‬
main()
()
{
...
FILE *out;
...
out = fopen (“daneshju” , “w”);
...
}
‫ﺷﻴﻮه ﻫﺎي ﭘﺮدازش اﺳﺘﺎﻧﺪارد‬

‫ﺷﻴﻮه ازش‬
‫ﭘﺮدازش‬ ‫ﺷ‬ ‫ﺑﺮاي ‪....‬‬
‫ﺑﺎزﻛﺮدن ا‬
‫ﺎزﻛ‬
‫‪w‬‬ ‫ﻧﻮﺷﺘﻦ در ﻓﺎﻳﻞ ﻣﺘﻨﻲ‬
‫‪r‬‬ ‫ﺧﻮاﻧﺪن از ﻓﺎﻳﻞ ﻣﺘﻨﻲ‬
‫‪a‬‬ ‫ﻣﺘﻨﻲ‬
‫ﻛﺮدن در ﻓﺎﻳﻞ ﻣﺘﻨ‬
‫اﻟﺤﺎق ﻛ دن‬
‫‪wb‬‬ ‫ﻧﻮﺷﺘﻦ در ﻓﺎﻳﻞ ﻛﺎراﻛﺘﺮي و ﻳﺎ رﻛﻮردي )دودوﺋﻲ=‪(b‬‬
‫‪rb‬‬ ‫ﺧﻮاﻧﺪن از ﻓﺎﻳﻞ ﻛﺎراﻛﺘﺮي و ﻳﺎ رﻛﻮردي )دودوﺋﻲ(‬
‫‪ab‬‬ ‫ﻲ(‬
‫دودوﺋﻲ‬
‫رﻛﻮردي ) و و‬
‫ﺮي و ﻳﻳﺎ ر ﻮر ي‬
‫ﻛﺎراﻛﺘﺮي‬
‫ﻳﻞ ر‬‫ﻛﺮدن ﺑﺑﻪ ﻓﺎﻳﻞ‬
‫ق ﺮ ن‬‫اﻟﺤﺎق‬
‫ﺷﻴﻮه ﻫﺎي ﭘﺮدازش اﺳﺘﺎﻧﺪارد )اداﻣﻪ(‬

‫ﺷﻴﻮه ازش‬
‫ﭘﺮدازش‬ ‫ﺷ‬ ‫ﺑﺮاي ‪....‬‬
‫ﺑﺎزﻛﺮدن ا‬
‫ﺎزﻛ‬
‫‪w+‬‬ ‫ﻧﻮﺷﺘﻦ و ﺑﻪ روز ﻛﺮدن ﻓﺎﻳﻞ ﻣﺘﻨﻲ‬
‫‪r+‬‬ ‫ﺧﻮاﻧﺪن و ﺑﻪ روز ﻛﺮدن ﻓﺎﻳﻞ ﻣﺘﻨﻲ‬
‫‪a+‬‬ ‫ﻛﺮدن آآن‬
‫ﻣﺘﻨﻲ و ﺑﻪﻪ روزز ﻛ د‬
‫ﻞ ﺘﻨ‬‫ﻓﺎﻳﻞ‬
‫ﻛﺮدن ددر ﻓﺎ‬
‫ﺎق ﻛ د‬
‫اﻟاﻟﺤﺎق‬
‫‪w+b‬‬ ‫ﻧﻮﺷﺘﻦ در و ﺑﻪ روز ﻛﺮدن ﻓﺎﻳﻞ ﻛﺎراﻛﺘﺮي و ﻳﺎ رﻛﻮردي‬
‫‪r+b‬‬ ‫ﺧﻮاﻧﺪن از ﻓﺎﻳﻞ ﻛﺎراﻛﺘﺮي و ﻳﺎ رﻛﻮردي و ﺑﻪ روز ﻛﺮدن‬
‫‪a+b‬‬ ‫اﻟﺤﺎق ﻛﺮدن ﺑﻪ ﻓﺎﻳﻞ ﻛﺎراﻛﺘﺮي و ﻳﺎ رﻛﻮردي و ﺑﻪ روز ﻛﺮدن‬
(fprintf) ‫ﺗﺎﺑﻊ ﻧﻮﺷﺘﻦ در ﭘﺮوﻧﺪه ﻣﺘﻨﻲ‬

:‫ﻓﺮﻣﺖ ﻧﻮﺷﺘﺎري اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺻﻮرت زﻳﺮ اﺳﺖ‬
[no_of_char=] fprintf (file_name , print_pattern,variables);
: ‫ﻣﺜﺎل‬
main()
{
...
FILE *out;
...
out = fopen (“daneshju” , “w”);
...
fprintf(out, “%s %5.2f\n”, name, mark);
...
}

‫اﻟﮕﻮﻫﺎي ﻧﻮﺷﺘﻦ در ﭘﺮوﻧﺪه ﻣﺘﻨﻲ‬

‫اﻟﮕﻮ‬
‫اﻟﮕ‬ ‫ﻳﻚ ‪....‬‬
‫ﭼﺎپ ﻚ‬
‫ﺑﺮاي ﺎ‬
‫ا‬
‫‪%c‬‬ ‫ﻛﺎراﻛﺘﺮ‬
‫‪%i , %d‬‬ ‫ﻋﺪد ﺻﺤﻴﺢ در ﻣﺒﻨﺎي ده‬
‫‪%u‬‬ ‫رﻣﺒﻨﺎي دده‬
‫ﺖ و د ﻨﺎ‬
‫ﻋﻼﻣﺖ‬
‫ﺑﺪون ﻋﻼ‬
‫ﻋﺪد ﺻﺤﻴﺢ ﺪ‬
‫‪%o‬‬ ‫ﻋﺪد ﺻﺤﻴﺢ در ﻣﺒﻨﺎي ﻫﺸﺖ )‪(octal‬‬
‫‪%X , %x‬‬ ‫ﻋﺪد ﺻﺤﻴﺢ در ﻣﺒﻨﺎي ﺷﺎﻧﺰده )‪(Hex‬‬
‫‪%f‬‬ ‫ﻋﺪد اﻋﺸﺎري‬
‫اﻟﮕﻮﻫﺎي ﻧﻮﺷﺘﻦ در ﭘﺮوﻧﺪه ﻣﺘﻨﻲ )اداﻣﻪ(‬

‫اﻟﮕﻮ‬
‫اﻟﮕ‬ ‫ﻳﻚ ‪....‬‬
‫ﭼﺎپ ﻚ‬
‫ﺑﺮاي ﺎ‬
‫ا‬
‫‪%E , %e‬‬ ‫ﻋﺪد اﻋﺸﺎري ﺑﻪ ﺻﻮرت ﻧﻤﺎﺋﻲ‬
‫‪%G , %g‬‬ ‫ﻋﺪد اﻋﺸﺎري ﺑﻪ ﺻﻮرت ﻧﻤﺎﺋﻲ ﻳﺎ ﻣﻌﻤﻮﻟﻲ‬
‫‪%s‬‬ ‫ﺷﺘﻪ‬
‫رﺷﺘﻪ‬
‫‪%p‬‬ ‫اﺷﺎره ﮔﺮ ‪ /‬ﻧﺸﺎﻧﮕﺮ‬
‫‪%%‬‬ ‫ﻛﺎراﻛﺘﺮ ‪%‬‬

: ‫ﻣﺜﺎل‬
/* file example */
#include<stdio.h>
void main()
{
char name[20];
float mark;
FILE *out;
out = fopen (“Daneshju” , “w”);
if (out == NULL) /*the file is not open for a reason */ {
puts (“Cannot open output file !!!);
return; }
puts(“\nEnter ‘end’ to EXIT “)
“\n--------------------
\n “);
);
printf(“ Name : “);
scanf(“%s”, name);
while (strcmp(name , “end” )) {
printf (“ Mark : “); scanf (“%f”, &mark);
f i tf( t “%
fprintf(out, “%s %5
%5.2f\n”,
2f\ ” name , mark);
k)
printf(“\n Name : “);
scanf(“%s”, name);
}
}

: ‫اﺟﺮاي ﺑﺮﻧﺎﻣﻪ ﻣﺜﺎل ﻗﺒﻞ‬
Enter ‘end’ to EXIT
-------------------
Name : Reza
Mark : 19
Name : Ahmad
Mark : 18
Name : Mehdi
Mark : 16.5
Name : end

‫ﺣﺎل ﻣﻲ ﺗﻮاﻧﻴﻢ ﻓﺎﻳﻞ ‪ Daneshju‬را ﺑﺎ ﻳﻚ واژه ﭘﺮداز )ﻫﻤﺎﻧﻨﺪ‬

‫‪ (notepad‬ﺑﺎز ﻛﺮده و ﻳﺎ ﺑﺎ اﺳﺘﻔﺎده از ﺑﺮﻧﺎﻣﻪ ‪ type‬ﺳﻴﺴﺘﻢ‬
‫ﻴﻢ‪.‬‬
‫ﺑﺒﻴﻨﻴﻢ‬
‫ﻮر ﺑﺒﻴ‬
‫ﻣﺎﻧﻴﺘﻮر‬
‫ن ررا روي ﺻﻔﺤﻪ ﻴ‬
‫ي آن‬
‫ﻣﺤﺘﻮاي‬
‫ﻮ‬ ‫ﻞ‬
‫ﻋﺎﻣﻞ‪،‬‬
‫‪ -‬دﺳﺘﻮر ‪ TYPE‬؟‬

‫ﺗﺎﺑﻊ ﺧﻮاﻧﺪن از ﻓﺎﻳﻞ ﻣﺘﻨﻲ )‪(fscanf‬‬

‫;)‪[no_of_char=] fscanf (file_name , read_pattern,variables‬‬
‫اﺷﻜﺎﻟﻲ ﺑﻮﺟﻮد آﻳﺪ‪ ،‬ﻣﻘﺪار اﻳﻦ ﻣﺘﻐﻴﺮ ﺑﺮاﺑﺮ ‪ EOF‬و ﻳﺎ ‪ -1‬ﻣﻣﻲ ﺷﻮد‪.‬‬
‫اﮔﺮ ﻓﺎﻳﻞ ﺑﻪ ﭘﺎﻳﺎن ﺑﺮﺳﺪ‪ ،‬ﻳﺎ در ﺧﻮاﻧﺪن اﺷﻜﺎﻟ‬
‫)(‪main‬‬
‫{‬
‫‪...‬‬
‫;‪FILE *in‬‬
‫‪...‬‬
‫;)”‪in = fopen (“daneshju” , “r‬‬
‫‪...‬‬
‫‪f‬‬
‫‪fscanf(in,‬‬
‫‪f(i‬‬ ‫‪“%‬‬
‫\‪“%s %f‬‬
‫‪%f\n”,‬‬ ‫& ‪” name,‬‬ ‫;)‪&mark‬‬
‫)‪k‬‬
‫‪...‬‬
‫}‬

‫اﻟﮕﻮﻫﺎي ﺧﻮاﻧﺪن از ﭘﺮوﻧﺪه ﻣﺘﻨﻲ‬

‫اﻟﮕﻮ‬
‫اﻟﮕ‬ ‫ﻳﻚ ‪....‬‬
‫ﺧﻮاﻧﺪن ﻚ‬
‫ﺑﺮاي ﺧ اﻧ‬
‫ا‬
‫‪%c‬‬ ‫ﻛﺎراﻛﺘﺮ‬
‫‪%i‬‬ ‫ﻋﺪد ﺻﺤﻴﺢ در ﻣﺒﻨﺎي ده‪ ،‬ﺷﺎﻧﺰده و ﻫﺸﺖ‬
‫‪%d‬‬ ‫رﻣﺒﻨﺎي دده‬
‫ﻋﺪد ﺻﺤﻴﺢ د ﻨﺎ‬
‫‪%o‬‬ ‫ﻋﺪد ﺻﺤﻴﺢ در ﻣﺒﻨﺎي ﻫﺸﺖ )‪(octal‬‬
‫‪%x‬‬ ‫ﻋﺪد ﺻﺤﻴﺢ در ﻣﺒﻨﺎي ﺷﺎﻧﺰده )‪(Hex‬‬
‫‪%g , %e , %f‬‬ ‫ﻋﺪد اﻋﺸﺎري ﺑﻪ ﺻﻮرت ﻣﻌﻤﻮﻟﻲ و ﻳﺎ ﻧﻤﺎﺋﻲ‬
‫اﻟﮕﻮﻫﺎي ﺧﻮاﻧﺪن از ﭘﺮوﻧﺪه ﻣﺘﻨﻲ )اداﻣﻪ(‬

‫اﻟﮕﻮ‬
‫اﻟﮕ‬ ‫ﻳﻚ ‪....‬‬
‫ﺧﻮاﻧﺪن ﻚ‬
‫ﺑﺮاي ﺧ اﻧ‬
‫ا‬
‫‪%s‬‬ ‫رﺷﺘﻪ‬
‫‪%p‬‬ ‫اﺷﺎره ﮔﺮ ‪ /‬ﻧﺸﺎﻧﮕﺮ‬
‫][‪%‬‬ ‫ﻋﻪ ااي از ﻛﺎ اﻛﺘ ﻫﺎ‬
‫ﻛﺎراﻛﺘﺮﻫﺎ‬ ‫ﻣﺠﻤﻮﻋﻪ‬
‫‪%ld‬‬ ‫اﻋﺪاد ﺻﺤﻴﺢ ﺑﻠﻨﺪ‬
‫‪%lf‬‬ ‫اﻋﺪاد اﻋﺸﺎري دو دﻗﺘﻲ ﺑﻠﻨﺪ‬

‫اﻟﮕﻮي ][‪ ،%‬را ﺑﺮاي ﺧﻮاﻧﺪن رﺷﺘﻪ ﻫﺎ ﺑﻪ ﻛﺎر ﻣﻲ ﺑﺮﻳﻢ‪ .‬ﻛﺎراﻛﺘﺮﻫﺎﺋﻲ را ﻛﻪ‬
‫رﺷﺘﻪ ﺑﺎﻳﺪ ﺗﻨﻬﺎ از آن ﻫﺎ ﺳﺎﺧﺘﻪ ﺷﻮﻧﺪ را در ﻣﻴﺎن دو ﻛﺎراﻛﺘﺮ ] و [ ﻗﺮار ﻣﻲ‬
‫دﻫﻴﻢ‪.‬‬
‫‪ : %[abc] -‬ﻧﺸﺎن دﻫﻨﺪه آن اﺳﺖ ﻛﻪ رﺷﺘﻪ ﺑﺎﻳﺴﺘﻲ از ﻛﺎراﻛﺘﺮﻫﺎي ‪ a‬و ‪b‬‬
‫ﻛﺎر‬
‫ﺑﺎﺷﺪ‪ ،‬ﻛﺎ‬
‫ﻛﺎراﻛﺘﺮي ﺟﺰ ااﻳﻦ ﺎﺷ‬
‫داراي ﻛﺎ اﻛ‬
‫رﺷﺘﻪ ا ا‬
‫اﮔﺮ ﺷ‬ ‫ﺑﺎﺷﺪ‪ .‬اﮔ‬
‫ﺷﺪه ﺎﺷ‬ ‫و ‪ c‬ﺎﺧ‬
‫ﺳﺎﺧﺘﻪ ﺷ‬
‫ﺧﻮاﻧﺪن رﺷﺘﻪ ﺑﻪ ﭘﺎﻳﺎن رﺳﻴﺪه و ﺧﻮاﻧﺪن داده ﺑﻌﺪي ﺷﺮوع ﻣﻲ ﺷﻮد‪.‬‬
‫ﺷﺪه ﺎﺷﺪ‬ ‫ﻛﺎراﻛﺘﺮﻫﺎي ‪ a‬ﺗﺎ ‪ k‬ﺳﺎﺧﺘﻪ‬
‫ﺎﺧﺘﻪ ﺷﺪ‬ ‫ﺪ از ﻛﺎ اﻛﺘ ﻫﺎ‬
‫رﺷﺘﻪ ﺎﺑﺎﻳﺪ‬
‫ﻳﻌﻨﻲ ﺷﺘﻪ‬ ‫]‪ : %[a-k‬ﻨ‬
‫‪%[a k] -‬‬
‫‪ : %[^ijk] -‬ﻳﻌﻨﻲ رﺷﺘﻪ ﻣﻲ ﺗﻮاﻧﺪ از ﻫﺮ ﻛﺎراﻛﺘﺮي ﺟﺰ ﻛﺎراﻛﺘﺮﻫﺎي ‪ i‬و ‪ j‬و ‪k‬‬
‫ﺗﺸﻜﻴﻞ ﺷﺪه ﺑﺎﺷﺪ‪.‬‬
‫ﺗﺸﻜ ﻞ‬

: ‫ﻣﺜﺎل‬
/* file reading example */
#include<stdio.h>
void main()
{
char name[20];
float mark;
FILE *in;
in = fopen (“Daneshju” , “r”);
if (out == NULL) /*the file is not open for a reason */ {
puts (“Cannot open output file !!!);
return; }
puts(“\nName Mark “)
“\n-------------------- “);
while (!feof(in)) {
fscanf(in , “%s %f\n” , name , &mark);
printf(“%-20s %6.2f\n”, name , mark);
}
}

‫اﺟﺮاي ﺑﺮﻧﺎﻣﻪ ﻣﺜﺎل ﻗﺒﻞ ‪:‬‬

‫‪Name‬‬ ‫‪Mark‬‬
‫‪-------------------‬‬
‫‪R‬‬
‫‪Reza‬‬ ‫‪19 00‬‬
‫‪19.00‬‬
‫‪Ahmad‬‬ ‫‪18.00‬‬
‫‪Mehdi‬‬ ‫‪16.50‬‬

‫ﺗﺎﺑﻊ ﺑﺴﺘﻦ ﻓﺎﻳﻞ‬

‫ل‪:‬‬
‫ﻣﺜﺎل‬
‫)‪fclose(in‬‬

‫ﺗﺎﺑﻊ ﺧﻮاﻧﺪن ﻛﺎراﻛﺘﺮ از ﻓﺎﻳﻞ ‪:‬‬

‫‪[Variable = ] fgetc(file‬‬
‫;)‪fgetc(file_name‬‬
‫;)‪name‬‬
‫ﺧﻮاﻧﺪه‬
‫ﻛﺎراﻛﺘﺮ ﺧ اﻧ‬
‫ﻣﺘﻐﻴﺮي ااﺳﺖ ﻛﻛﻪ ﻛﺎ اﻛ‬
‫‪ variable‬ﻐ‬
‫ﻋﺒﺎرت‪i bl ،‬‬ ‫در ااﻳﻦ ﺎ‬
‫ﺷﺪه در آن ﻗﺮار ﻣﻲ ﮔﻴﺮد‪ .‬اﮔﺮ در ﺧﻮاﻧﺪن ﻓﺎﻳﻞ اﺷﻜﺎﻟﻲ ﭘﻴﺶ آﻳﺪ‬
‫ﭘﺎﻳﺎن‬
‫ﺖ ﺎﺎ‬‫ﺛﺎﺑﺖ‬
‫ﻣﻘﺪار ﺛﺎ‬
‫ﺑﺮاﺑﺮ ﺑﺎﺎ ﻘﺪا‬
‫ﻣﺘﻐﻴﺮ ا‬
‫ﻣﻘﺪار ﺘﻐ‬
‫ﺑﺮﺳﺪ‪ ،‬ﻘﺪا‬
‫ﭘﺎﻳﺎن ﺪ‬
‫ﺑﻪ ﺎ ﺎ‬
‫ﻓﺎﻳﻞ ﻪ‬
‫ﻳﺎ ﻓﺎ ﻞ‬
‫و ﺎ‬
‫ﭘﺮوﻧﺪه )‪ (EOF‬ﻣﻲ ﺷﻮد‪.‬‬
‫ﺗﺬﻛﺮ ‪ :‬ﭘﺮوﻧﺪه ﺑﺎﻳﺴﺘﻲ ﺑﺮاي ﺧﻮاﻧﺪن و ﻳﺎ ﺑﻪ روز ﺷﺪن ﺑﺎز ﺷﺪه‬
‫ اﻳﺠﺎد ﺷﺪ‬notepad ‫ ﺧﻮاﻧﺪن اﻃﻼﻋﺎت ﻓﺎﻳﻠﻲ ﻛﻪ ﺑﺎ‬،‫ ﺧﻮاﻧﺪن ﻧﺎم ﻓﺎﻳﻞ از ورودي‬: ‫ﻣﺜﺎل‬
(‫ )ﺑﺮﻧﺎﻣﻪ اﺟﺮا ﺷﺪه ﻛﭙﻲ ﺷﺪ‬.‫و ﻧﻤﺎﻳﺶ آن روي ﺻﻔﺤﻪ ﻣﺎﻧﻴﺘﻮر‬
#include<stdio.h>
i t main()
int i ()
{
int ch;
char fname[20];
FILE *t
*tele;
l
printf("\nFile Name : ");
gets(fname);
puts("------------------");
tele = fopen(fname , "rb")
"rb");
if (tele==NULL) {
puts("Cannot open Input File !!!");
return 0;
}
while ((ch=fgetc(tele)) != EOF)
putchar(ch);
}

‫ﺗﺎﺑﻊ ﻧﻮﺷﺘﻦ رﺷﺘﻪ در ﻓﺎﻳﻞ ‪:‬‬
‫ﺗﺬﻛﺮ ‪ :‬ﺑﺮاي اﺳﺘﻔﺎده از اﻳﻦ ﺗﺎﺑﻊ‪ ،‬ﻓﺎﻳﻞ ﺑﺎﻳﺴﺘﻲ ﺑﻪ ﺻﻮرت ﻧﻮﺷﺘﻦ‪،‬‬

‫ﻛﺮدن‪ ،‬ﺑﺎز ﺷﺪه ﺑﺎﺷﺪ‪.‬‬
‫ﻛﺮدن و ﻳﺎ ﺑﻪ روز ن‬
‫اﻟﺤﺎق ن‬
‫)‪fputs (str, fstr‬‬
‫ﺷﻮد‪.‬‬
‫ﻧﻮﺷﺘﻪ ﻣﻲ ﻮ‬‫‪ fstr‬ﻮ‬
‫ﻳﻞ ‪st‬‬ ‫‪ st‬درر ﻓﺎﻳﻞ‬
‫ل‪ ،‬ررﺷﺘﻪ ‪str‬‬‫در اﻳﻦ ﻣﻣﺜﺎل‪،‬‬
‫ر‬
‫)‪fgets (str , 80 , fstr‬‬

‫ﻋﺒﺎرت ﺑﺎﻻ‪ ،‬ﺗﻌﺪاد ﺣﺪاﻛﺜﺮ ‪ 80‬ﻛﺎراﻛﺘﺮ از ﻓﺎﻳﻞ ‪ fstr‬ﺧﻮاﻧﺪه و در‬
‫ﻣﺘﻐﻴﺮ ‪ str‬ﻗﺮار ﻣﻣﻲ دﻫﺪ‪.‬‬
: ‫ﻣﺜﺎل‬
#include<stdio.h>
int main()
{
int ch;
char str[81];
FILE *fstr; Running Program
fstr = fopen(“string”
fopen( string , “wb");
wb );
Enter some string
if (tele == NULL) {
puts("Cannot open Input File !!!"); <^z to exit >
return 0; -------------------------
}
Welcome
puts(“Enter some string”
“\n <^z to exit >“ To
“\n----------------”); C
while (gets(str)) != NULL)
Textbook
fputs(str, fstr);
fputs(“\n” , fstr); !
} ^z

‫ﺗﻮاﺑﻊ ﭘﺮدازش ﻓﺎﻳﻞ ﻫﺎي رﻛﻮردي‬
‫‪ -1‬ﻧﻮﺷﺘﻦ در ﻓﺎﻳﻞ )‪(fwrite‬‬

‫ﻓﺮﻣﺖ ﻧﻮﺷﺘﺎري اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺻﻮرت زﻳﺮ اﺳﺖ‪:‬‬
‫ﻣﺘﻐﻴﺮ[‬
‫‪ =] fwrite‬ﻐ‬
‫اﺷﺎره ﮔﮔﺮ ( ‪f it‬‬
‫رﻛﻮرد ‪ ،‬اﺷﺎ‬
‫ﻃﻮل ﻛ‬
‫رﻛﻮردﻫﺎ ‪ ،‬ﻃ ل‬
‫ﺎ‬ ‫ﺗﻌﺪاد ﻛ‬
‫ﻓﺎﻳﻞ ‪ ،‬ا‬
‫)ﻧﺎﻧﺎم ﻓﺎ ﻞ‬
‫)‪fwrite (&danesh , sizeof danesh , 1 , out‬‬
‫ﺗﺬﻛﺮ ‪ :‬اﻳﻦ ﻓﺎﻳﻞ ﺑﺎﻳﺴﺘﻲ ﺑﻪ ﺷﻴﻮه ﻧﻮﺷﺘﻦ‪ ،‬اﻟﺤﺎق ﻛﺮدن و ﺑﻪ روز ﻛﺮدن ﺑﺎز ﺷﺪه ﺑﺎﺷﺪ‪.‬‬
‫اﺷﺎره ﮔﺮ ‪ :‬ﻫﻤﺎن ﻧﺸﺎﻧﻲ واﺳﻄﻲ اﺳﺖ ﻛﻪ رﻛﻮردﻫﺎ در آن ﻗﺮار دارد‪.‬‬
‫ﻓﺎﻳﻞ )‪(fread‬‬ ‫ﺧﻮاﻧﺪن از ﻓﺎ ﻞ‬

‫‪ -2‬ﺧ اﻧ‬
‫ﻓﺮﻣﺖ ﻧﻮﺷﺘﺎري اﻳﻦ ﺗﺎﺑﻊ ﺑﻪ ﺻﻮرت زﻳﺮ اﺳﺖ‪:‬‬
‫)ﻧﺎم ﻓﺎﻳﻞ ‪ ،‬ﺗﻌﺪاد رﻛﻮردﻫﺎ ‪ ،‬ﻃﻮل رﻛﻮرد ‪ ،‬اﺷﺎره ﮔﺮ ( ‪ =] fread‬ﻣﺘﻐﻴﺮ[‬

‫ﺗﻮاﺑﻊ دﻳﮕﺮ ﻛﺎر ﺑﺎ ﻓﺎﻳﻞ ‪:‬‬
‫‪-‬ﺟﺴﺘﺠﻮي ﻓﺎﻳﻞ )‪(fseek‬‬

‫ﻓﺎﻳﻞ )‪ft ll‬‬
‫‪(ftell‬‬ ‫ش ﻓﺎ ﻞ‬‫ﮔﺰارش‬‫‪-‬ﮔ ا‬
‫‪-‬ﻧﻤﺎﻳﺎﻧﮕﺮ اﺷﻜﺎل در ﻓﺎﻳﻞ )‪(ferror‬‬
‫‪-‬ﭘﺎك ﻛﺮدن ﻓﺎﻳﻞ )‪(remove‬‬
‫ﻳﻞ )‪(rename‬‬ ‫‪ -‬ﻴﻴﺮ‬
‫ﺗﻐﻴﻴﺮ ﻧﺎمم ﻓﺎﻳﻞ‬

fseek ‫ﻓﺎﻳﻞ ﺑﺑﺎ ااﺳﺘﻔﺎده از‬
‫ﮔﺮ ﻳﻞ‬‫اﺷﺎره ﺮ‬
‫ﺣﺮﻛﺖ ا ر‬
‫ﺮ‬
• int fseek ( FILE * stream,, long
g int offset,, int origin
g );
• Parameters
stream Pointer to a FILE object that identifies the stream.
offset Number of bytes to offset from origin.
origin Position from where offset is added.
It is specified by one of the following constants defined in <cstdio>:
SEEK_SET Beginning of file

SEEK_CUR Current position of the file pointer
S
SEEK_END End off file
f
fseek ‫ﻳﻚ ﻣﺜﺎل از‬
.‫ اﺳﺖ‬fileseek ‫ ﻧﺎم ﻓﺎﻳﻞ اﺟﺮاﺋﻲ‬.‫ ﭘﻴﺎده ﺳﺎزي و ﺗﺴﺖ ﺷﺪه اﺳﺖ‬dev cpp ‫اﻳﻦ ﺑﺮﻧﺎﻣﻪ ﺑﺎ‬
/* fseek example */
#include <stdio.h>
int main ()
{
FILE * pFile;
ppFile = fopen
p ( "example.txt"
p , "w" ));
fputs ( "This is an apple." , pFile );
fseek ( pFile , 9 , SEEK_SET );
fputs
p ( " sam" , ppFile );
fclose ( pFile );
return 0;
}

‫ﺗﻮاﺑﻊ دﻳﮕﺮ ﻛﺎر ﺑﺎ ﻓﺎﻳﻞ‬
• See also
ftell Get current position in stream (function)
fsetpos Set position indicator of stream (function)
rewind
i d S t position
Set iti iindicator
di t tto ththe b
beginning
i i (f (function)
ti )
#include <stdio.h>
i t fseek
int f k (FILE **stream,
t llong offset,
ff t int
i t whence)
h )
long ftell (FILE *stream)
void rewind (FILE *stream)
i t fgetpos
int f t (FILE * restrict
t i t stream,
t f
fpos_t t * restrict
t i t pos))
int fsetpos (FILE *stream, const fpos_t *pos)

‫ﺗﻤﺮﻳﻨﺎت ﭘﺎﻳﺎن ﻓﺼﻞ‬

‫ﻧﺎم‪ ،‬ﻧﺎمم‬
‫داﻧﺸﺠﻮﺋﻲ‪ ،‬م‬
‫ﺠﻮ ﻲ‬ ‫ﺷﻤﺎره‬
‫ر‬ ‫ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ اﻃﻼﻋﺎت‬
‫اي ﺑ ﻮﻳ ﻴ‬ ‫‪ -1‬ﺑﺮ‬
‫ﺑﺮﻧﺎﻣﻪ ي‬
‫ﺧﺎﻧﻮادﮔﻲ و ﻧﻤﺮه ﻣﻴﺎن ﺗﺮم‪ ،‬ﭘﺎﻳﺎن ﺗﺮم و ﺗﻜﺎﻟﻴﻒ را از ﻳﻚ ﻓﺎﻳﻞ‬
‫ﻧﻮﺷﺘﻪ ﺷﺪه‬ ‫ﻓﺎﻳﻞ ﻮ‬
‫از ﻳﻞ‬‫ﺺ درر ﻳﻳﻚ ﺳﻄﺮﺮ ز‬
‫ﺧﻮاﻧﺪه )اﻃﻼﻋﺎت ﻫﺮﺮ ﺷﺨﺺ‬ ‫ﻮ‬
‫اﺳﺖ( و آن را در ﻳﻚ ﺟﺪول ﺑﺎ ﺷﻜﻠﻲ ﻣﻨﺎﺳﺐ روي ﻣﺎﻧﻴﺘﻮر ﻧﻤﺎﻳﺶ‬
‫دﻫﻴﺪ‪.‬‬
‫ﻴ‬
‫‪ -2‬ﻳﻚ دﻓﺘﺮﭼﻪ ﺗﻠﻔﻦ ﺑﺴﺎزﻳﺪ‪.‬‬

‫ﻓﺼﻞ ده‬
‫ﺳﺎﺧﺘﺎر‬
‫ﺳﺎﺧﺘﺎ‬
‫‪Structure‬‬

‫ﺳﺎﺧﺘﺎر ﭼﻴﺴﺖ؟‬
‫ﻗﺒﻞ از ﺗﻌﺮﻳﻒ ﺳﺎﺧﺘﺎر‪ ،‬اﺑﺘﺪا ﺗﻌﺮﻳﻔﻲ از ﻳﻚ ﻣﻮﺟﻮدﻳﺖ و وﻳﮋﮔﻲ ﻫﺎي آن‬
‫اراﺋﻪ ﻣﻲ ﻛﻛﻨﻴﻢ‪.‬‬
‫ا اﺋ‬
‫ﻣﻮﺟﻮدﻳﺖ ‪ :‬ﺑﻪ ﻫﺮ ﺷﺌﻲ‪ ،‬ﻣﻮﺟﻮد و ﻳﺎ ﻣﻔﻬﻮم ﺟﻬﺎن اﻃﺮاف ﺧﻮد‪ ،‬ﻳﻚ‬
‫ﻣﻮﺟﻮدﻳﺖ ﻣﻣﻲ ﮔﻮﺋﻴﻢ‪.‬‬
‫‪ -1‬ﻣﻮﺟﻮدﻳﺖ ﺻﻨﺪﻟﻲ‬
‫‪ -2‬ﻣﻮﺟﻮدﻳﺖ اﻧﺴﺎن‬
‫ﻣﻮﺟﻮدﻳﺖ داﻧﺸﺠﻮ‬
‫ﺠﻮ‬ ‫‪ -3‬ﻮﺟﻮ ﻳ‬
‫‪ -4‬ﻣﻮﺟﻮدﻳﺖ ﺻﻔﺤﻪ ﻧﻤﺎﻳﺶ‬
‫ﻣﻮﺟﻮدﻳﺖ درس‬
‫رس‬ ‫‪ -5‬ﻮﺟﻮ ﻳ‬
‫وﻳﮋﮔﻲ ﻫﺎي ﻳﻚ ﻣﻮﺟﻮدﻳﺖ ‪:‬‬

‫ﺗﻮاﻧﺪ‬
‫ﻣﻲ ﻮ‬
‫ﻧﻈﺮ ﻣﺎ ﻲ‬
‫از ﺮ‬‫وﻳﮋﮔﻲ اﺳﺖ ﻛﻪ ز‬
‫ﺳﺮي وﻳﮋ ﻲ‬ ‫ي ﻳﻳﻚ ﺮي‬ ‫داراي‬
‫ﻣﻮﺟﻮدﻳﺖ ر‬
‫ﻫﺮﺮ ﻮﺟﻮ ﻳ‬
‫ﺑﻌﻀﻲ از آن ﻫﺎ در ارﺗﺒﺎط ﺑﺎ ﻛﺎري ﻛﻪ اﻧﺠﺎم ﻣﻲ دﻫﻴﻢ‪ ،‬ﺣﺎﺋﺰ اﻫﻤﻴﺖ‬
‫ﺑﺑﺎﺷﺪ‪.‬‬
‫وﻳﮋﮔﻲ ﻫﺎي ﺻﻨﺪﻟﻲ ‪:‬‬
‫آﻣﻮزﺷﻲ و (‬
‫‪(.....‬‬ ‫اداري‪ ،‬آ زﺷ‬ ‫ﺻﻨﺪﻟﻲ )ادا‬
‫ﻛﺎرﺑﺮد ‪ /‬ﻧﻧﻮع ﻨﺪﻟ‬
‫‪ -1‬ﻛﺎ د‬
‫‪ -2‬رﻧﮓ ﺻﻨﺪﻟﻲ‬
‫‪ -3‬ﺟﻨﺲ ﺻﻨﺪﻟﻲ )ﻓﻠﺰي‪ ،‬ﭼﻮﺑﻲ و ‪(......‬‬
‫‪...... -4‬‬
‫ﻣﻮﺟﻮدﻳﺖ درس ‪:‬‬

‫‪ -1‬ﻧﺎمم درس‬
‫رس‬
‫‪ -2‬ﻛﺪ درس‬
‫ﺶ ﻧ ﺎز‬
‫ﻧﻴﺎز‬ ‫‪ -3‬ﻛﺪ ددرس ﭘﻴﺶ‬
‫‪ -4‬ﺗﻌﺪاد واﺣﺪ‬
‫‪ -5‬ﻧﻮع درس )ﺗﺌﻮري ‪ /‬ﻋﻤﻠﻲ(‬
‫‪....... -6‬‬

‫وﻳﮋﮔﻲ ﻫﺎي ﻣﻮﺟﻮدﻳﺖ داﻧﺸﺠﻮ )از ﻧﮕﺎه اﻃﻼﻋﺎت ﻓﺮدي(‬
‫‪ -1‬ﺷﻤﺎره داﻧﺸﺠﻮﺋﻲ‬
‫‪ -2‬ﻧﺎﻧﺎم‬
‫‪ -3‬ﻧﺎم ﺧﺎﻧﻮادﮔﻲ‬
‫‪ -4‬ﺷﻤﺎره ﺷﻨﺎﺳﻨﺎﻣﻪ‬
‫‪ -5‬ﺳﺎل ﺗﻮﻟﺪ‬
‫‪ -6‬ﻛﺪ رﺷﺘﻪ ﺗﺤﺼﻴﻠﻲ‬
‫‪ -7‬ﻣﻌﺪل دوره دﺑﻴﺮﺳﺘﺎن‬
‫‪ -8‬رﺗﺒﻪ ﻛﻨﻜﻮر‬
‫‪ -9‬ﻗﻗﺪ‬
‫‪ -10‬وزن‬
‫‪...... -11‬‬
‫وﻳﮋﮔﻲ ﻫﺎي داﻧﺸﺠﻮ )از ﻧﻈﺮ اﻃﻼﻋﺎت ﺗﺮﻣﻲ(‬

‫‪ -1‬ﺷﻤﺎره داﻧﺸﺠﻮ‬
‫‪ -2‬ﻛﺪ درس‬
‫ﺮم اول‬
‫ﻣﻴﺎن ﺗﺮم‬
‫ﻧﻤﺮه ﻴ ن‬
‫‪ -3‬ﺮ‬
‫‪ -4‬ﻧﻤﺮه ﻣﻴﺎن ﺗﺮم دوم‬
‫‪ -5‬ﻧﻤﺮه ﺗﻜﺎﻟﻴﻒ‬
‫‪ -6‬ﻧﻤﺮه ﭘﺎﻳﺎن ﺗﺮم‬
‫ﻧﻬﺎﺋﻲ‬
‫‪ -7‬ﻧﻧﻤﺮه ﻧ ﺎﺋ‬
‫‪ -8‬وﺿﻌﻴﺖ داﻧﺸﺠﻮ )ﻋﺎدي‪ ،‬ﻣﺤﺮوم و ‪(.....‬‬

‫ﻫﻤﺎﻧﮕﻮﻧﻪ ﻛﻪ ﻣﻲ ﺑﻴﻨﻴﻢ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻛﺎرﺑﺮد ﻳﻚ ﻣﻮﺟﻮدﻳﺖ‪ ،‬وﻳﮋﮔﻲ‬

‫ﻫﺎي ﺧﺎﺻﻲ از آن را ﺑﺎﻳﺪ درﻧﻈﺮ ﺑﮕﻴﺮﻳﻢ‪ .‬وﻳﮋﮔﻲ ﻫﺎي ﻣﻮرد ﻧﻈﺮ از‬
‫‪ (Types‬داده اي‬
‫‪T‬‬ ‫ﻳﻚ ﻣﻮﺟﻮدﻳﺖ ﻣﻲ ﺗﻮاﻧﻨﺪ داراي ﺗﺎﻳﭗ ﻫﺎي )‬
‫ﮔﻮﻧﺎﮔﻮن ﺑﺎﺷﻨﺪ‪ .‬ﺑﻪ ﻃﻮر ﻣﺜﺎل ‪:‬‬
‫ﻣﻮﺟﻮدﻳﺖ درس ‪:‬‬
‫‪ -1‬ﻧﺎم درس )رﺷﺘﻪ(‬
‫‪ -2‬ﻛﺪ درس )رﺷﺘﻪ ‪ /‬ﺻﺤﻴﺢ ﭼﻬﺎر ﺑﺎﻳﺘﻲ ﺑﺪون ﻋﻼﻣﺖ(‬
‫‪ -3‬ﻛﺪ درس ﭘﻴﺶ ﻧﻴﺎز )رﺷﺘﻪ ‪ /‬ﺻﺤﻴﺢ ﭼﻬﺎر ﺑﺎﻳﺘﻲ ﺑﺪون ﻋﻼﻣﺖ(‬
‫‪ -4‬ﺗﻌﺪاد واﺣﺪ )ﺻﺤﻴﺢ(‬
‫ﻲ(‬
‫دودوﺋﻲ‬
‫ﻣﻘﺪار و و‬
‫ﻲ( ) ر‬ ‫ﻮري ‪ /‬ﻋﻤﻠﻲ‬
‫رس )ﺗﺌﻮري‬ ‫‪ -5‬ﻮع‬
‫ﻧﻮع درس‬
‫و ﻳﺎ ﻣﻮﺟﻮدﻳﺖ داﻧﺸﺠﻮ در ﺗﺮم ‪:‬‬

‫ن ﻋﻼﻣﺖ(‬
‫ﺑﺎﻳﺘﻲ ﺑﺪون‬
‫ﺻﺤﻴﺢ ﭼﻬﺎر ﻲ‬ ‫ﺢ‬ ‫‪ -1‬ﺷﻤﺎره داﻧﺸﺠﻮ )رﺷﺘﻪ ‪/‬‬
‫‪ -2‬ﻛﺪ درس )رﺷﺘﻪ ‪ /‬ﺻﺤﻴﺢ ﭼﻬﺎر ﺑﺎﻳﺘﻲ ﺑﺪون ﻋﻼﻣﺖ(‬
‫ﻴﺢ(‬
‫ﺮم اول ) ﺻﺤﻴﺢ‬
‫ﻣﻴﺎن ﺗﺮم‬
‫ﻧﻤﺮه ﻴ ن‬
‫‪ -3‬ﺮ‬
‫‪ -4‬ﻧﻤﺮه ﻣﻴﺎن ﺗﺮم دوم )ﺻﺤﻴﺢ(‬
‫‪ -5‬ﻧﻤﺮه ﺗﻜﺎﻟﻴﻒ )ﺻﺤﻴﺢ(‬
‫‪ -6‬ﻧﻤﺮه ﭘﺎﻳﺎن ﺗﺮم )ﺻﺤﻴﺢ(‬
‫اﻋﺸﺎري(‬
‫ﻧﻬﺎﺋﻲ )ا ﺸﺎ‬
‫‪ -7‬ﻧﻧﻤﺮه ﻧ ﺎﺋ‬
‫‪ -8‬وﺿﻌﻴﺖ داﻧﺸﺠﻮ )ﻋﺎدي‪ ،‬ﻣﺤﺮوم و ‪) (.....‬ﺻﺤﻴﺢ(‬

‫ﺣﺎل ﻣﺠﻤﻮﻋﻪ اي از داده ﻫﺎ را در اﺧﺘﻴﺎر دارﻳﻢ ﻛﻪ ﻣﺘﻌﻠﻖ ﺑﻪ ﻳﻚ ﻣﻮﺟﻮدﻳﺖ ﺑﻮده و ﺿﻤﻨﺎ‬
‫داراي ﺗﺎﻳﭗ ﻫﺎي داده اي ﻣﺘﻔﺎوت ﻣﻲ ﺑﺎﺷﻨﺪ‪.‬‬
‫در زﺑﺎن ‪ ،c‬ﺑﻪ ﻣﻮﺟﻮدﻳﺖ‪ ،‬ﺳﺎﺧﺘﺎر )‪ (Structure‬ﮔﻔﺘﻪ ﻣﻣﻲ ﺷﻮد و ﺑﻪ ﻫﺮ ﻳﻚ از وﻳﮋﮔ‬
‫وﻳﮋﮔﻲ‬
‫ﻫﺎي ﻳﻚ ﻣﻮﺟﻮدﻳﺖ ‪ /‬ﺳﺎﺧﺘﺎر‪ ،‬ﻋﻨﺼﺮ )‪ (element‬ﮔﻔﺘﻪ ﻣﻲ ﺷﻮد‪.‬‬
‫ﺗﺬﻛﺮ ‪ :‬ﺑﻪ ﺳﺎﺧﺘﺎر‪ ،‬رﻛﻮرد ﻫﻢ ﮔﻔﺘﻪ ﻣﻲ ﺷﻮد‪.‬‬
‫ﺑﺮاي ﺗﻌﺮﻳﻒ ﺳﺎﺧﺘﺎر در زﺑﺎن ‪ ،c‬دارﻳﻢ‪:‬‬
‫‪struct [ struct‬‬
‫]‪struct_code‬‬
‫{ ]‪code‬‬
‫;‪data_type1 element1‬‬
‫;‪data type2 element2‬‬
‫‪data_type2‬‬
‫‪…….‬‬
‫‪} struct‬‬
‫;‪struct_name‬‬
‫;‪name‬‬
‫{ ‪struct‬‬
‫;‪int stno‬‬
‫;]‪char name[20‬‬ ‫] [‬
‫;‪float avg‬‬
‫;‪} student‬‬ ‫;‬
‫در اﻳﻦ ﻣﺜﺎل ﺳﺎﺧﺘﺎري ﺑﺎ ﻧﺎم ‪ student‬ﺗﻌﺮﻳﻒ ﻛﺮدﻳﻢ ﻛﻪ ﺷﺎﻣﻞ ﻋﻨﺎﺻﺮ‪:‬‬
‫ﺻﺤﻴﺢ‪..‬‬
‫‪-‬ﺷﻤﺎره داﻧﺸﺠﻮﺋﻲ ﺑﺎ ﻧﻮع داده اي ﺻﺤﻴﺢ‬
‫‪ -‬ﻧﺎم داﻧﺸﺠﻮ‪ ،‬ﻛﻪ ﻣﻤﺘﻐﻴﺮي ‪ 20‬ﻛﺎراﻛﺘﺮي ﻣﻲ ﺑﺎﺷﺪ‪.‬‬
‫‪-‬ﻣﻴﺎﻧﮕﻴﻦ‪ ،‬ﻛﻪ از ﻧﻮع اﻋﺸﺎري اﺳﺖ‪.‬‬
‫ﺑﺮاي ﺗﻌﺮﻳﻒ ﺻﻔﺤﻪ ﻗﺒﻞ‪ ،‬ﺳﺎﺧﺘﺎري در ﺣﺎﻓﻈﻪ ﺑﺎ ﻧﺎم ‪، student‬‬

‫ﻢ‪.‬‬
‫ﻧﻤﻮدﻳﻢ‬
‫ﻣﺮﺑﻮﻃﻪ اﻳﺠﺎد ﻮ‬
‫ﺻﻮرت ززﻳﺮﺮ و ﺑﺎ ﻋﻨﺎﺻﺮﺮ ﺮ ﻮ‬
‫ﺑﻪ ﻮر‬
‫‪stno‬‬ ‫‪name‬‬ ‫‪avg‬‬
‫‪student‬‬

‫ﻣﻘﺪار دﻫﻲ ﺑﻪ ﻋﻨﺎﺻﺮ ﻳﻚ ﺳﺎﺧﺘﺎر ‪:‬‬

‫ﺑﺮاي ﻣﺮاﺟﻌﻪ ﺑﻪ ﻋﻨﺎﺻﺮ ﻳﻚ ﻣﺘﻐﻴﺮ ﺳﺎﺧﺘﺎري‪ ،‬اﺑﺘﺪا ﻧﺎم ﻣﺘﻐﻴﺮ ﺳﺎﺧﺘﺎر‪ ،‬ﺳﭙﺲ‬
‫ﻋﻤﻠﮕﺮ ﻧﻘﻄﻪ و ﭘﺲ از آن ﻧﺎم ﻋﻨﺼﺮ را ﻣﻲ ﻧﻮﻳﺴﻴﻢ‪.‬‬
‫ﺗﺬﻛﺮ ‪ :‬ﻫﺮ آن ﭼﻪ در ﻣﻮرد ﻣﺘﻐﻴﺮﻫﺎي ﻣﻌﻤﻮﻟﻲ داﺷﺘﻪ اﻳﻢ‪ ،‬در ﻣﻮرد اﻳﻦ ﻧﻮع از‬
‫ﻣﺘﻐﻴﺮﻫﺎ ﻧﻴﺰ ﺻﺎدق اﺳﺖ‪ .‬ﺗﻨﻬﺎ ﺗﻔﺎوت در ﻧﺤﻮه ارﺟﺎع ﺑﻪ آآن ﻫﺎ اﺳﺖ‪.‬‬
‫;‪student.stno = 7318‬‬
‫;”‪student.name = “Ali Mousavi‬‬
‫;‪student.avg = 18.25‬‬
‫ﺳﻮال ‪ :‬آﻳﺎ ﻋﺒﺎرات ﺑﺎﻻ ﺻﺤﻴﺢ اﺳﺖ؟‬
: ‫ﻋﺒﺎرات ﺻﺤﻴﺢ ﻣﺜﺎل ﻗﺒﻞ‬

student.stno
student stno = 7318;
strcpy(student.name, “Ali Mousavi”);
g = 18.25;
student.avg
‫ ﺑﻪ‬student ‫ ﻣﻘﺎدﻳﺮ در ﻣﺘﻐﻴﺮ ﺳﺎﺧﺘﺎري‬،‫ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻣﺜﺎل ﺑﺎﻻ‬
: ‫ﺑﻮد‬
‫ﺧﻮاﻫﺪ ﺑﻮ‬
‫ﺻﻮرت زﻳﺮ ﻮ‬
‫ﻮر‬
stno
t name avg
7318 Ali Mousavi 18.25

student

.‫ در ﺑﺮﻧﺎﻣﻪ زﻳﺮ ﺳﺎﺧﺘﺎر ﻣﺜﺎل ﻗﺒﻞ را ﭼﺎپ ﻛﺮده اﻳﻢ‬: ‫ﻣﺜﺎل‬
/* P10.1 Structures */
#include <stdio.h>
main()
i () {
struct {
int stno;
char name[20];
[ ];
float avg;
} student;
student.stno = 7318;
strcpy(student name “Ali Mousavi”);
strcpy(student.name,
student.avg = 18.25;
printf(“%d %s %.2f\n”,student.stno,student.name,student.avg);
}
Running Program

: ‫ ﻣﺜﺎل‬.‫ ﻣﻘﺪار ﺑﺪﻫﻴﻢ‬،‫ﻣﻲ ﺗﻮاﻧﻴﻢ ﺑﻪ ﻋﻨﺎﺻﺮ ﻳﻚ ﺳﺎﺧﺘﺎر در ﻫﻤﺎن زﻣﺎن ﺗﻌﺮﻳﻒ‬
/* P10.2 Structures */
#include <stdio.h>
main()
i () {
struct {
int stno;
char name[20];
[ ];
float avg;
} student = {
7318,
“Ali Mousavi”
Mousavi”,
“18.25”
}
}
Running Program
18 25

:‫ ﻣﺜﺎل‬.‫ﻋﻨﺎﺻﺮ ﻳﻚ ﺳﺎﺧﺘﺎر ﻣﻲ ﺗﻮاﻧﻨﺪ از ورودي ﻣﻘﺪار ﺑﮕﻴﺮﻧﺪ‬
/* P10.3 Structure reading from keyboard */
#include <stdio.h>
main() {
struct {
int stno;
char name[20];
float avg;
} student;
printf(“Enter Num Name Average : “);
scanf(“%d
scanf( %d %s %f
%f”,
, &student.stno,student.name,&student.ang);
}
Running
i Program
Enter Num Name Average : 7318 Ali.Mousavi 18.25
7318 Ali.Mousavi 18.25
.‫ﻧﻤﺎﺋﻴﺪ‬
‫ﺗﻮﺟﻪ ﻴ‬‫ﻲ ﻮﺟ‬
‫ﺧﺎﻧﻮادﮔﻲ‬
‫ﻧﺎم ﻮ‬‫ﻧﺎم و م‬
‫ﻛﺎراﻛﺘﺮ ﻧﻘﻄﻪ ﺑﻴﻦ م‬
‫ ﺑﺑﻪ ر ﺮ‬: ‫ﺗﺬﻛﺮﺮ‬

‫ﺑﻬﺘﺮ اﺳﺖ ﻛﻪ ﺑﺮاي ﺧﻮاﻧﺪن ﻣﻘﺎدﻳﺮ‪ ،‬ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ اﻟﮕﻮي ﭘﻴﻤﺎﻳﺶ) در ﺻﻔﺤﻪ ﻗﺒﻞ‪ ،‬در اﻟﮕﻮي‬
‫ﭘﻴﻤﺎﻳﺶ ﺑﺮاي ﺟﺪاﺳﺎزي ﻣﻘﺎدﻳﺮ ورودي ﺑﺮاي ﻋﻨﺎﺻﺮ‪ ،‬از ﻛﺎراﻛﺘﺮ ﻓﺎﺻﻠﻪ اﺳﺘﻔﺎده ﻛﺮدﻳﻢ(‪،‬‬
‫ﺑﻪ ﺟﺎي ﺣﺮف ﻓﺎﺻﻠﻪ از ﻛﺎراﻛﺘﺮ ﺑﺎ ﻛﺪ اﺳﻜﻲ ‪ 255‬اﺳﺘﻔﺎده ﻛﻨﻴﻢ و ﻳﺎ اﻳﻦ ﻛﻪ ﻣﻘﺎدﻳﺮ را ﺑﻪ‬
‫ﺑﺨﻮاﻧﻴﻢ ‪:‬‬
‫ﻣﻨﻔﺮد ﺨ اﻧ‬
‫ﺻﻮرت ﻨﻔ‬
‫‪...‬‬
‫‪printf(“\nEnter‬‬
‫‪i tf(“\ E t‬‬ ‫‪St‬‬
‫‪Student‬‬
‫‪d t S‬‬
‫‪Specification\n‬‬
‫‪ifi ti \ Number‬‬
‫‪N b‬‬ ‫;”‪:‬‬
‫”‬
‫;)‪scanf(“%d” , &student.stno‬‬
‫;)“ ‪printf(“ Name :‬‬
‫”‪scanf(“%s‬‬
‫(‪scanf‬‬ ‫;)‪%s , student.name‬‬
‫;)‪student name‬‬
‫;)“ ‪printf(“ Average :‬‬
‫;)‪scanf(“%f” , &student.avg‬‬
‫‪...‬‬
‫‪...‬‬

‫ﺗﻌﺮﻳﻒ ﺳﺎﺧﺘﺎر ﺑﻪ ﮔﻮﻧﻪ دﻳﮕﺮ‪:‬‬

‫{ ‪struct student‬‬
‫;‪int stno‬‬
‫;]‪char name[20‬‬ ‫] [‬
‫;‪float avg‬‬
‫;}‬
‫;‪struct student stud‬‬
‫در اﻳﻦ ﻣﺜﺎل‪ stud ،‬ﻣﺘﻐﻴﺮي اﺳﺖ ﺳﺎﺧﺘﺎري‪ ،‬ﻛﻪ ﻛﺪ آن ‪student‬‬
‫ﻣﻴﺒﺎﺷﺪ‪ .‬ﭘﺲ از اﻳﻦ ﺗﻌﺮﻳﻒ ﻣﻲ ﺗﻮاﻧﻴﻢ ﻫﻤﺎﻧﻨﺪ ﻣﺜﺎل ﻫﺎﺋﻲ ﻛﻪ ﭘﻴﺶ از اﻳﻦ‬
‫دﻳﺪﻳﻢ‪ ،‬ﻣﺘﻐﻴﺮ ﺳﺎﺧﺘﺎري ‪ stud‬را ﺑﻪ ﻛﺎر ﺑﺮﻳﻢ‪.‬‬
‫اﺳﺘﻔﺎده از ﻣﺘﻐﻴﺮﻫﺎي ﺳﺎﺧﺘﺎري در ﺣﻠﻘﻪ ﻫﺎ‬
/* P10.4 Structure & Loop */
#include <stdio.h>
#include<string.h>
void main() {
struct telefon {
char name[20];
char num[12];
};
struct telefon tel;
puts(“\nEnter ‘end’ for quit”);
puts(“----------------------”);
do {
printf(“Enter Name : “);
scanf(“%s”, tel.name);
if (!strcmp(tel.name,”end”)) break;
printf(“Enter tel# : “);
scanf(“%s”,tel.num);
printf(“\n%-20s %-12s\n\n, tel.name, tel.num);
} while (1);
}

Enter ‘end’ for quit
--------------------
Enter Name : Reza
Enter tel# : 238071
Reza 238071
Enter Name : Ahmad

Enter tel# : 452201
Ahmad 452201
Enter Name : end

‫ﺗﻌﺮﻳﻒ ﺳﺎﺧﺘﺎر ﺑﺎ اﺳﺘﻔﺎده از ‪typedef‬‬

‫ﻳﻚ دﻳﮕﺮ از روش ﻫﺎي ﺗﻌﺮﻳﻒ ﺳﺎﺧﺘﺎر‪ ،‬ﺗﻌﺮﻳﻒ آن در دﺳﺘﻮر ﺗﻌﺮﻳﻒ ﻧﻮع‬
‫)‪ (Type Definition‬اﺳﺖ‪ .‬دﺳﺘﻮر ﺗﻌﺮﻳﻒ ﻧﻮع را زﻣﺎﻧﻲ ﺑﻪ ﻛﺎر ﻣﻲ ﮔﻴﺮﻳﻢ‬
‫ﻛﻪ ﺑﺨﻮاﻫﻴﻢ ﺑﺮ ﻳﻚ ﻧﻮع داده‪ ،‬ﻧﺎﻣﻲ ﺟﺪﻳﺪ ﻧﺴﺒﺖ دﻫﻴﻢ‪.‬‬
‫‪typedef‬‬ ‫‪int‬‬ ‫;‪sahih‬‬
‫ﭘﺲ از اﻳﻦ دﺳﺘﻮر‪ ،‬ﻫﻤﻪ ﺟﺎ ﻣﻲ ﺗﻮاﻧﻴﻢ ﺑﻪ ﺟﺎي ‪ int‬از ‪ sahih‬اﺳﺘﻔﺎده‬
‫ﻛﻨﻴﻢ‪:‬‬
‫;‪sahih a, b‬‬
‫ﻫﻤﻴﻦ ﻛﺎر را ﺑﺮاي ﺗﻌﺮﻳﻒ ﺳﺎﺧﺘﺎر ﻣﻲ ﺗﻮاﻧﻴﻢ ﺑﻪ ﻛﺎر ﺑﺮﻳﻢ‪.‬‬

‫ اداﻣﻪ‬- typedef ‫ﺗﻌﺮﻳﻒ ﺳﺎﺧﺘﺎر ﺑﺎ اﺳﺘﻔﺎده از‬

typedef struct {
char name[20];
char
h num[12];
[12]
} telefon;
telefon tel;

/* P10.5 Structure & Loop */
#include <stdio.h>
#include<string.h>
void main() {
typedef struct {
char name[20];
char num[12];
} telefon;
telefon tel;
puts(“----------------------”);
do {
printf(“Enter Name : “);
scanf(“%s”, tel.name);
if (!strcmp(tel.name,”end”)) break;
scanf(“%s”,tel.num);
printf(“\n%-20s %-12s\n\n, tel.name, tel.num);
} while (1);
}

--------------------
Enter Name : Reza
Enter tel# : 238071
Reza 238071
Enter Name : Ahmad

Enter tel# : 452201
Ahmad 452201
Enter Name : end

‫اﮔﺮ ﻣﺘﻐﻴﺮﻫﺎي ﺳﺎﺧﺘﺎري از ﻳﻚ ﻧﻮع ﺑﺎﺷﻨﺪ‪ ،‬ﻣﻲ ﺗﻮان ﻣﻘﺎدﻳﺮ آن ﻫﺎ‬

‫را ﻫﻤﺎﻧﻨﺪ ﻣﺘﻐﻴﺮﻫﺎي ﻣﻌﻤﻮﻟﻲ و ﻧﺸﺎﻧﮕﺮﻫﺎ ﺑﻪ ﻳﻜﺪﻳﮕﺮ واﮔﺬار ﻛﺮد‪:‬‬
‫;]‪char name[20‬‬
‫;]‪char num[12‬‬
‫;‪} telefon‬‬
‫;‪telefon tel1, tel2‬‬
‫;‪tel1 = tel2‬‬
‫اﮔﺮ ﺑﺎ اﺳﺘﻔﺎده از ‪ typedef‬ﻳﻚ ﺳﺎﺧﺘﺎر ﺗﻌﺮﻳﻒ ﻛﺮده ﺑﺎﺷﻴﻢ‪ ،‬ﺑﺎز‬
‫ﺑﻪ ﻫﻤﻴﻦ ﺗﺮﺗﻴﺐ ﻣﻣﻲ ﺗﻮاﻧﻴﻢ ﻣﺘﻐﻴﺮﻫﺎي ﻫﻢ ﻧﻮع ﺗﻌﺮﻳﻒ ﻛﻨﻴﻢ‪.‬‬
‫ﺳﺎﺧﺘﺎر و آراﻳﻪ ‪:‬‬
‫ﺳﺎﺧﺘﺎر و آراﻳﻪ از اﻳﻦ ﻧﻈﺮ ﻛﻪ ﻫﺮ دو ﻣﺠﻤﻮﻋﻪ اي از داده ﻫﺎ ﻫﺴﺘﻨﺪ ﻛﻪ زﻳﺮ ﻳﻚ ﻧﺎم ﮔﺮد آﻣﺪه اﻧﺪ‪ ،‬ﺑﺎ ﻫﻢ‬
‫ﻫﻤﺎﻧﻨﺪ ﻫﺴﺘﻨﺪ‪ ،‬وﻟﻲ در ﻣﻴﺎن آن ﻫﺎ ﺗﻔﺎوت ﻫﺎﺋﻲ وﺟﻮد دارد ﻛﻪ در زﻳﺮ ﺑﻪ آن ﻫﺎ اﺷﺎره ﺷﺪه اﺳﺖ‪:‬‬
‫‪ -1‬ﻫﻢ ﻧﻮع ﺑﻮدن ﻋﻨﺎﺻﺮ آراﻳﻪ‪ ،‬و ﻧﺎ ﻫﻢ ﻧﻮع ﺑﻮدن ﻋﻨﺎﺻﺮ ﺳﺎﺧﺘﺎر‪.‬‬
‫‪ -2‬اﻧﺪﻳﺲ دار ﺑﻮدن ﻋﻨﺎﺻﺮ آراﻳﻪ‪ ،‬و ﻧﺎم داﺷﺘﻦ ﻋﻨﺎﺻﺮ ﺳﺎﺧﺘﺎر‪.‬‬
‫ﺳﺎﺧﺘﺎر‪.‬‬
‫ﺑﻮدن ﻧﺎﻧﺎم ﺎﺧﺘﺎ‬
‫ﻣﻌﻤﻮﻟﻲ دن‬
‫ﻟ‬ ‫آراﻳﻪ‪ ،‬و‬
‫ﺑﻮدن ﻧﺎﻧﺎم آ ا ﻪ‬
‫اﺷﺎره ﮔﮔﺮ دن‬
‫‪ -3‬اﺷﺎ ه‬
‫‪ -4‬ﻧﺸﺪﻧﻲ ﺑﻮدن واﮔﺬاري دو آراﻳﻪ ﺑﻪ ﻫﻢ‪ ،‬و ﺷﺪﻧﻲ ﺑﻮدن واﮔﺬاري دو ﺳﺎﺧﺘﺎر ﺑﻪ ﻫﻢ‪.‬‬
‫ﺑﺎ درﻫﻢ آﻣﻴﺨﺘﻦ ﺳﺎﺧﺘﺎر و آراﻳﻪ‪ ،‬ﺗﺮﻛﻴﺐ ﻫﺎي زﻳﺮ ﺑﺪﺳﺖ ﻣﻲ آﻳﺪ‪:‬‬
‫‪ -1‬آراﻳﻪ ﺳﺎﺧﺘﺎري‪.‬‬
‫ي‪.‬‬
‫آراﻳﻪ اي‬
‫ﺳﺎﺧﺘﺎر ر ﻳ‬
‫ر‬ ‫‪-2‬‬

‫آراﻳﻪ ﺳﺎﺧﺘﺎري ‪:‬‬
‫آراﻳﻪ اي ﻛﻪ ﻫﺮ ﻋﻨﺼﺮ آن ﻳﻚ ﺳﺎﺧﺘﺎر ﺑﺎﺷﺪ‪ ،‬آراﻳﻪ ﺳﺎﺧﺘﺎري ﻧﺎﻣﻴﺪه ﻣﻴﺸﻮد‪.‬‬
‫;]‪char name[20‬‬ ‫;] [‬
‫;]‪char num[12‬‬
‫;]‪} tel[100‬‬
‫در اﻳﻦ ﻣﺜﺎل‪tel ،‬آآراﻳﻪ اي اﺳﺖ ﻛﻪ داراي ﻳﻜﺼﺪ ﻋﻨﺼﺮ ﺑﻮده و ﻫﺮ ﻳﻚ از‬
‫ﻋﻨﺎﺻﺮ ﻳﻚ ﺳﺎﺧﺘﺎر ﻣﻲ ﺑﺎﺷﺪ‪ .‬ﺑﺮاي رﺳﻴﺪن ﺑﻪ ﻫﺮ ﻳﻚ از ﻋﻨﺎﺻﺮ‪ ،‬ﺧﻮاﻫﻴﻢ‬
‫داﺷﺖ ‪:‬‬
‫‪tel[i].name‬‬
‫‪tel[i].num‬‬

/ P10.6
/* P10 6 Structure & Array */ /
#include <stdio.h>
#include<string.h>
void main() {
struct {
char name[20];
char num[12];
} tel[100];
int i = 0,
0 n;
puts(“----------------------”);
do {
printf(“Enter
printf( Enter Name : “);
);
scanf(“%s”, tel[i].name);
if (!strcmp(tel[i].name,”end”)) break;
scanf(“%s”,tel[i]
scanf( %s ,tel[i].num);
num); puts(“
puts( “);
);
} while (++i);
puts(“\n\n Name Tel # “);
puts(“-----------------------------------”);
for (n=0
(n 0 ; n < i; ++n)
printf(“\n%-20s %-12s\n\n, tel.name, tel.num); }
--------------------
Enter Name : Reza
Enter tel# : 238071
Enter Name : Ahmad

Enter tel# : 452201
Enter Name : Mahdi

Enter tel# : 761132
Enter Name : end
Name Tel #
----------------------------
Reza 238071
Ahmad 452201
Mahdi 761132

‫ﺳﺎﺧﺘﺎر آراﻳﻪ اي ‪:‬‬
‫ﺳﺎﺧﺘﺎر آراﻳﻪ اي‪ ،‬ﻣﺘﻐﻴﺮ ﺳﺎﺧﺘﺎري اﺳﺖ ﻛﻪ ﺑﻌﻀﻲ از ﻋﻨﺎﺻﺮ آن ﻳﻚ آراﻳﻪ‬
‫ااﺳﺖ‪.‬‬
‫‪struct‬‬
‫‪t‬‬ ‫{ ‪t‬‬
‫;]‪char name [15‬‬
‫;]‪char ketab [10] [15‬‬
‫;‪} author‬‬
‫در اﻳﻦ ﺳﺎﺧﺘﺎر‪ ،‬ﺑﺮي ﻧﺎم ﻧﻮﻳﺴﻨﺪه ﺗﺎ ‪ 15‬ﻛﺎراﻛﺘﺮ‪ ،‬و ﺑﺮاي ﻧﺎم ﻛﺘﺎب ﺗﺎ ‪30‬‬
‫ﻛﺎراﻛﺘﺮ ﭘﻴﺶ ﺑﻴﻨﻲ ﺷﺪه اﺳﺖ‪ .‬در ﺑﺮﻧﺎﻣﻪ ﺻﻔﺤﻪ ﺑﻌﺪ‪ ،‬اﻳﻦ ﺳﺎﺧﺘﺎر را ﺑﺮاي‬
‫ﺧﻮاﻧﺪن و ﭼﺎپ ﻧﺎم و ﻧﺎم ﻛﺘﺎب ﻫﺎي ﻧﻮﻳﺴﻨﺪﮔﺎن ﻣﺨﺘﻠﻒ ﺑﻪ ﻛﺎر ﺑﺮده اﻳﻢ‪.‬‬

/ P10.7
/* P10 7 Structure & Array */ /
#include <stdio.h>
#include<string.h>
void main() {
struct {
char name[15];
char Ketab[10][30];
} author;
int i;
puts(“----------------------”);
do {
printf(“Enter
printf( Enter Name : “);
);
scanf(“%s”, author.name);
if (!strcmp(author.name,”end”)) break;
i = 0;
do {
printf(“ book %d : “, i + 1);
scanf(“%s” , author.ketab[i]);
if (!strcmp(author.ketab[i],”end”)) break;
++i
} while(1); / C
: ‫اداﻣﻪ ﺑﺮﻧﺎﻣﻪ اﺳﻼﻳﺪ ﻗﺒﻞ‬

i = 0;
puts(“\n\nName Book(s)“);
puts(“-----------------------------------”);
while ((strcmp(author.ketab[i],
p( [ ], “end”))
))
{
printf(“\n%-15s %-30s\n, author.name, author.ketab[++i]);
strcmp(author name “ “);
strcmp(author.name, );
}
} while(1);
}

: ‫اﺟﺮاي ﺑﺮﻧﺎﻣﻪ ﺻﻔﺤﻪ ﻗﺒﻞ‬
--------------------
Enter Name : Molavi
book 1 : Masnavi
b k 2 : Divan.e.Shams
book Di Sh
book 3 : end
Name Book(s)
-----------------------
Molavi Masnavi
Divane.e.Shams
Enter Name : end

:‫ﺳﺎﺧﺘﺎر زﻳﺮ را ﺷﺮح دﻫﻴﺪ‬

struct {
char stno[8];
char
h name[30];
[30]
int grade[3];
} Student;

:‫ﺳﺎﺧﺘﺎر زﻳﺮ را ﺷﺮح دﻫﻴﺪ‬

struct {
char stno[8];
char
h name[30];
[30]
int grade[3];
} Student[100];

‫ ﻣﺜﺎل‬: cout ‫ﻧﺤﻮه اﺳﺘﻔﺎده از‬
2: /* This Program Describe the use of COUT */
3: #include <iostream.h>
4: int main()
5: {
6: cout << "Hello there.\n";
7: cout << "Here is 5: " << 5 << "\n";
8: cout <<"The manipulator endl writes a new line to the screen."<<endl;
9: cout << "Here is a very big number:\t" << 70000 << endl;
10: cout << "Here is the sum of 8 and 5:\t" << 8+5 << endl;
11: cout << "Here's
Here s a fraction:\t\t"
fraction:\t\t << (float) 5/8 << endl;
12: cout <<"And a very very big number:\t"<<(double)7000 * 7000 <<endl;
13: cout << "Don't forget to replace Baski with your name...\n";
14: cout << "Baski is a C++ programmer!\n";
15
15: return
t 0
0;
16: }

‫ – ﺗﻮﺿﻴﺢ ﻣﺜﺎل ﺻﻔﺤﻪ ﻗﺒﻞ‬cout ‫ﻧﺤﻮه ﻋﻤﻠﻜﺮد‬
On line 3, the statement #include <iostream.h> causes the iostream.h file to be added to your
source code. This is required if you use cout and its related functions.
On line 6 is the simplest

p use of cout,
, p
printing
g a string
g or series of characters. The symbol
y \n
is a special formatting character. It tells cout to print a newline character to the screen.
Three values are passed to cout on line 7, and each value is separated by the insertion
operator. The first value is the string "Here is 5: ". Note the space after the colon. The
space is part of the string. Next, the value 5 is passed to the insertion operator and the
newline character (always in double quotes or single quotes). This causes the line
Here is 5: 5 to be printed to the screen. Because there is no newline character after the first
string, the next value is printed immediately afterwards. This is called concatenating the two
values.
On line 8, an informative message is printed, and then the manipulator endl is used. The
purpose of endl is to write a new line to the screen. (Other uses for endl are discussed on Day
16.)
On line 9, a new formatting character, \t, is introduced. This inserts a tab character and is
used on lines 8-12 to line up the output. Line 9 shows that not only integers, but long
integers as well can be printed. Line 10 demonstrates that cout will do simple addition. The
value of 8+5 is passed to cout, but 13 is printed.
On line 11, the value 5/8 is inserted into cout. The term (float) tells cout that you want this
value evaluated as a decimal equivalent, and so a fraction is printed. On line 12 the value
7000 * 7000 is given to cout, and the term (double) is used to tell cout that you want this to
be printed using scientific notation. All of this will be explained on Day 3, "Variables and
Constants," when data types are discussed.
On line 14, you substituted your name, and the output confirmed that you are indeed a C++
programmer. It must be true, because the computer said so!
‫ – اﻳﻦ ﺑﺮﻧﺎﻣﻪ اﺟﺮا و ﺑﻪ ﺧﺮوﺟﻲ ﺗﻮﺟﻪ ﺷﻮد‬strncmp ‫ و ﺗﺎﺑﻊ‬strcmp ‫ﻣﺜﺎﻟﻲ از ﻛﺎر ﺑﺎ ﺗﺎﺑﻊ‬
#include <iostream.h>
#include <string.h>
void main()
{
char *s1 = "Happy New Year";
char *s2 = "Happy New Year";
char *s3 = "Happy Holidays";
cout << "s1 = " << s1 << "\ns2 = " << s2 << "\ns3 = " <<
s3 << "\n\nstrcmp(s1,
\ \ p( , s2) ) = " << " " << strcmp( p( s1, , s2 )
<< "\nstrcmp(s1, s3) = " << " " << strcmp( s1, s3 ) <<
"\nstrcmp(s3, s1) = " << " " << strcmp( s3, s1 );
cout << "\n\nstrncmp(s1

"\n\nstrncmp(s1, s3,
s3 6) = " << " " <<
strncmp(s1,s3,6) << "\nstrncmp(s1,s3,7) = " << " " <<
strncmp( s1, s3, 7 ) << "\nstrncmp(s3, s1, 7) = " << " "
<< strncmp( s3, s1, 7 ) << endl;
}
‫ﺳﺎﺧﺘﺎر و اﺷﺎره ﮔﺮ‬

‫ﺳﺎﺧﺘﺎر ﺑﺎزﮔﺸﺘﻲ‬

‫ﺳﺎﺧﺘﺎر و ﺗﺎﺑﻊ – ﺗﺎﺑﻊ ﺳﺎﺧﺘﺎري‬

‫ﭘﺎراﻣﺘﺮ ﺳﺎﺧﺘﺎري‬

@SHARIF - IE برنامه نویسی جلالی

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

@SHARIF - IE برنامه نویسی جلالی

Uploaded by

Copyright:

Available Formats

‫داﻧﺸﮕﺎه ﻋﻠﻢ و ﺻﻨﻌﺖ اﻳﺮان – داﻧﺸﻜﺪه ﻣﻬﻨﺪﺳﻲ ﻛﺎﻣﭙﻴﻮﺗﺮ‬

main() Basic Function

C++ Tutorial azizjalali@iust.ac.ir 4

‫دﺳﺘﻮر اﻓﺰاﻳﺶ ‪:‬‬

C++ Tutorial azizjalali@iust.ac.ir 6

‫‪C++ Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬ ‫‪7‬‬

‫اﻧﻮاع داده ﻫﺎ ‪:‬‬

‫‪C++ Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬ ‫‪8‬‬

‫ﺣﺮوف ‪a.. z , A..Z :‬‬

‫‪C++ Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬ ‫‪9‬‬

‫‪ -2‬ﻋﺪدﻫﺎي ﺻﺤﻴﺢ ‪:‬‬

‫‪C++ Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬ ‫‪10‬‬

‫‪ -3‬ﻋﺪدﻫﺎي اﻋﺸﺎري ﺗﻚ دﻗﺘﻲ ‪:‬‬

‫‪C++ Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬ ‫‪11‬‬

‫‪ -4‬ﻋﺪدﻫﺎي اﻋﺸﺎري دو دﻗﺘﻲ ‪:‬‬

‫‪C++ Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬ ‫‪12‬‬

‫‪ -5‬ﻣﻘﺪار ﺗﻬﻲ ‪:‬‬

‫‪C++ Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬ ‫‪13‬‬

C++ Tutorial azizjalali@iust.ac.ir 14

‫‪C++ Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬ ‫‪15‬‬

scanf(“%d %f %c” , &number, &sum, &ch);

C++ Tutorial azizjalali@iust.ac.ir 16

‫‪C++ Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬ ‫‪17‬‬

C ‫ﺑﻌﻀﻲ از واژه ﻫﺎي ﻛﻠﻴﺪي در‬

‫ﺛﺎﺑﺖ ﻫﺎ )‪: (constant‬‬

‫رﺷﺘﻪ ﻫﺎ )‪: (Strings‬‬

‫دﺳﺘﻮرﻫﺎي ﭘﻴﻤﺎﻳﺶ و ﺧﻮاﻧﺪن‬

C++ Tutorial azizjalali@iust.ac.ir 21

‫دﺳﺘﻮرﻫﺎي ﭘﻴﻤﺎﻳﺶ و ﭼﺎپ‬

C++ Tutorial azizjalali@iust.ac.ir 22

‫‪/* P2.3 Name & Tel. No. */‬‬

‫‪C++ Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬ ‫‪23‬‬

/* P2.5 Staudent_Name & Marks */

Name : Ebrahim Azari

C++ Tutorial azizjalali@iust.ac.ir 24

‫دﺳﺘﻮرﻫﺎي ورودي و ﺧﺮوﺟﻲ ‪ cin‬و ‪cout‬‬

‫‪C++ Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬ ‫‪25‬‬

‫دﺳﺘﻮر ﺧﺮوﺟﻲ ‪cout‬‬

‫‪C++ Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬ ‫‪26‬‬

‫دﺳﺘﻮر ﺧﺮوﺟﻲ ‪ - cout‬اداﻣﻪ‬

‫‪C++ Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬ ‫‪27‬‬

‫داﻧﺸﮕﺎه ﻋﻠﻢ و ﺻﻨﻌﺖ اﻳﺮان – داﻧﺸﻜﺪه ﻣﻬﻨﺪﺳﻲ ﻛﺎﻣﭙﻴﻮﺗﺮ‬

‫دﺳﺘﻮر ﺧﺮوﺟﻲ ‪ – cout‬اداﻣﻪ‬

‫‪C++ Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬ ‫‪28‬‬

‫داﻧﺸﮕﺎه ﻋﻠﻢ و ﺻﻨﻌﺖ اﻳﺮان – داﻧﺸﻜﺪه ﻣﻬﻨﺪﺳﻲ ﻛﺎﻣﭙﻴﻮﺗﺮ‬

‫دﺳﺘﻮر ﺧﺮوﺟﻲ ‪ – cout‬اداﻣﻪ‬

‫ﻣﻮﺟﺐ ﻧﻤﺎﻳﺶ ﻋﺒﺎرت زﻳﺮ روي ﺻﻔﺤﻪ ﻣﺎﻧﻴﺘﻮر ﻣﻴﮕﺮدد‪:‬‬

‫‪C++ Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬ ‫‪29‬‬

‫داﻧﺸﮕﺎه ﻋﻠﻢ و ﺻﻨﻌﺖ اﻳﺮان – داﻧﺸﻜﺪه ﻣﻬﻨﺪﺳﻲ ﻛﺎﻣﭙﻴﻮﺗﺮ‬

‫دﺳﺘﻮر ﺧﺮوﺟﻲ ‪ – cout‬اداﻣﻪ‬

‫ﻣﻮﺟﺐ ﻧﻤﺎﻳﺶ ﻋﺒﺎرت زﻳﺮ روي ﺻﻔﺤﻪ ﻣﺎﻧﻴﺘﻮر ﻣﻴﮕﺮدد‪:‬‬

‫‪C++ Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬ ‫‪30‬‬

‫داﻧﺸﮕﺎه ﻋﻠﻢ و ﺻﻨﻌﺖ اﻳﺮان – داﻧﺸﻜﺪه ﻣﻬﻨﺪﺳﻲ ﻛﺎﻣﭙﻴﻮﺗﺮ‬

‫دﺳﺘﻮر ﺧﺮوﺟﻲ ‪ – cout‬اداﻣﻪ‬

‫ﻣﻮﺟﺐ ﻧﻤﺎﻳﺶ ﻋﺒﺎرت زﻳﺮ روي ﺻﻔﺤﻪ ﻣﺎﻧﻴﺘﻮر ﻣﻴﮕﺮدد‪:‬‬

‫‪C++ Tutorial‬‬ ‫‪azizjalali@iust.ac.ir‬‬ ‫‪31‬‬

‫داﻧﺸﮕﺎه ﻋﻠﻢ و ﺻﻨﻌﺖ اﻳﺮان – داﻧﺸﻜﺪه ﻣﻬﻨﺪﺳﻲ ﻛﺎﻣﭙﻴﻮﺗﺮ‬

‫دﺳﺘﻮر ورودي – ‪cin‬‬

‫اﺳﺘﻔﺎده ااز & ا‬

‫داﻧﺸﮕﺎه ﻋﻠﻢ و ﺻﻨﻌﺖ اﻳﺮان – داﻧﺸﻜﺪه ﻣﻬﻨﺪﺳﻲ ﻛﺎﻣﭙﻴﻮﺗﺮ‬

‫ – اداﻣﻪ‬cin –‫دﺳﺘﻮر ورودي‬

C++ Tutorial azizjalali@iust.ac.ir 33

‫داﻧﺸﮕﺎه ﻋﻠﻢ و ﺻﻨﻌﺖ اﻳﺮان – داﻧﺸﻜﺪه ﻣﻬﻨﺪﺳﻲ ﻛﺎﻣﭙﻴﻮﺗﺮ‬