Start Programming With D

‫زﺑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ‪ D‬ﻗﺴﻤﺖ اول‬

‫ﭼﺸﻢ اﻧﺪاز ‪ D‬ﭼﯿﺴﺖ؟ ‪ D‬ﯾﮏ زﺑﺎن ﺑﺮﻧﺎﻣﻪﺳﺎزی ﺳﯿﺴﺘﻤﯽ و ﮐﺎرﺑﺮدی ھﻤﻪ ﻣﻨﻈﻮره اﺳﺖ ‪ D .‬ﯾﮏ زﺑﺎن‬ ‫ﺳﻄﺢ ﺑﺎﻻﺗﺮ از ‪ C++‬اﺳﺖ اﻣﺎ ﺗﻮاﻧﺎﯾﯽ ﻧﻮﺷﺘﻦ ﮐﺪھﺎی ﻗﺪرﺗﻤﻨﺪ و ﺗﻌﺎﻣﻞ ﻣﺴﺘﻘﯿﻢ ﺑﺎ ‪API‬ھﺎی ﺳﯿﺴﺘﻢ‬ ‫ﻋﺎﻣﻞ و ﺳﺨﺖ اﻓﺰار را ﺣﻔﻆ ﻣﯽﮐﻨﺪ‪ D.‬ﺑﻪ ﺧﻮﺑﯽ ﺑﺮای ﻧﻮﺷﺘﻦ ﺑﺮﻧﺎﻣﻪھﺎی ﻣﺘﺪاول و ﺑﺮﻧﺎﻣﻪھﺎی ﺑﺰرگ ﭼﻨﺪ‬ ‫ﻣﯿﻠﯿﻮن ﺧﻄﯽ ﺑﺎ ﺗﯿﻤﮫﺎی ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﻣﻨﺎﺳﺐ اﺳﺖ ‪ D .‬ﺑﻪ آﺳﺎﻧﯽ ﻗﺎﺑﻞ آﻣﻮﺧﺘﻦ اﺳﺖ ‪ ،‬ﺗﻮاﻧﺎﺋﯿﮫﺎی‬ ‫زﯾﺎدی را ﺑﺮای ﮐﻤﮏ ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺲ ﻓﺮاھﻢ ﻣﯽﮐﻨﺪوﺑﻪ ﺧﻮﺑﯽ ﺑﺮای ﻓﻨﺎوری ﭘﺮﺗﮑﺎﭘﻮی ﺑﮫﯿﻨﻪﺳﺎزی ﮐﺎﻣﭙﺎﯾﻠﺮ‬ ‫ﻣﻨﺎﺳﺐ اﺳﺖ‪ D .‬ﯾﮏ زﺑﺎن اﺳﮑﺮﯾﭙﺘﯽ)ﻣﺘﻨﯽ( ﯾﺎ دارای ﻣﻔﺴﺮ)‪(interpreter‬ﻧﯿﺴﺖ‪ .‬ھﻤﭽﻨﯿﻦ دارای‬ ‫ﻣﺎﺷﯿﻦ ﻣﺠﺎزی ‪ ،‬ﻣﺬھﺐ ﺧﺎص ﯾﺎ ﻓﻠﺴﻔﻪ ﺑﺮﺗﺮیﺟﻮﯾﯽ ﻧﻤﯽ ﺑﺎﺷﺪ‪ .‬ﺑﻠﮑﻪ ﯾﮏ زﺑﺎن ﻋﻤﻠﯽ اﺳﺖ ﺑﺮای‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﺎن ﺣﺮﻓﻪای ﮐﻪ ﻧﯿﺎز ﺑﻪ اﻧﺠﺎم ﺳﺮﯾﻊ و ﻗﺎﺑﻞ اﻋﺘﻤﺎد ﭘﺮوژه دارﻧﺪ و ﺑﻪ ﮐﺪ ﻗﺎﺑﻞ ﻓﮫﻢ آﺳﺎن ﻧﯿﺎز‬ ‫دارﻧﺪ و ﻣﺴﺌﻮل ﻋﻤﻠﮑﺮد ﺻﺤﯿﺢ ﺑﺮﻧﺎﻣﻪ ھﺴﺘﻨﺪ‪ D .‬اوج ﭼﻨﺪ دھﻪ ﺗﺠﺮﺑﻪ ﺑﻪ ﮐﺎرﮔﯿﺮی ﮐﺎﻣﭙﺎﯾﻠﺮھﺎﯾﯽ از‬ ‫زﺑﺎﻧﮫﺎی ﮔﻮﻧﺎﮔﻮن و ﺗﻼش ﺑﺮای ﺑﻨﺎﻧﮫﺎدن ﭘﺮوژه ھﺎی ﺑﺰرگ ﺗﻮﺳﻂ آن زﺑﺎنھﺎ اﺳﺖ‪ D .‬از زﺑﺎﻧﮫﺎی دﯾﮕﺮ‬ ‫ﻣﺨﺼﻮﺻﺎً ‪ C++‬اﻟﮫﺎم ﻣﯽﮔﯿﺮد و آن را ﺑﺎ ﺗﺠﺮﺑﻪ و ﮐﺎرﺑﺮد ﺑﻪ ﻣﻌﻨﺎی واﻗﻌﯽ درھﻢ ﻣﯽآﻣﯿﺰد‪ .‬ﭼﺮا ‪ D‬؟ واﻗﻌﺎً‬ ‫ﭼﺮا؟ ﭼﻪ ﮐﺴﯽ زﺑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ دﯾﮕﺮی ﻧﯿﺎز دارد؟ ﺻﻨﻌﺖ ﻧﺮم اﻓﺰار راه درازی از زﻣﺎن اﺧﺘﺮاع زﺑﺎن ‪C‬‬ ‫ﺗﺎﮐﻨﻮن ﭘﯿﻤﻮده اﺳﺖ‪ .‬ﺑﻪ وﺳﯿﻠﻪ ‪ C++‬ﺗﻌﺪاد زﯾﺎدی ﻣﻔﺎھﯿﻢ ﺟﺪﯾﺪ ﺑﻪ زﺑﺎن ‪ C‬اﻓﺰوده ﺷﺪ‪ .‬اﻣﺎ ﺳﺎزﮔﺎرﺑﺎ‬ ‫ﮔﺬﺷﺘﻪ ‪ C‬در آن اداﻣﻪ ﯾﺎﻓﺖ ‪ ،‬ﺷﺎﻣﻞ ﺳﺎزﮔﺎری ﺑﺎ ﺗﻘﺮﯾﺒﺎً ﺗﻤﺎم ﺿﻌﻔﮫﺎی ﻃﺮاﺣﯽ اﺻﻠﯽ زﺑﺎن ‪ . C‬ﺗﻼﺷﮫﺎی‬ ‫زﯾﺎدی ﺑﺮای ﺑﺮﻃﺮف ﺳﺎﺧﺘﻦ آن ﺿﻌﻔﮫﺎ ﺗﺎﮐﻨﻮن ﺻﻮرت ﮔﺮﻓﺘﻪ اﺳﺖ اﻣﺎ در ﭘﯽ ﺣﻔﻆ ﺳﺎزﮔﺎری ﺑﺎ ﮔﺬﺷﺘﻪ‬ ‫ﺧﻨﺜﯽ ﺷﺪه اﺳﺖ‪ .‬در ﺿﻤﻦ ھﺮ دوی ‪ C‬و ‪ C ++‬دﺳﺘﺨﻮش ﯾﮏ رﺷﺪ ﭘﯿﻮﺳﺘﻪ ﺧﺼﻮﺻﯿﺎت ﺟﺪﯾﺪ ﺷﺪه اﻧﺪ‪.‬‬ ‫اﯾﻦ ﺧﺼﻮﺻﯿﺎت ﺟﺪﯾﺪ ﺑﺎﯾﺪ ﺑﻪ دﻗﺖ و ﺑﺪون ﻧﯿﺎز ﺑﻪ ﺑﺎزﻧﻮﯾﺴﯽ ﮐﺪ ﻗﺪﯾﻤﯽ ﺑﻪ ﺳﺎﺧﺘﺎر ﻣﻮﺟﻮد ﺧﻮراﻧﺪه ﺷﻮد‪.‬‬ ‫ﻧﺘﯿﺠﻪ ﻧﮫﺎﯾﯽ ﺑﺴﯿﺎر ﭘﯿﭽﯿﺪه اﺳﺖ ؛ ‪C‬اﺳﺘﺎﻧﺪارد ﺗﻘﺮﯾﺒ ﺎً ‪ ۵٠٠‬ﺻﻔﺤﻪ اﺳﺖ و ‪C++‬اﺳﺘﺎﻧﺪارد ﺣﺪود ‪٧۵٠‬‬ ‫ﺻﻔﺤﻪ ! ﺣﻘﯿﻘﺖ ﺷﻠﻮﻏﯽ ﮐﺎﻣﭙﺎﯾﻠﺮ ‪ ++C‬اﯾﻦ اﺳﺖ ﮐﻪ ﮐﺎﻣﭙﺎﯾﻠﺮھﺎی اﻧﺪﮐﯽ ﺑﻪ ﻃﻮر ﻣﺆﺛﺮ اﺳﺘﺎﻧﺪارد را‬ ‫دﺳﺖ ﻧﺨﻮرده ﺑﻪ ﮐﺎر ﻣﯽﮔﯿﺮﻧﺪ‪ .‬ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﺎن ‪ ++C‬ﮔﺮاﯾﺶ ﻣﯽ ﯾﺎﺑﻨﺪ ﮐﻪ در ﺟﺰاﯾﺮ ﺧﺎﺻﯽ از زﺑﺎن ﺑﺮﻧﺎﻣﻪ‬ ‫ﺑﺴﺎزﻧﺪ و در ﻧﻈﺮ ﻣﯽﮔﯿﺮﻧﺪ ﮐﺎرﺑﺮد ﺑﺴﯿﺎر ﺧﻮب ﺑﻌﻀﯽ ﺧﺼﻮﺻﯿﺎت را در ﺣﺎﻟﯽ ﮐﻪ از دﯾﮕﺮ ﻣﺠﻤﻮﻋﻪھﺎ‬ ‫اﺟﺘﻨﺎب ﻣﯽﮐﻨﻨﺪ ‪ .‬ﺑﺎ وﺟﻮد اﯾﻨﮑﻪ ﮐﺪ از ﯾﮏ ﮐﺎﻣﭙﺎﯾﻠﺮ ﺑﻪ ﮐﺎﻣﭙﺎﯾﻠﺮ دﯾﮕﺮ ﻗﺎﺑﻞ ﺣﻤﻞ اﺳﺖ ﻣﯽ ﺗﻮاﻧﺪ ﻣﺸﮑﻞ‬ ‫ﺑﺎﺷﺪ ﮐﻪ از ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ دﯾﮕﺮ ﻣﻨﺘﻘﻞ ﺷﻮد ‪ .‬ﺗﻮاﻧﺎﯾﯽ ﺑﺰرگ ‪ ++C‬اﯾﻦ اﺳﺖ ﮐﻪ‬ ‫ﻣﯽﺗﻮاﻧﺪ ﺗﻌﺪاد زﯾﺎدی ﺳﺒﮑﮫﺎی اﺻﻠﯽ ﺑﺮﻧﺎﻣﻪﻧﻮﯾﺴﯽ را ﭘﺸﺘﯿﺒﺎﻧﯽ ﮐﻨﻨﺪ ‪ .‬در ﮐﺎرﺑﺮد ﻃﻮﻻﻧﯽ ﻣﺪت ﺳﺒﮑﮫﺎی‬ ‫دارای اﺷﺘﺮاک و ﻣﺘﻨﺎﻗﺾ ﯾﮏ ﻣﺎﻧﻊ و در ﻧﺘﯿﺠﻪ ﺳﺒﺐ ﺗﺄﺧﯿﺮ ھﺴﺘﻨﺪ‪ .‬ﻧﺎاﻣﯿﺪ ﮐﻨﻨﺪه اﺳﺖ ﮐﻪ زﺑﺎﻧﯽ ﭼﻨﯿﻦ‬ ‫ﻗﺪرﺗﻤﻨﺪ ‪ ،‬اﻋﻤﺎل ﭘﺎﯾﻪا ای ﻣﺎﻧﻨﺪ ﺗﻐﯿﯿﺮ اﻧﺪازه آراﯾﻪھﺎ و اﻟﺤﺎق رﺷﺘﻪھﺎ را اﻧﺠﺎم ﻧﻤﯽدھﺪ‪.‬اﻟﺒﺘﻪ ‪++C‬‬ ‫ﺗﻮاﻧﺎﯾﯽ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﻗﺪرﺗﻤﻨﺪ ﺑﺮای ﭘﯿﺎده ﺳﺎزی آراﯾﻪ ھﺎی ﻗﺎﺑﻞ ﺗﻐﯿﯿﺮ اﻧﺪازه و رﺷﺘﻪ ھﺎ را ﻓﺮاھﻢ‬ ‫ﻣﯽﮐﻨﻨﺪ )ﻣﺎﻧﻨﺪ ﻧﻮع ﺑﺮدار در ‪ . ( STL‬اﻣﺎ ﺑﻪ ھﺮﺣﺎل ﭼﻨﯿﻦ ﺧﺼﻮﺻﯿﺎت ﺑﻨﯿﺎدی ‪ ،‬ﺑﺎﯾﺴﺘﯽ ﺟﺰء ﻗﺴﻤﺘﮫﺎی‬ ‫زﺑﺎن ﺑﺎﺷﺪ‪ .‬آﯾﺎ ﻗﺪرت و ﻗﺎﺑﻠﯿﺘﮫﺎی ‪ ، ++C‬ﻗﺎﺑﻞ ﮔﺴﺘﺮش ‪ ،‬ﻃﺮاﺣﯽ ﻣﺠﺪد و ﭘﯿﺎدهﺳﺎزی ﺑﻪ ﯾﮏ زﺑﺎن ﺳﺎده‬ ‫وارﺗﮕﻨﺎل )ﻣﺘﻤﺎﯾﺰ و ﻣﺴﺘﻘﻞ (و ﮐﺎرﺑﺮدی ﻣﯽ ﺑﺎﺷﺪ؟ آﯾﺎ ﺗﻤﺎﻣﯽ آﻧﮫﺎ ﻣﯽ ﺗﻮاﻧﺪ داﺧﻞ ﺑﺴﺘﻪ ای ﻗﺮار ﮔﯿﺮد ﮐﻪ‬ ‫ﺑﺮای ﮐﺎﻣﭙﺎﯾﻠﺮﻧﻮﯾﺴﺎن ﺑﻪ آﺳﺎﻧﯽ ﻗﺎﺑﻞ ﭘﯿﺎدهﺳﺎزی ﺻﺤﯿﺢ ﺑﺎﺷﺪ و ﮐﺎﻣﭙﺎﯾﻠﺮھﺎ را ﻗﺎدر ﮐﻨﺪ ﮐﻪ ﺑﻪ ﻧﺤﻮی ﮐﺎرا ‪،‬‬ ‫ﮐﺪھﺎی ﺑﮫﯿﻨﻪ ﺷﺪه و ﭘﺮﺗﮑﺎﭘﻮ اﯾﺠﺎد ﮐﻨﺪ؟ ﻓﻨﺎوری ﭘﯿﺸﺮﻓﺘﻪ ﮐﺎﻣﭙﺎﯾﻠﺮ ﺑﻪ ﻧﻘﻄﻪای رﺳﯿﺪه اﺳﺖ ﮐﻪ‬ ‫ﺧﺼﻮﺻﯿﺎﺗﯽ از زﺑﺎن ﮐﻪ ﺑﻪ ﻣﻨﻈﻮر ﺟﺒﺮان ﮐﺮدن ﻓﻨﺎوری اﺑﺘﺪاﯾﯽ ﮐﺎﻣﭙﺎﯾﻠﺮ وﺟﻮد دارﻧﺪ ‪ ،‬ﻣﯽﺗﻮاﻧﻨﺪ ﺣﺬف ﺷﻮﻧﺪ‪.‬‬ ‫)ﻣﺜﺎﻟﯽ ازاﯾﻦ ﻧﻤﻮﻧﻪ ﻣﯽ ﺗﻮاﻧﺪ واژه ﮐﻠﯿﺪی “‪ ”Register‬در ‪ C‬ﺑﺎﺷﺪ ‪ ،‬ﻣﺜﺎﻟﯽ ﻇﺮﯾﻔﺘﺮ ﻣﺎﮐﺮوی ﭘﯿﺶﭘﺮدازﻧﺪه در‬ ‫‪ C‬اﺳﺖ( ‪ .‬ﻣﺎ ﻣﯽﺗﻮاﻧﯿﻢ ﺑﻪ ﻓﻨﺎوری ﭘﯿﺸﺮﻓﺘﻪی ﺑﮫﯿﻨﻪ ﺳﺎزی ﮐﺎﻣﭙﺎﯾﻠﺮ اﻋﺘﻤﺎد ﮐﻨﯿﻢ ﺗﺎ دﯾﮕﺮ ﺑﻪ ﺧﺼﻮﺻﯿﺎﺗﯽ‬ ‫از زﺑﺎن ﮐﻪ ﺑﺮای دﺳﺖ ﯾﺎﻓﺘﻦ ﺑﻪ ﮐﯿﻔﯿﺖ ﮐﺪ ﻗﺎﺑﻞﻗﺒﻮل )ﺟﺪای از ﮐﺎﻣﭙﺎﯾﻠﺮھﺎی اﺑﺘﺪاﺋﯽ( ﻻزم اﺳﺖ ﻧﯿﺎز‬ ‫ﻧﺪاﺷﺘﻪ ﺑﺎﺷﯿﻢ‪ D .‬درﻧﻈﺮ دارد ﮐﻪ ھﺰﯾﻨﻪھﺎی ﮔﺴﺘﺮش ﻧﺮماﻓﺰار را ﺣﺪاﻗﻞ ‪ ١٠%‬ﮐﺎھﺶ دھﺪ ﺗﻮﺳﻂ اﻓﺰودن‬ ‫ﺧﺼﻮﺻﯿﺎت ﺑﮫﯿﻨﻪﺳﺎزی ﺑﺎﻻﺑﺮﻧﺪه ﻣﯿﺰان ﺳﻮدﻣﻨﺪی و ﺗﻮﻟﯿﺪ و ھﻤﭽﻨﯿﻦ ﺑﺎ ﺗﻌﺪﯾﻞ ﮐﺮدن ﺧﺼﻮﺻﯿﺎت زﺑﺎن ‪ ،‬ﺑﻪ‬ ‫ﻃﻮری ﮐﻪ اﺷﮑﺎﻻت وﻗﺖﮔﯿﺮ ﻣﺘﺪاول از اﺑﺘﺪا ﺣﺬف ﻣﯽﺷﻮﻧﺪ‪ .‬ﺧﺼﻮﺻﯿﺎت ﺣﻔﻆ ﺷﺪه از ‪ ++C/C‬ﻣﻨﻈﺮه‬ ‫ﮐﻠﯽ ‪ D‬ﺷﺒﯿﻪ ‪ C‬و ‪ ++C‬اﺳﺖ ‪ .‬اﯾﻦ ﻣﻮ ﺿﻮع آﻣﻮﺧﺘﻦ ‪ D‬و اﻧﺘﻘﺎل ﮐﺪ ﺑﻪ آن را آﺳﺎﻧﺘﺮ ﻣﯽﮐﻨﺪ‪ .‬ﮔﺬر از‬ ‫‪ ++C/C‬ﺑﻪ ﺳﻮی ‪ D‬ﺑﺎﯾﺪ ﻃﺒﯿﻌﯽ ﺣﺲ ﺷﻮد و ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺲ ﻣﺠﺒﻮر ﻧﺨﻮاھﺪ ﺑﻮد ﮐﻪ ﯾﮏ راه ﮐﺎﻣﻼً ﺟﺪﯾﺪ‬ ‫اﻧﺠﺎم ﮐﺎرھﺎ را ﻓﺮاﮔﯿﺮد ‪ .‬اﺳﺘﻔﺎده از ‪ D‬ﺑﻪ اﯾﻦ ﻣﻌﻨﺎ ﻧﯿﺴﺖ ﮐﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺲ ﺑﻪ ﯾﮏ ﻣﺎﺷﯿﻦ ﻣﺠﺎزی ﺧﺎص‬ ‫زﺑﺎن اﺟﺮا ﻣﺤﺪود ﺷﻮد ﻣﺎﻧﻨﺪ ﻣﺎﺷﯿﻦ ﻣﺠﺎزی ﺟﺎوا ﯾﺎ ‪ . Smalltalk‬ھﯿﭻ ﻣﺎﺷﯿﻦ ﻣﺠﺎزی ‪ D‬وﺟﻮد ﻧﺪارد ﯾﮏ‬ ‫ﮐﺎﻣﭙﺎﯾﻠﺮ ﺳﺮراﺳﺖ اﺳﺖ ﮐﻪ ‪ Objectfile‬ھﺎی ﻗﺎﺑﻞ ﭘﯿﻮﻧﺪ )‪ (Link‬ﺗﻮﻟﯿﺪ ﻣﯽﮐﻨﺪ ‪ D .‬ﺑﻪ ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ ﻣﺘﺼﻞ‬ ‫ﻣﯽﺷﻮد دﻗﯿﻘﺎً ﻣﺎﻧﻨﺪ ‪ . C‬اﺑﺰارھﺎی آﺷﻨﺎی ﻣﺘﺪاول ﻣﺎﻧﻨﺪ “‪ ”MAKE‬ﻣﺴﺘﻘﯿﻤ ﺎً در ﺑﺮﻧﺎﻣﻪﻧﻮﯾﺴﯽ ‪ D‬ﮔﻨﺠﺎﻧﺪه‬ ‫ﺷﺪه اﺳﺖ‪.١ .‬ﻣﻨﻈﺮه ﻋﻤﻮﻣﯽ و اﺣﺴﺎس ﻣﻮﺟﻮد در ‪ ++C/C‬اﺑﻘﺎ ﺧﻮاھﺪ ﺷﺪ ‪ .‬ھﻤﺎن اﻣﻼی ﺟﺒﺮی ﺑﻪ ﮐﺎر‬ ‫ﺧﻮاھﺪ رﻓﺖ و اﻏﻠﺐ ﻋﺒﺎرات و ﻓﺮﻣﮫﺎی دﺳﺘﻮرات و ﻃﺮحﺑﻨﺪی ﻋﻤﻮﻣﯽ‪. ٢ .‬ﺑﺮﻧﺎﻣﻪھﺎی ‪ D‬ھﻢ ﺑﻪ ﺳﺒﮏ ‪C‬‬ ‫)ﺗﻮاﺑﻊ و دادهھﺎ( و ھﻢ در ﺳﺒﮏ ‪) ++C‬ﻧﻪ ﺷﯽءﮔﺮا( ﯾﺎﺗﺮﮐﯿﺒﯽ از ھﺮدو ﻗﺎﺑﻞ ﻧﻮﺷﺘﻦ اﺳﺖ‪ D .‬ﺑﺮای ﭼﻪ‬ ‫ﮐﺴﺎﻧﯽ ﻣﻨﺎﺳﺐ اﺳﺖ؟ ‪.١‬ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﺎﻧﯽ ﮐﻪ ﺑﻪ ﻃﻮر ﻣﺪاوم از اﺑﺰارھﺎی ﺗﺠﺰﯾﻪ و ﺗﺤﻠﯿﻞ ﮐﺪ اﺳﺘﻔﺎده‬ ‫ﻣﯽﮐﻨﻨﺪ ﺗﺎ ﺧﻄﺎھﺎ را ﺣﺘﯽ ﻗﺒﻞ از ﮐﺎﻣﭙﺎﯾﻞ ﺷﺪن ازﺑﯿﻦ ﺑﺒﺮﻧﺪ‪.٢ .‬اﻓﺮادی ﮐﻪ ﻋﻤﻞ ﮐﺎﻣﭙﺎﯾﻞ را ﺑﺎ ﺑﺎﻻﺗﺮﯾﻦ‬ ‫ﺳﻄﺢ ھﺸﺪارھﺎ اﻧﺠﺎم ﻣﯽدھﻨﺪ ﯾﺎ از ﮐﺎﻣﭙﺎﯾﻠﺮ ﻣﯽﺧﻮاھﻨﺪ ﮐﻪ ھﺸﺪارھﺎ را ﺑﻪ ﻣﻨﺰﻟﻪ ﺧﻄﺎ ﺗﻠﻘﯽ ﮐﻨﺪ‪.‬‬ ‫‪. ٣‬ﻣﺪﯾﺮان ﺑﺮﻧﺎﻣﻪﻧﻮﯾﺴﯽ ﮐﻪ ﻣﺠﺒﻮرﻧﺪ ﺑﻪ راھﻨﻤﺎﯾﯿﮫﺎی ﺳﺒﮏ ﺑﺮﻧﺎﻣﻪﻧﻮﯾﺴﯽ ﺑﺮای اﺟﺘﻨﺎب از اﺷﮑﺎﻻت‬ ‫ﻣﻌﻤﻮل ‪ C‬اﻋﺘﻤﺎد ﮐﻨﻨﺪ‪.۴ .‬اﻓﺮادی ﮐﻪ ﺑﺮاﯾﻦ ﺑﺎورﻧﺪ ﮐﻪ وﻋﺪهھﺎی ﺳﺒﮏ ﺷﯽءﮔﺮای ‪ ++C‬ﺑﻪ ﺧﺎﻃﺮ‬

‫ﭘﯿﭽﯿﺪهﮔﯿﮫﺎﯾﺶ ﺑﺮآورده ﻧﻤﯽﺷﻮد ‪. ۵ .‬ﺑﺮﻧﺎﻣﻪﻧﻮﯾﺴﺎﻧﯽ ﮐﻪ از ﻗﺪرت ﺑﯿﺎﻧﮕﺮ ‪ ++C‬ﻟﺬت ﻣﯽﺑﺮﻧﺪ اﻣﺎ ﺑﻪ ﺧﺎﻃﺮ‬ ‫ﻧﯿﺎز ﺑﻪ ﺻﺮف ﺗﻼش زﯾﺎد ﺑﺮای اداره ﺣﺎﻓﻈﻪ و ﯾﺎﻓﺘﻦ اﺷﮑﺎﻻت اﺷﺎرهﮔﺮھﺎ ‪ ،‬ﻧﺎاﻣﯿﺪ ﺷﺪهاﻧﺪ‪.۶ .‬ﭘﺮوژهھﺎﯾﯽ ﮐﻪ‬ ‫ﻧﯿﺎز ﺑﻪ ﺗﺴﺖ ھﻤﺮاه و ﺗﺼﺪﯾﻖ و ﺗﺄﯾﯿﺪ دارﻧﺪ ‪. ٧ .‬ﺑﺮﻧﺎﻣﻪﻧﻮﯾﺴﺎﻧﯽ ﮐﻪ ﻓﮑﺮ ﻣﯽ ﮐﻨﻨﺪ زﺑﺎن ﺑﺎﯾﺪ دارای ﺧﺼﻮﺻﯿﺎت‬ ‫ﮐﺎﻓﯽ ﺑﺎﺷﺪ ‪ .‬ﺑﺮای رﻓﻊ ﻧﯿﺎز داﺋﻤﯽ اداره دﺳﺘﯽ و ﻣﺴﺘﻘﯿﻢ اﺷﺎرهﮔﺮھﺎ ‪.٨ .‬ﺑﺮﻧﺎﻣﻪﻧﻮﯾﺴﺎن ﻣﺤﺎﺳﺒﺎت‬ ‫ﻋﺪدی ‪ D .‬دارای ﺧﺼﻮﺻﯿﺎت زﯾﺎدی ﺑﺮای ﭘﺸﺘﯿﺒﺎﻧﯽ ﻣﺴﺘﻘﯿﻢ اﻋﻤﺎل ﻣﻮرد ﻧﯿﺎز ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﺎن ﻣﺤﺎﺳﺒﺎت‬ ‫ﻣﯽﺑﺎﺷﺪ ‪ ،‬ﻣﺎﻧﻨﺪ ﭘﺸﺘﯿﺒﺎﻧﯽ ﻣﺴﺘﻘﯿﻢ از ﻧﻮع داده ﻣﺮﮐﺐ و اﻋﻤﺎل ﺗﻌﺮﯾﻒ ﺷﺪه ﺑﺮای ﺑﯽﻧﮫﺎﯾﺖ و ‪NAN’S‬‬ ‫)اﯾﻦ ﺧﺼﻮﺻﯿﺎت در اﺳﺘﺎﻧﺪارد ‪ ٩٩C‬اﺿﺎﻓﻪ ﺷﺪ وﻟﯽ در ‪ ++C‬ﻧﻪ( ‪.٩‬ﺑﺨﺶ ﺗﺠﺰﯾﻪ ﻟﻐﻮی و ﺗﺠﺰﯾﻪ ﻧﺤﻮی ‪ D‬از‬ ‫ﯾﮑﺪﯾﮕﺮ در ﻧﮫﺎﯾﺖ ﻣﺠﺰا ھﺴﺘﻨﺪ و ھﻤﭽﻨﯿﻦ از ﺗﺠﺰﯾﻪﮔﺮ ﻣﻌﻨﺎﯾﯽ‪ .‬اﯾﻦ ﺑﺪﯾﻦ ﻣﻌﻨﺎﺳﺖ ﮐﻪ ﻧﻮﺷﺘﻦ اﺑﺰارھﺎی‬ ‫ﺳﺎده ﺑﺮای اداره ﮐﺮدن ﮐﺪ ﻣﻨﺒﻊ ‪D‬در ﺳﻄﺢ ﻋﺎﻟﯽ آﺳﺎن اﺳﺖ ﺑﺪون اﯾﻨﮑﻪ ﻣﺠﺒﻮر ﺑﻪ ﺳﺎﺧﺘﻦ ﯾﮏ ﮐﺎﻣﭙﺎﯾﻠﺮ‬ ‫ﮐﺎﻣﻞ ﺑﺎﺷﯿﻢ ‪ .‬ھﻤﭽﻨﯿﻦ ﺑﺪﯾﻦ ﻣﻌﻨﺎﺳﺖ ﮐﻪ ﮐﺪ ﻣﻨﺒﻊ ‪،‬ﺑﺮای ﮐﺎرﺑﺮدھﺎی ﺧﺎص ﻗﺎﺑﻞ اﻧﺘﻘﺎل ﺑﻪ ﻓﺮم ‪token‬ھﺎ‬ ‫اﺳﺖ ‪.‬‬ ‫زﺑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ‪ D‬ﻗﺴﻤﺖ دوم‬ ‫‪D‬ﺑﺮای ﭼﻪ ﮐﺴﺎﻧﯽ ﻣﻨﺎﺳﺐ ﻧﯿﺴﺖ؟ ‪.١‬ﺑﻪ ﻃﻮر واﻗﻊ ﺑﯿﻨﺎﻧﻪ ‪ ،‬ھﯿﭽﮑﺲ ﻗﺼﺪ ﺗﺒﺪﯾﻞ ﻣﯿﻠﯿﻮﻧﮫﺎ ﺧﻂ از ‪C/C++‬‬ ‫ﺑﻪ ‪ D‬ﻧﺪارد و از آﻧﺠﺎ ﮐﻪ ‪ D‬ﮐﺪ ﻣﻨﺒﻊ اﺻﻼح ﻧﺸﺪه ‪ C/C++‬را ﮐﺎﻣﭙﺎﯾﻞ ﻧﻤﯽﮐﻨﺪ ‪ D‬ﺑﺮای ‪ apps‬اﺷﺎره ﻣﻨﺎﺳﺐ‬ ‫ﻧﯿﺴﺖ‪) .‬ﺑﻪ ھﺮﺣﺎل ‪CAPF ، D‬ھﺎی ارث را ﺑﻪ ﺧﻮﺑﯽ ﭘﺸﺘﯿﺒﺎﻧﯽ ﻣﯽﮐﻨﺪ(‪.٢ .‬ﺑﺮﻧﺎﻣﻪ ھﺎی ﺧﯿﻠﯽ ﮐﻮﭼﮏ ‪:‬‬ ‫ﯾﮏ زﺑﺎن اﺳﮑﺮﯾﭙﺘﯽ ﯾﺎ دارای ﻣﻔﺴﺮ ﻣﺎﻧﻨﺪ ‪ Perl , Dmdscript , Python‬اﺣﺘﻤﺎﻻً ﻣﻨﺎﺳﺒﺘﺮ اﺳﺖ ‪.٣ .‬ﺑﻪ ﻋﻨﻮان‬ ‫زﺑﺎن ﺑﺮﻧﺎﻣﻪﻧﻮﯾﺴﯽ ﺑﺮای ﺷﺮوع‪ :‬ﺑﺮای ﻣﺒﺘﺪیھﺎ ‪ Python‬ﯾﺎ ‪ java‬ﻣﻨﺎﺳﺒﺘﺮ اﺳﺖ ‪ D‬ﺑﺮای ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﺎن‬ ‫ﻣﺘﻮﺳﻂ ﺗﺎ ﭘﯿﺸﺮﻓﺘﻪ ﯾﮏ زﺑﺎن دوم ﻋﺎﻟﯽ اﺳﺖ ‪. ۴ .‬زﺑﺎن ﺑﻪ ﮐﺎرﺑﺮد ﮐﻠﻤﺎت ﺻﺤﯿﺢ وﺳﻮاس دارد ‪. D‬ﯾﮏ زﺑﺎن‬ ‫ﻋﻤﻠﯽ اﺳﺖ و ھﺮ ﺧﺼﯿﺼﻪ از آن ﺗﺮﺟﯿﺤﺎً ﻗﺎﺑﻞ ﻣﻘﺎﯾﺴﻪ و ارزﯾﺎﺑﯽ در ھﻤﺎن ﺣﺪاﺳﺖ ﺗﺎ در ﺣﺪ اﯾﺪهآل ‪ .‬ﺑﻪ‬ ‫ﻃﻮر ﻣﺜﺎل ‪ D‬ﺳﺎﺧﺘﺎرھ ﺎ و ﻣﻔﺎھﯿﻤﯽ دارد ﮐﻪ ﺑﻪ ﻃﻮر ﻣﺠﺎزی ﻧﯿﺎز ﺑﻪ اﺷﺎرهﮔﺮھﺎ را ﺑﺮای اﻣﻮر ﭘﯿﺶﭘﺎ اﻓﺘﺎده‬ ‫ازﺑﯿﻦ ﻣﯽﺑﺮد ‪ .‬ﺑﻪ ﻃﻮر ﻣﺸﺎﺑﻪ ﺗﻐﯿﯿﺮ ﻧﻮﻋﮫﺎ ھﻨﻮز وﺟﻮد دارد ﺑﺮای آن ﺟﺎﯾﯽ ﮐﻪ ﺳﯿﺴﺘﻢ ﻧﻮع ﻧﯿﺎز ﺑﻪ ﻧﺎدﯾﺪه‬ ‫ﮔﺮﻓﺘﻦ دارد ‪.‬ﺧﺼﻮﺻﯿﺎت اﺻﻠﯽ ‪ D‬اﯾﻦ ﻗﺴﻤﺖ ﺑﺮﺧﯽ ﺧﺼﻮﺻﯿﺎت ﺟﺎﻟﺐﺗﺮ(‪ D‬ﻧﺴﺒﺖ ﺑﻪ )‪ C‬را در دﺳﺘﻪھﺎی‬ ‫ﻣﺨﺘﻠﻒ ﻃﺒﻘﻪﺑﻨﺪی ﻣﯽﮐﻨﺪ‪ .‬ﺑﺮﻧﺎﻣﻪﻧﻮﯾﺴﯽ ﺷﯽءﮔﺮا ﮐﻼﺳﮫﺎ ‪ :‬ﻃﺒﯿﻌﺖ ﺷﯽءﮔﺮای ‪ D‬از ﮐﻼﺳﮫﺎ آﻏﺎز‬ ‫ﻣﯽﺷﻮد‪ .‬ﻣﺪل وراﺛﺖ ‪ ،‬وراﺛﺖ ﯾﮕﺎﻧﻪ اﺳﺖ ﮐﻪ ﺑﺎ رواﺑﻂ ﺗﻘﻮﯾﺖ ﻣﯽﺷﻮد‪ .‬ﺷﯽء ﮐﻼس در رﯾﺸﻪی ﺷﺠﺮه‬ ‫وراﺛﺖ ﻣﯽ ﻧﺸﯿﻨﺪ ‪ .‬ﺑﻨﺎﺑﺮاﯾﻦ ﺗﻤﺎم ﮐﻼﺳﮫﺎ ﯾﮏ ﻣﺠﻤﻮﻋﻪ ﻣﺘﺪاول ﺗﺎﺑﻌﯽ را اﺟﺮا ﻣﯽﮐﻨﻨﺪ‪ .‬ﮐﻼﺳﮫﺎ ﺑﻪ وﺳﯿﻠﻪ‬ ‫ارﺟﺎع ﻣﻌﺮﻓﯽ ﻣﯽ ﺷﻮﻧﺪ و ﭼﻨﺎن ﮐﺪ ﭘﯿﭽﯿﺪهای ﺑﺮای آﻧﮑﻪ ﭘﺲاز اﺳﺘﺜﻨﺎھﺎ ﭘﺎک ﺷﻮد ﻧﯿﺎز ﻧﯿﺴﺖ‪ .‬ﺗﻌﺮﯾﻒ‬ ‫ﻣﺠﺪد ﻋﻤﻠﮕﺮھﺎ‪ :‬ﻣﯽﺗﻮان ﮐﻼس را ﺑﺮآن واداﺷﺖ ﮐﻪ ﺑﺎ اﺳﺘﻔﺎده از ﻋﻤﻠﮕﺮھﺎی ﻣﻮﺟﻮد ‪ ،‬ﺳﯿﺴﺘﻢ ﻧﻮع را‬ ‫ﺑﺮای ﭘﺸﺘﯿﺒﺎﻧﯽ ﻧﻮﻋﮫﺎی ﺟﺪﯾﺪ ﮔﺴﺘﺮش دھﻨﺪ‪ .‬ﻣﺜﻼً اﯾﺠﺎد ﮐﻼس اﻋﺪاد ﺑﺰرگ و ﺳﭙﺲ ﺗﻌﺮﯾﻒ ﻣﺠﺪد‬ ‫ﻋﻤﻠﮕﺮھﺎی )‪ (+,_,*,/‬ﺑﺮای ﺗﻮاﻧﺎﯾﯽ اﺳﺘﻔﺎده از آﻧﮫﺎ در اﻣﻼی ﻋﺒﺎرات ﺟﺒﺮی ﻣﻌﻤﻮﻟﯽ ‪.‬‬ ‫ﻓﺮاوری )‪( Productivity‬ﭘﯿﻤﺎﻧﻪھﺎ ‪ :‬ﻓﺎﯾﻠﮫﺎی ﻣﻨﺒﻊ دارای ارﺗﺒﺎﻃﯽ ﯾﮏﺑﻪﯾﮏ ﺑﺎ ﭘﯿﻤﺎﻧﻪھﺎ ھﺴﺘﻨﺪ‪ .‬ﺑﻪ ﺟﺎی‬ ‫‪include#‬ﻧﻤﻮدن ﯾﮏ ﻓﺎﯾﻞ از اﻋﻼن ھﺎ ﻓﻘﻂ ﭘﯿﻤﺎﻧﻪ را ‪ import‬ﻣﯽﻧﻤﺎﯾﯿﻢ‪ .‬ھﯿﭻ ﻧﮕﺮاﻧﯽ در ﻣﻮرد‬ ‫‪import‬ھﺎی ﻣﺘﻌﺪد از ھﻤﺎن ﭘﯿﻤﺎﻧﻪ ﻧﯿﺴﺖ ھﻤﭽﻨﯿﻦ ﻧﯿﺎزی ﺑﻪ ﭘﻮﺷﺎﻧﺪن ﻓﺎﯾﻠﮫﺎی ‪ header‬ﺑﺎ ‪ ifndef#‬ﯾﺎ‬ ‫‪endif#‬ﯾﺎ‪ pragma once #‬و از اﯾﻦ ﻗﺒﯿﻞ ﻧﯿﺴﺖ ‪ .‬اﻋﻼن در ﺑﺮاﺑﺮ ﺗﻌﺮﯾﻒ ‪ C++‬ﻣﻌﻤﻮ ﻻً ﻧﯿﺎز دارد ﮐﻪ ﺗﻮاﺑﻊ و‬ ‫ﮐﻼﺳﮫﺎ دوﺑﺎر اﻋﻼن ﺷﻮﻧﺪ ﯾﮏ اﻋﻼن ﮐﻪ در ﻓﺎﯾﻠﮫﺎی ‪ header‬ﺻﻮرت ﻣﯽﮔﯿﺮد و ﺗﻌﺮﯾﻒ ﮐﻪ در ﻓﺎﯾﻞ ﻣﻨﺒﻊ ﺑﺎ‬ ‫ﭘﺴﻮﻧﺪ ‪ “C.” .‬اﯾﻦ ﯾﮏ روﻧﺪ ﻣﺴﺘﻌﺪ ﺧﻄﺎ و ﮐﺴﻞ ﮐﻨﻨﺪه اﺳﺖ ‪ .‬ﺑﻪ ﻃﻮر واﺿﺢ ﺑﺮﻧﺎﻣﻪﻧﻮﯾﺲ ﻓﻘﻂ ﻧﯿﺎز دارد‬ ‫ﮐﻪ ﯾﮏ ﺑﺎر آن را ﺑﻨﻮﯾﺴﯿﺪ و ﺳﭙﺲ ﮐﺎﻣﭙﺎﯾﻠﺮ ﺑﺎﯾﺪ دادهھﺎی اﻋﻼن را ﺑﺴﻂ دھﺪ و ﺑﺮای وارد ﮐﺮدن ﻧﻤﺎدﯾﻦ در‬ ‫دﺳﺘﺮس ﻗﺮار دھﺪ‪ .‬دﻗﯿﻘﺎً آن ﮔﻮﻧﻪ ﮐﻪ ‪ D‬ﻣﯽﮐﻨﺪ‪ :‬ﻣﺜﺎل‬ ‫;‪class ABC { int func() { return 7; } static int z = 7; } int q‬‬ ‫دﯾﮕﺮ ﻧﯿﺎز ﺑﻪ ﺗﻌﺮﯾﻒ ﺟﺪای ﺗﻮاﺑﻊ ﻋﻀﻮ‪ ،‬اﻋﻀﺎی اﺳﺘﺎﺗﯿﮏ ‪extern ،‬ھﺎ ﯾﺎ اﻣﻼھﺎﯾﯽ ﻣﺎﻧﻨﺪ زﯾﺮ ﻧﯿﺴﺖ ‪:‬‬ ‫;‪int ABC::func() { return 7; } int ABC::z = 7; extern int q‬‬ ‫ﺗﺬﮐﺮ ‪ :‬اﻟﺒﺘﻪ در ‪ C++‬ﺗﻮاﺑﻊ ﺟﺰﯾﯽ ﻣﺎﻧﻨﺪ }‪ {;return 7‬ﺑﻪ ﺻﻮرت ‪ inline‬ھﻢ ﻧﻮﺷﺘﻪ ﻣﯽﺷﻮﻧﺪ اﻣﺎ ﺗﻮاﺑﻊ‬ ‫ﭘﯿﭽﯿﺪه ﻧﻪ‪ .‬ﻋﻼوه ﺑﺮآن اﮔﺮ ﯾﮏ ارﺟﺎع ﺑﻌﺪ از آن ﻣﻮﺟﻮد ﺑﺎﺷﺪ ﺗﺎﺑﻊ ﻧﯿﺎز ﺑﻪ اﻟﮕﻮ دارد ﮐﻪ از ﻗﺒﻞ ﻣﻮﺟﻮد ﺑﺎﺷﺪ‬ ‫ﻣﺜﺎل زﯾﺮ در ‪ C++‬ﮐﺎر ﻧﻤﯽ ﮐﻨﺪ ‪.‬‬ ‫اﻣﺎ ;} } ;‪class Foo { int foo(Bar *c) { return c->bar; } }; class Bar { public: int bar() { return 3‬‬ ‫)(‪: class Foo { int foo(Bar c) { return c.bar; } } class Bar { int bar‬ﮐﺎر ﻣﯽ ﮐﻨﺪ ‪ D‬ﮐﺪ ھﻢارز در‬ ‫} } ;‪{ return 3‬‬

‫اﯾﻨﮑﻪ ﯾﮏ ﺗﺎﺑﻊ ‪ D‬ﺑﻪ ﺻﻮرت ‪ inline‬اﺳﺖ ﯾﺎ ﻧﻪ ﺗﻮﺳﻂ ﺗﻨﻈﯿﻤﺎت ﺑﮫﯿﻨﻪﺳﺎز ﻗﺎﺑﻞ ﮐﻨﺘﺮل اﺳﺖ ‪ .‬ﻗﺎﻟﺐھﺎ‬ ‫ﻗﺎﻟﺒﮫﺎی ‪ D‬روﺷﯽ واﺿﺢ ﺑﺮای ﭘﺸﺘﯿﺒﺎﻧﯽ ﺑﺮﻧﺎﻣﻪﺳﺎزی ﻋﻤﻮﻣﯽ ھﻤﺮاه ﺑﺎ ﻗﺪرت اﺧﺘﺼﺎﺻﯽﺳﺎزی ﺑﻪ ﺻﻮرت‬ ‫ﻗﺴﻤﺖ ﺑﻪ ﻗﺴﻤﺖ ‪ ،‬ﭘﯿﺸﻨﮫﺎد ﻣﯽﮐﻨﺪ‪ .‬آراﯾﻪھﺎی ﺷﺮﮐﺖﭘﺬﯾﺮ آراﯾﻪھﺎی ﺷﺮﮐﺖﭘﺬﯾﺮ آراﯾﻪھﺎﯾﯽ ھﺴﺘﻨﺪ ﺑﺎ‬ ‫ﯾﮏ ﻧﻮع داده ﻗﺮاردادی )اﺧﺘﯿﺎری( ﺑﻪ ﻋﻨﻮان اﯾﻨﺪﮐﺲ ﺑﻪ ﺟﺎی آﻧﮑﻪ ﺑﻪ ﯾﮏ اﯾﻨﺪﮐﺲ از ﻧﻮع اﻋﺪاد ﺻﺤﯿﺢ‬ ‫ﻣﺤﺪود ﺑﺎﺷﻨﺪ ‪ .‬در اﺻﻞ آراﯾﻪھﺎی ﺷﺮﮐﺖﭘﺬﯾﺮ ﺟﺪوﻟﮫﺎی ‪ hash‬ھﺴﺘﻨﺪ ‪ .‬اﯾﻦ آراﯾﻪھﺎ ﺳﺎﺧﺘﻦ ﺳﺮﯾﻊ ‪ ،‬ﮐﺎرا و‬ ‫ﺧﺎﻟﯽ از اﺷﮑﺎل ﺟﺪولھﺎی ﺳﻤﺒﻞ را آﺳﺎن ﻣﯽﻧﻤﺎﯾﺪ‪ .‬ﺗﻌﺮﯾﻒ ﻧﻮﻋﮫﺎی واﻗﻌﯽ ﺗﻌﺮﯾﻒ ﻧﻮﻋﮫﺎی ‪ C‬و ‪ C++‬در‬ ‫ﺣﻘﯿﻘﺖ ﻧﺎم ﻣﺴﺘﻌﺎر ﻧﻮع ھﺴﺘﻨﺪ ﻃﻮرﯾﮑﻪ ھﯿﭻ ﻧﻮع ﺟﺪﯾﺪی ﺑﻪ ﻃﻮر واﻗﻌﯽ ﻣﻄﺮح ﻧﻤﯽﺷﻮد ‪ ،. D‬ﺗﻌﺮﯾﻒ‬ ‫ﻧﻮﻋﮫﺎی واﻗﻌﯽ ﭘﯿﺎدهﺳﺎزی ﻣﯽﮐﻨﺪ ﺟﺎﯾﯽ ﮐﻪ ‪:‬‬ ‫‪;type def int handle‬‬ ‫ﺑﻪ ﻃﻮر واﻗﻌﯽ ﯾﮏ ﻧﻮع ﺟﺪﯾﺪ ﺑﻪ ﻧﺎم ‪ handle‬اﯾﺠﺎد ﻣﯽﮐﻨﺪ ‪ .‬ﺑﺮ ﮐﻨﺘﺮل ﻧﻮع ﺗﺄﮐﯿﺪ ﺷﺪه اﺳﺖ و ﺗﻌﺮﯾﻒ ﻧﻮﻋﮫﺎ‬ ‫در ﺗﻌﺮﯾﻒ ﻣﺠﺪد ﺗﻮاﺑﻊ ﺷﺮﯾﮏ ﻣﯽ ﺷﻮﻧﺪ‪ .‬ﺑﺮای ﻣﺜﺎل ‪:‬‬ ‫;)‪int foo(int i); int foo(handle h‬‬ ‫ﻧﻮع ‪ bit‬ﻧﻮع داده ﭘﺎﯾﻪ ﺑﯿﺖ اﺳﺖ و ‪ D‬ﯾﮏ ﻧﻮع داده ﺑﺎ ﻧﺎم ‪ bit‬دارد ‪ .‬اﯾﻦ اﻣﺮ ﺑﯿﺶ از ھﻤﻪ در ﺳﺎﺧﺖ‬ ‫آراﯾﻪھﺎﯾﯽ از ﺑﯿﺘﮫﺎ ﻣﻔﯿﺪ اﺳﺖ ‪:‬‬ ‫‪;bit [ ] foo‬‬ ‫ﺗﻮاﺑﻊ ‪ D‬ﺗﻮﻗﻊ ﭘﺸﺘﯿﺒﺎﻧﯽ از ﺗﻮاﺑﻊ ﻣﻌﻤﻮل از ﺟﻤﻠﻪ ﺗﻮاﺑﻊ ﻋﻤﻮﻣﯽ ‪ ،‬ﺗﻮاﺑﻊ ﻣﺠﺪد ﺗﻌﺮﯾﻒ ﺷﺪه ‪ ،‬ﺗﻮاﺑﻊ ‪، inline‬‬ ‫ﺗﻮاﺑﻊ ﻋﻀﻮ ‪ ،‬ﺗﻮاﺑﻊ ﻣﺠﺎزی ‪ ،‬اﺷﺎرهﮔﺮھﺎ ﺑﻪ ﺗﻮاﺑﻊ و … را داﺷﺘﻪ اﺳﺖ ﻋﻼوه ﺑﺮآن ‪ :‬ﺗﻮاﺑﻊ ﺗﻮدرﺗﻮ ﺗﻮاﺑﻊ‬ ‫ﻣﯽﺗﻮاﻧﻨﺪ درون ﺗﻮاﺑﻊ دﯾﮕﺮ ﻗﺮار ﮔﯿﺮﻧﺪ ‪ .‬اﯾﻦ اﻣﺮ در ﺳﺎﺧﺖ ﮐﺪ ‪ ،‬ﺧﺎﺻﯿﺖ ‪ locality‬و ﺗﮑﻨﯿﮑﮫﺎی ﺑﺴﺘﻪﺑﻨﺪی‬ ‫ﺗﻮاﺑﻊ ﺑﺴﯿﺎر ﻣﻔﯿﺪ اﺳﺖ‪ .‬ﻟﻔﻆھﺎی ﺗﻮاﺑﻊ ‪ Functionliterals‬ﺗﻮاﺑﻊ ﺑﯽﻧﺎم ﻣﯽ ﺗﻮاﻧﻨﺪ ﺑﻪ ﻃﻮر ﻣﺴﺘﻘﯿﻢ در ﯾﮏ‬ ‫ﻋﺒﺎرت ﺟﺎی داده ﺷﻮﻧﺪ‪ .‬وﮐﺎﻟﺖ )‪(Closure‬دﯾﻨﺎﻣﯿﮏ ﺗﻮاﺑﻊ ﻣﺤﺼﻮر ﺷﺪه و ﺗﻮاﺑﻊ ﻋﻀﻮ ﮐﻼس ﺑﻮﺳﯿﻠﻪ وﮐﺎﻟﺖ‬ ‫)‪(delegate‬ﻣﯽﺗﻮاﻧﻨﺪ ارﺟﺎع داده ﺷﻮﻧﺪ ﮐﻪ اﯾﻦ ﺑﺎﻋﺚ آﺳﺎﻧﺘﺮ ﺷﺪن و ‪ type safe‬ﺷﺪن ﺑﺮﻧﺎﻣﻪﺳﺎزی‬ ‫ﻋﻤﻮﻣﯽ ﻣﯽﺷﻮد‪ .‬ﭘﺎراﻣﺘﺮھﺎی ورودی‪ ،‬ﺧﺮوﺟﯽ ‪ ،‬ورودی ﺧﺮوﺟﯽ اﯾﻦ ﺧﺼﻮﺻﯽﺳﺎزی ﻧﻪ ﺗﻨﮫﺎ ﮐﻤﮏ‬ ‫ﻣﯽﮐﻨﺪ ﮐﻪ ﺗﻮاﺑﻊ ﺧﻮد ﻣﺴﺘﻨﺪﺗﺮ ﺷﻮﻧﺪ ﺑﻠﮑﻪ ﺑﺴﯿﺎری از ﻣﻮارد ﻟﺰوم اﺷﺎرهﮔﺮھﺎ را ﺑﺪون ﻗﺮﺑﺎﻧﯽ ﮐﺮدن ھﯿﭻ‬ ‫ﭼﯿﺰ ﺣﺬف و اﻣﮑﺎﻧﺎﺗﯽ را ﺑﺮای ﮐﻤﮏ ﺑﯿﺸﺘﺮﺑﻪ ﮐﺎﻣﭙﺎﯾﻠﺮ در ﭘﯿﺪا ﮐﺮدن اﺷﮑﺎﻻت ﮐﺪ ﻓﺮاھﻢ ﻣﯽﮐﻨﺪ‪ .‬ﺑﺪﯾﻦ‬ ‫ﺗﺮﺗﯿﺐ ﺑﺮای ‪ D‬اﯾﻦ اﻣﮑﺎن ﻓﺮاھﻢ ﻣﯿﺸﻮد ﮐﻪ ﻣﺴﺘﻘﯿﻤﺎً ﺑﺎ ﯾﮏ ﺑﺎزه وﺳﯿﻌﺘﺮی از ‪ API‬ھﺎی ﺑﯿﮕﺎﻧﻪ ارﺗﺒﺎط ﺑﺮﻗﺮار‬ ‫ﮐﻨﺪ ‪ .‬و ھﯿﭻ ﻧﯿﺎزی ﺑﺮای ﮐﺎرھﺎی ﺟﺎﻧﺒﯽ ﻣﺎﻧﻨﺪ زﺑﺎﻧﮫﺎی ﺗﻌﺮﯾﻒ ارﺗﺒﺎﻃﺎت وﺟﻮد ﻧﺪارد‪ .‬آراﯾﻪھﺎ آراﯾﻪھﺎی ‪C‬‬ ‫اﺷﺘﺒﺎھﺎت ﻣﺘﻌﺪدی دارﻧﺪ ﮐﻪ ﻣﯽ ﺗﻮاﻧﻨﺪ ﺗﺼﺤﯿﺢ ﺷﻮﻧﺪ ‪: 1.‬اﻃﻼﻋﺎت ﺑﻌﺪ ﺑﺎ آراﯾﻪ ھﻤﺮاه ﻧﯿﺴﺖ و ﺑﻨﺎﺑﺮاﯾﻦ ﺑﺎﯾﺪ‬ ‫ذﺧﯿﺮهﺷﺪه و ﺟﺪاﮔﺎﻧﻪ ارﺳﺎل ﺷﻮد ‪ .‬ﻣﺜﺎل ﮐﻼﺳﯿﮏ اﯾﻦ ﻣﻮرد ﭘﺎراﻣﺘﺮھﺎی ‪ argc‬و ‪ argr‬ھﺴﺘﻨﺪ ﮐﻪ ﺑﻪ‬ ‫‪main‬ﻓﺮﺳﺘﺎده ﻣﯽﺷﻮﻧﺪ ‪.‬‬ ‫)][‪main (int argc , char*argv‬‬ ‫‪2.‬آراﯾﻪھﺎ اﺷﯿﺎء ﺳﻄﺢ اول ﻧﯿﺴﺘﻨﺪ ‪.‬وﻗﺘﯽ ﯾﮏ آراﯾﻪ ﺑﻪ ﻋﻨﻮان ﭘﺎراﻣﺘﺮ ﺑﻪ ﯾﮏ ﺗﺎﺑﻊ ﻓﺮﺳﺘﺎده ﻣﯽﺷﻮد ﺑﻪ ﯾﮏ‬ ‫اﺷﺎرهﮔﺮ ﺑﺮﮔﺮداﻧﺪه ﻣﯽﺷﻮد ﺣﺘﯽ ﺑﺎ اﯾﻨﮑﻪ اﻟﮕﻮی ﺗﺎﺑﻊ ﺑﻪ ﻃﻮر ﮔﯿﺞ ﮐﻨﻨﺪهای ﻣﯽ ﮔﻮﯾﺪ ﮐﻪ اﯾﻦ آراﯾﻪ اﺳﺖ ‪.‬‬ ‫وﻗﺘﯽ اﯾﻦ ﺑﺮﮔﺮداﻧﺪن اﻧﺠﺎم ﻣﯽﺷﻮد ﺗﻤﺎم اﻃﻼﻋﺎت ﻧﻮع آراﯾﻪ ﮔﻢ ﻣﯽﺷﻮد ‪. 3.‬آراﯾﻪھﺎی ‪ C‬ﻗﺎﺑﻞ ﺗﻐﯿﯿﺮ اﻧﺪازه‬ ‫ﻧﯿﺴﺘﻨﺪ ‪ .‬اﯾﻦ ﺑﺪان ﻣﻌﻨﯽ اﺳﺖ ﮐﻪ ﺣﺘﯽ ﭼﯿﺰھﺎی ﺳﺎده ‪،‬اﻧﺒﻮه و ﻣﺘﺮاﮐﻢ ﻣﯽﮔﺮدد ﻣﺎﻧﻨﺪ ﯾﮏ ﭘﺸﺘﻪ ﮐﻪ‬ ‫ﻧﯿﺎزدارد ﺑﻪ ﻋﻨﻮان ﯾﮏ ﮐﻼس ﭘﯿﭽﯿﺪه ﺳﺎﺧﺘﻪ ﺷﻮد‪.۴ .‬ﻣﺮز ﯾﮏ آراﯾﻪ ‪ C‬ﻗﺎﺑﻞ ﮐﻨﺘﺮل ﻧﯿﺴﺖ ﭼﻮن اﺻﻼً ﻣﺮز‬ ‫آراﯾﻪ ﻣﺸﺨﺺ ﻧﯿﺴﺖ‪.۵ .‬آراﯾﻪھﺎ ﺑﺎ ﻋﻼﻣﺖ ] [ ﭘﺲ از ﺷﻨﺎﺳﻪ اﻋﻼن ﻣﯽﺷﻮﻧﺪ ‪ .‬اﯾﻦ ﺑﻪ ﯾﮏ اﻣﻼی ﺑﯽﺧﻮد‬ ‫و ﮔﯿﺞ ﮐﻨﻨﺪه در اﻋﻼن اﺷﯿﺎﯾﯽ ﻣﺎﻧﻨﺪ اﺷﺎرهﮔﺮ ﺑﻪ ﯾﮏ آراﯾﻪ ﻣﯽاﻧﺠﺎﻣﺪ ‪:‬‬ ‫;]‪int (*array ) [3‬‬ ‫در ‪ D‬ﻋﻼﻣﺖ ] [ در ﺳﻤﺖ ﭼﭗ ﻗﺮار ﻣﯽﮔﯿﺮد ﮐﻪ ﻓﮫﻢ آن ﺑﺴﯿﺎر ﺳﺎدهﺗﺮ اﺳﺖ; ‪. int [3] * array‬اﻋﻼن‬ ‫ﯾﮏ اﺷﺎرهﮔﺮ ﺑﻪ ﯾﮏ آراﯾﻪ ﺳﻪﺗﺎﯾﯽ از اﻋﺪاد ﺻﺤﯿﺢ;)‪ Long [ ] func (int x‬ﺗﺎﺑﻌﯽ ﮐﻪ آراﯾﻪ ای از اﻋﺪاد‬ ‫ﺻﺤﯿﺢ ﺑﻠﻨﺪ را ﺑﺮﻣﯽ ﮔﺮداﻧﺪ آراﯾﻪھﺎی ‪ D‬در ﭼﮫﺎر ﻧﻮع ﻣﯽآﯾﻨﺪ ‪ :‬اﺷﺎرهﮔﺮھﺎ ‪ ،‬آراﯾﻪھﺎی اﺳﺘﺎﺗﯿﮏ ‪،‬‬ ‫آراﯾﻪھﺎی دﯾﻨﺎﻣﯿﮏ و آراﯾﻪھﺎی ﺷﺮﮐﺖﭘﺬﯾﺮ ‪،‬ﻗﺴﻤﺖ آراﯾﻪھﺎ را ﺑﺒﻨﯿﺪ ! رﺷﺘﻪھﺎ ﭘﺮدازش رﺷﺘﻪھﺎ آن ﻗﺪر‬ ‫ﻣﺘﺪاول اﺳﺖ )و آن ﻗﺪر در ‪ C‬و ‪ C++‬زﻣﺨﺖ و ﺑﺪﺗﺮﮐﯿﺐ( ﮐﻪ ﻧﯿﺎزﻣﻨﺪ ﭘﺸﺘﯿﺒﺎﻧﯽ ﻣﺴﺘﻘﯿﻢ در زﺑﺎن ﺑﺮﻧﺎﻣﻪ‬ ‫ﺳﺎزی اﺳﺖ ‪ .‬زﺑﺎﻧﮫﺎی ﻣﺪرن از ﺟﻤﻠﻪ ‪ ، D‬اﻟﺤﺎق رﺷﺘﻪھﺎ ‪ ،‬ﮐﭙﯽ ﮐﺮدن و … را در دﺳﺖ ﻣﯽﮔﯿﺮﻧﺪ ‪.‬‬ ‫رﺷﺘﻪھﺎ رھﺎورد ﻣﺴﺘﻘﯿﻢ ﭘﺮدازش ﺑﮫﯿﻨﻪ ﺷﺪه آراﯾﻪھﺎ ھﺴﺘﻨﺪ‪.‬‬

‫زﺑﺎن ﺑﺮﻧﺎﻣﻪﻧﻮﻳﺴﯽ ‪ D‬ﺑﺨﺶ ﺳﻮم‬

‫ﮐﻨﺘﺮل ﻣﻨﺎﺑﻊ )‪(Collection Grabage‬‬ ‫ﺗﺨﺼﯿﺺ ﺣﺎﻓﻈﻪ در ‪ D‬ﮐﺎﻣﻼً ﺑﺎ ﺟﻤﻊآوری زﺑﺎﻟﻪ ھﻤﺮاه اﺳﺖ‪ .‬ﺗﺠﺮﺑﻪ ﺷﮫﻮدی ﺑﯿﺎن ﻣﯽﮐﻨﺪ ﮐﻪ ﺗﻌﺪاد زﯾﺎدی‬ ‫از ﺧﺼﻮﺻﯿﺎت ‪ C++‬ﺑﺮای ﮐﻨـــﺘﺮل رھﺎﺳﺎزی ﺣﺎﻓﻈــــﻪ ﻻزم اﺳﺖ ‪ .‬ﺑﺎ ﺟﻤــﻊآوری زﺑﺎﻟﻪ زﺑﺎن ﺑﺴﯿﺎر ﺳﺎدهﺗﺮ‬ ‫ﻣﯽﺷﻮد‪.‬‬ ‫ﺣﮑﻤﯽ ھﺴﺖ ﮐﻪ ﻣﯽ ﮔﻮﯾﺪ ﺟﻤﻊآوری زﺑﺎﻟﻪ ﺑﺮای ﺟﻮﺟﻪ ﺑﺮﻧﺎﻣﻪﻧﻮﯾﺴﮫﺎ و ﺗﻨﺒﻞھﺎ اﺳﺖ‪ .‬ﻣﻦ ﺑﻪ ﯾﺎد دارم‬ ‫زﻣﺎﻧﯽ را ﮐﻪ اﯾﻦ ﺣﺮف در ﻣﻮرد ‪ C++‬ﮔﻔﺘﻪ ﻣﯽ ﺷﺪ ‪ .‬ﺑﻌﺪ از ھﻤﻪ ھﯿﭻ ﭼﯿﺰ در ‪ C++‬ﻧﯿﺴﺖ ﮐﻪ در ‪ C‬ﻗﺎﺑﻞ‬ ‫اﻧﺠﺎم ﻧﺒﺎﺷﺪ ﯾﺎ در اﺳﻤﺒﻠﺮ ﺑﺮای آن ﻣﻨﻈﻮر ‪.‬‬ ‫ﺧﺼﻮﺻﯿﺎت ﺟﻤﻊآوری زﺑﺎﻟﻪ ﮐﺪ ﺧﺴﺘﻪ ﮐﻨﻨﺪه ﭘﯿﮕﯿﺮی ﺗﺨﺼﯿﺺ ﺣﺎﻓﻈﻪھﺎی ﻣﺴﺘﻌﺪ ﺧﻄﺎ ﮐﻪ در ‪ C‬و ‪C++‬‬ ‫ﻻزم اﺳﺖ را ﺣﺬف ﻣﯽﮐﻨﺪ ‪ .‬اﯾﻦ ﻧﻪ ﺗﻨﮫﺎ ﺑﺪﯾﻦ ﻣﻌﻨﺎﺳﺖ ﮐﻪ ﮔﺴﺘﺮش ﺑﺮﻧﺎﻣﻪھﺎ ﺳﺮﯾﻌﺘﺮ اﻧﺠﺎم ﻣﯽﮔﯿﺮد و‬ ‫ھﺰﯾﻨﻪھﺎی ﻧﮕﮫﺪاری ﮐﺎھﺶ ﻣﯽ ﯾﺎﺑﺪ ﺑﻠﮑﻪ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﻣﯿﺰان زﯾﺎدی در دﻓﻌﺎت اﺟﺮا ﺳﺮﯾﻌﺘﺮ اﺳﺖ‪.‬‬ ‫ﮐﻨﺘﺮل ﺣﺎﻓﻈﻪ ﺳﺎده و واﺿﺢ‬ ‫ﺑﺎ وﺟﻮد اﯾﻨﮑﻪ ‪ D‬ﯾﮏ زﺑﺎن دارای ﺟﻤﻊآوری زﺑﺎﻟﻪ اﺳﺖ ‪ ،‬اﻋﻤﺎل ‪ new‬و ‪ delete‬ﻣﯽﺗﻮاﻧﻨﺪ در ﮐﻼﺳﮫﺎی‬ ‫ﺧﺎص اﺟﺮا ﺷﻮﻧﺪ ھﻤﺎﻧﮕﻮﻧﻪ ﮐﻪ ﯾﮏ ﺗﺨﺼﯿﺺ دھﻨﺪه ﺳﻔﺎرﺷﯽ ﺑﻪ ﮐﺎر ﻣﯽرود‪.‬‬ ‫‪RAII‬‬ ‫‪ RAII‬ﯾﮏ ﺗﮑﻨﯿﮏ ﭘﯿﺸﺮﻓﺘﻪ ﮔﺴﺘﺮش ﻧﺮماﻓﺰار ﺑﺮای ﮐﻨﺘﺮل ﺗﺨﺼﯿﺺ ﻣﻨﺎﺑﻊ و آزادﺳﺎزی آﻧﮫﺎ اﺳﺖ ‪ D ،‬از‬ ‫‪ RAII‬در ﯾﮏ روش ﮐﻨﺘﺮل ﺷﺪه ﻗﺎﺑﻞ ﭘﯿﺶﺑﯿﻨﯽ ﮐﻪ ﻣﺴﺘﻘﻞ از ﭼﺮﺧﻪ ﺟﻤﻊآوری زﺑﺎﻟﻪ اﺳﺖ ﭘﺸﺘﯿﺒﺎﻧﯽ‬ ‫ﻣﯽﮐﻨﺪ ‪.‬‬ ‫ﮐﺎراﯾﯽ‬ ‫ﺗﻮده ﺳﺒﮏ وزن‬ ‫‪ D‬ﺳﺎﺧﺘﻤﺎنھﺎی ﺳﺒﮏ ﺳﺎده ‪ C‬را ﭘﺸﺘﯿﺒﺎﻧﯽ ﻣﯽﮐﻨﺪ ھﻢ ﺑﺮای ﺳ ﺎزﮔﺎری ﺑﺎ ﺳﺎﺧﺘﻤﺎن دادهھﺎی ‪ C‬و ﻧﯿﺰ‬ ‫ﺑﻪ ﺧﺎﻃﺮ اﯾﻨﮑﻪ آﻧﮫﺎ در ﺟﺎھﺎﯾﯽ ﮐﻪ ﻗﺪرت ﮐﺎﻣﻞ ﮐﻼﺳﮫﺎ ﮐﺎراﯾﯽ ﻧﺪارد ﻣﻔﯿﺪﻧﺪ‪.‬‬ ‫‪Assembler Inline‬‬ ‫دراﯾﻮر ﺳﺨﺖ اﻓﺰار ‪ ،‬ﮐﺎرﺑﺮدھﺎی ﺳﯿﺴﺘﻤﯽ ﺑﺎ ﮐﺎراﯾﯽ ﺑﺎﻻ ‪ ،‬ﺳﯿﺴﺘﻢ ھﺎی ﺗﻌﺒﯿﻪ ﺷﺪه و ﮐﺪھﺎی ﺧﺼﻮﺻﯽ‬ ‫ﺷﺪه ﺑﻌﻀﯽ وﻗﺘﮫﺎ ﻧﯿﺎز ﺑﻪ ﻏﺮق ﺷﺪن در زﺑﺎن اﺳﻤﺒﻠﯽ دارﻧﺪ ﺗﺎ ﮐﺎر اﻧﺠﺎم ﺷﻮد ‪ .‬در ﺣﺎﻟﯽ ﮐﻪ ﭘﯿﺎده ﺳﺎزی‬ ‫ھﺎی ‪ D‬ﻧﯿﺎز ﺑﻪ ﮐﺎرﮔﯿﺮی اﺳﻤﺒﻠﺮ ﺧﻄﯽ ﻧﺪارﻧﺪ ‪ ،‬اﯾﻦ ﺧﺼﻮﺻﯿﺖ ﺗﻌﺮﯾﻒ ﺷﺪه و ﻗﺴﻤﺘﯽ از زﺑﺎن اﺳﺖ ‪.‬‬ ‫اﻏﻠﺐ ﻧﯿﺎزھﺎی ﮐﺪ اﺳﻤﺒﻠﯽ ﺑﻪ وﺳﯿﻠﻪ اﯾﻦ ﺑﺨﺶ ﻗﺎﺑﻞ ﺑﺮآوری اﺳﺖ ﮐﻪ ﻧﯿﺎز ﺑﻪ اﺳﻤﺒﻠﺮھﺎی ﺟﺪاﮔﺎﻧﻪ و‬ ‫‪ DLL‬ھﺎ را ﻣﺮﺗﻔﻊ ﻣﯽ ﺳﺎزد ‪.‬‬ ‫ھﻤﭽﻨﯿﻦ ﺑﺴﯿﺎری از ﭘﯿﺎده ﺳﺎزی ھﺎی ‪ D‬ﺗﻮاﺑﻊ اﺻﻠﯽ را ﺷﺒﯿﻪ ﺑﻪ ﭘﺸﺘﯿﺒﺎﻧﯽ ذاﺗﯽ ‪ C‬از ﭘﺮدازش درﮔﺎھﮫﺎی‬ ‫ورودی ﺧﺮوﺟﯽ ‪ ،‬دﺳﺘﺮﺳﯽ ﻣﺴﺘﻘﯿﻢ ﺑﻪ ﻋﻤﻠﯿﺎﺗﮫﺎی ﻣﻤﯿﺰ ﺷﻨﺎور و … ﭘﺸﺘﯿﺒﺎﻧﯽ ﻣﯽ ﮐﻨﺪ ‪.‬‬ ‫ﻗﺎﺑﻠﯿﺖ اﻋﺘﻤﺎد‬ ‫ﯾﮏ زﺑﺎن ﭘﯿﺸﺮﻓﺘﻪ ﺑﺎﯾﺪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺲ را در رﻓﻊ ﺗﻤﺎﻣﯽ اﺷﮑﺎﻻت از ﮐﺪ ﯾﺎری ﮐﻨﺪ ‪ .‬اﯾﻦ ﮐﻤﮏ ﺑﻪ ﭼﻨﺪﯾﻦ‬ ‫ﺻﻮرت ﻣﯽ ﺗﻮاﻧﺪ اراﺋﻪ ﺷﻮد ‪ .‬از آﺳﺎن ﺳﺎزی ﮐﺎرﺑﺮد ﺗﮑﻨﯿﮑﮫﺎی ﻗﺪرﺗﻤﻨﺪ ﺗﺮ ‪ ،‬ﺗﺎ ﮔﻮﺷﺰد ﮐﺮدن ﮐﺪ ﻏﻠﻂ‬ ‫آﺷﮑﺎرا ﺗﻮﺳﻂ ﮐﻤﭙﺎﯾﻠﺮ و ﮐﻨﺘﺮل زﻣﺎن اﺟﺮا ‪.‬‬ ‫ﻣﻌﺎھﺪات ) ‪( Contracts‬‬ ‫ﻃﺮاﺣﯽ ﺑﻪ وﺳﯿﻠﻪ ﮐﻨﺘﺮات ) ﺳﺎﺧﺘﻪ ‪ ( B.Meyer‬ﯾﮏ ﺗﮑﻨﯿﮏ اﻧﻘﻼﺑﯽ ﺑﺮای ﮐﻤﮏ ﺑﻪ ﻣﻄﻤﺌﻦ ﺷﺪن از ﺻﺤﺖ‬ ‫ﺑﺮﻧﺎﻣﻪ اﺳﺖ و ﻧﺴﺨﻪ ‪ DBC‬زﺑﺎن ‪ D‬ﺷﺎﻣﻞ ﭘﯿﺶ ﺷﺮﻃﮫﺎی ﺗﻮاﺑﻊ ‪ ،‬ﭘﺲ ﺷﺮﻃﮫﺎی ﺗﻮاﺑﻊ ‪ ،‬ﯾﮑﺴﺎﻧﯽ ھﺎی‬ ‫ﮐﻼس و ﮐﻨﺘﺮاﮐﺘﮫﺎی ﺛﺎﺑﺖ ﮐﻨﻨﺪه اﺳﺖ ‪.‬‬ ‫آزﻣﺎﯾﺶ واﺣﺪ‬ ‫آزﻣﺎﯾﺶ ﻗﺴﻤﺘﮫﺎ ﻣﯽ ﺗﻮاﻧﺪ ﺑﻪ ﯾﮏ ﮐﻼس اﻓﺰوده ﺷﻮد ﻃﻮری ﮐﻪ ﺑﻪ ﺻﻮرت ﺧﻮدﮐﺎر در ﻟﺤﻈﻪ ﺷﺮوع اﺟﺮای‬ ‫ﺑﺮﻧﺎﻣﻪ اﺟﺮا ﺷﻮﻧﺪ ‪ .‬اﯾﻦ در ھﺸﺪار دادن اﯾﻨﮑﻪ ﭘﯿﺎده ﺳﺎزی ﮐﻼس در ھﺮ ﺑﺎر ﺳﺎﺧﺘﻪ ﺷﺪن ‪،‬ﺳﮫﻮاً ﺑﺎ‬ ‫ﺷﮑﺴﺖ ﻣﻮاﺟﻪ ﻧﺸﺪه اﺳﺖ ﻣﻔﯿﺪ اﺳﺖ آزﻣﺎﯾﺶ واﺣﺪ ﻗﺴﻤﺘﯽ از ﮐﺪ ﮐﻼس را ﺗﺸﮑﯿﻞ ﻣﯽ دھﺪ ‪ .‬اﯾﺠﺎد‬ ‫آﻧﮫﺎ ﯾﮏ ﻗﺴﻤﺖ ﻃﺒﯿﻌﯽ ﭘﺮ دارد ﮔﺴﺘﺮش ﮐﻼس ﺧﻮاھﺪ ﺷــــﺪ ﺑﺮﺧﻼف ﭘﺸﺖ ﮔﻮش اﻧﺪاﺧﺘﻦ ﮐﺪ ﺗﻤﺎم‬ ‫ﺷﺪه از ﮔﺮوھﮫﺎی آزﻣﺎﯾﺶ‪.‬‬ ‫آزﻣﺎﯾﺶ واﺣﺪ در دﯾﮕﺮ زﺑﺎﻧﮫﺎ ﻗﺎﺑﻞ اﻧﺠﺎم اﺳﺖ اﻣﺎ ﻧﺘﯿﺠﻪ ﺟﺎﻟﺐ از آب در ﻧﻤﯽ آﯾﺪ زﯾﺮا اﯾﻦ زﺑﺎﻧﮫﺎ ﺑﺎ اﯾﻦ ﻓﮑﺮ‬ ‫ﻋﺠﯿﻦ ﻧﯿﺴﺘﻨﺪ ‪ .‬آزﻣﺎﯾﺶ واﺣﺪ ﯾﮏ ﺧﺼﻮﺻﯿﺖ اﺻﻠﯽ و ﺑﺎرز در ‪ D‬اﺳﺖ ‪ .‬ﺑﺮای ﺗﻮاﺑﻊ ﮐﺘﺎﺑﺨﺎﻧﻪ ای ﺑﻪ ﺧﻮﺑﯽ‬

‫ﻋﻤﻞ ﻣﯽ ﮐﻨﺪ ھﻢ ﺿﻤﺎﻧﺖ ﻣﯽ ﮐﻨﺪ ﮐﻪ ﺗﺎﺑﻊ ﺣﻘﯿﻘﺘﺎً ﮐﺎر ﻣﯽ ﮐﻨﺪ و ھﻢ ﺑﺎ ﻣﺜﺎل ﺑﯿﺎن ﻣﯽ ﮐﻨﺪ ﮐﻪ ﺗﺎﺑﻊ‬ ‫ﭼﮕﻮﻧﻪ ﮐﺎر ﻣﯽ ﮐﻨﺪ ‪ .‬ﺧﯿﻞ ﮐﺜﯿﺮ ﮐﺪھﺎی ﻣﻨﺸﺎء ﮐﺎرﺑﺮدی و ﮐﺘﺎﺑﺨﺎﻧﻪ ھﺎی ‪ C++‬ﻣﻮﺟﻮد در اﯾﻨﺘﺮﻧﺖ ﺑﺮای‬ ‫داﻧﻠﻮد را در ﻧﻈﺮ ﺑﮕﯿﺮﯾﺪ ‪ .‬ﭼﻪ ﺗﻌﺪاد از آﻧﮫﺎ ﺑﺎ ﺗﺴﺘﮫﺎی ﮐﻠﯽ ھﻤﺮاه اﺳﺖ ) ﺗﺴﺖ واﺣﺪ را ھﻢ در ﻧﻈﺮ‬ ‫ﻧﮕﯿﺮﯾﺪ ( ؟ ﮐﻤﺘﺮ از ﯾﮏ درﺻﺪ ‪ .‬روش ﻣﻌﻤﻮل اﯾﻦ اﺳﺖ ﮐﻪ اﮔﺮ ﮐﺎﻣﭙﺎﯾﻞ ﺷﺪه اﺟﺮا ھﻢ ﻣﯽ ﺷﻮد و ﺷﮕﻔﺖ‬ ‫زده ﺧﻮاھﯿﻢ ﺷﺪ اﮔﺮ ھﺸﺪارھﺎی ﮐﺎﻣﭙﺎﯾﻠﺮ اﺷﮑﺎﻻت واﻗﻌﯽ ﺑﺎﺷﻨﺪ ‪.‬‬ ‫در ﮐﻨﺎر ﻃﺮاﺣﯽ ﺑﺎ ﮐﻨﺘﺮاﮐﺖ ‪ ،‬آزﻣﺎﯾﺶ واﺣﺪ ‪ D ،‬را ﺑﻪ ﻣﺮاﺗﺐ ﺑﻪ ﺑﮫﺘﺮﯾﻦ زﺑﺎن ﺑﺮای ﻧﻮﺷﺘﻦ ﻗﺎﺑﻞ اﻋﺘﻤﺎد و‬ ‫ﮐﺎرﺑﺮدھﺎی ﺳﯿﺴﺘﻤﯽ ﻗﺪرﺗﻤﻨﺪ ﺗﺒﺪﯾﻞ ﻣﯽ ﮐﻨﺪ‪.‬‬ ‫ﺧﺼﻮﺻﯿﺎت و ﺷﺮح اﺷﮑﺎل زداﯾﯽ‬ ‫اﮐﻨﻮن اﺷﮑﺎل زداﯾﯽ ﺑﺨﺸﯽ از اﻣﻼی زﺑﺎن اﺳﺖ ) ‪ . ( debug‬ﮐﻪ در زﻣﺎن ﮐﺎﻣﭙﺎﯾﻞ ﻗﺎﺑﻞ ﻓﻌﺎل ﯾﺎ ﻏﯿﺮ ﻓﻌﺎل‬ ‫ﺷﺪن اﺳﺖ ﺑﺪون ﮐﺎرﺑﺮد دﺳﺘﻮرات ﭘﯿﺶ ﭘﺮدازﻧﺪه ﯾﺎ ﻣﺎﮐﺮوھﺎ ‪ .‬اﻣﻼی ‪ debug‬ﯾﮏ ﻗﺎﺑﻠﯿﺖ ﺗﺸﺨﯿﺺ ﺳﺎزﮔﺎر‬ ‫ اﺳﺘﻮار و ﻗﺎﺑﻞ ﺣﻤﻞ و ﻗﺎﺑﻞ ﻓﮫﻢ را ﻓﻌﺎل ﻣﯽ ﮐﻨﺪ ﮐﻪ آﯾﺎ ﮐﺪ ﻣﻨﺒﻊ ﺣﻘﯿﻘﯽ ﻗﺎﺑﻞ اﯾﺠﺎد در ﮐﺎﻣﭙﺎﯾﻞ اﺷﮑﺎل‬‫زداﯾﯽ و ﮐﺎﻣﭙﺎﯾﻞ ﻧﮫﺎﯾﯽ ھﺴﺖ ؟‬ ‫ﭘﺮدازش اﺳﺘﺜﻨﺎء‬ ‫ﻣﺪل ﺑﺮﺗﺮ ‪ finally - try - catch‬ﺑﻪ ﺟﺎی ﻣﺪل ﻓﻘﻂ ‪ try - catch‬ﺑﻪ ﮐﺎر رﻓﺘﻪ اﺳﺖ ‪ .‬ﻧﯿﺎز ﻧﯿﺴﺖ ﮐﻪ اﺷﯿﺎی‬ ‫زاﺋﺪ اﯾﺠﺎد ﮐﻨﯿﻢ ﻓﻘﻂ ﺑﺮای اﯾﻨﮑﻪ ﻣﻌﻨﺎھﺎی ﻧــــﮫﺎﯾﯽ را ﺗﻮﺳﻂ ﻣﺨﺮب ) ‪ ( destructor‬ﭘﯿﺎده ﺳﺎزی ﮐﻨﯿﻢ ‪.‬‬ ‫ھﻤﺎھﻨﮕﯽ و ھﻢ زﻣﺎﻧﯽ‬ ‫ﺑﺮﻧﺎﻣﻪ ﺳﺎزی ﭼﻨﺪ رﺷﺘﻪ ای ﻣﺘﺪاوﻟﺘﺮ ﻣﯽ ﺷﻮد و ‪ D‬ﻣﺒﻨﺎھﺎﯾﯽ ﺑﺮای ﺳﺎﺧﺖ ﺑﺮﻧﺎﻣﻪ ھﺎی ﭼﻨﺪ رﺷﺘﻪ ای‬ ‫ﻓﺮاھﻢ ﻣﯽ ﮐﻨﺪ ‪ .‬ھﻢ زﻣﺎن ﺳﺎزی ﻣﯽ ﺗﻮاﻧﺪ ھﻢ در ﺳﻄﺢ ﻣﺘﺪ و ھﻢ در ﺳﻄﺢ ﺷﯿﺌﯽ اﻧﺠﺎم ﺷﻮد ‪.‬‬ ‫‪{.} ( ) synchronize int func‬‬ ‫ﺗﻮاﺑﻊ ھﻤﺰﻣﺎن ﺷﺪه ) ﺳﻨﮑﺮون ﺷﺪه ( در ھﺮ زﻣﺎن ﻓﻘﻂ ﺑﻪ ﯾ ﮏ رﺷﺘﻪ اﺟﺎزه ﻣﯽ دھﻨﺪ ﮐﻪ آن ﺗﺎﺑﻊ را اﺟﺮا‬ ‫ﮐﻨﺪ ‪ .‬ﻋﺒﺎرت ‪ synchronix\ze‬در اﻃﺮاف ﻗﻄﻌﻪ ای از ﻋﺒﺎرات اﺣﺎﻃﻪ ﻣﯽ ﮐﻨﺪ و دﺳﺘﺮﺳﯽ ﺑﻪ وﺳﯿﻠﻪ ﺷﯿﺌﯽ‬ ‫ﯾﺎ ﺑﻪ ﺻﻮرت ﻋﻤﻮﻣﯽ را ﮐﻨﺘﺮل ﻣﯽ ﮐﻨﺪ ‪.‬‬ ‫ﭘﺸﺘﯿﺒﺎﻧﯽ ﺗﮑﻨﯿﮑﮫﺎی ﻗﺪرﺗﻤﻨﺪ‬ ‫آراﯾﻪ ھﺎی دﯾﻨﺎﻣﯿﮏ ﺑﻪ ﺟﺎی اﺷﺎره ﮔﺮ ھﺎ‬ ‫ﻣﺘﻐﯿﯿﺮھﺎی ارﺟﺎﻋﯽ ﺑﻪ ﺟﺎی اﺷﺎره ﮔﺮ ھﺎ‬ ‫اﺷﯿﺎی ارﺟﺎﻋﯽ ﺑﻪ ﺟﺎی اﺷﺎره ﮔﺮھﺎ‬ ‫ﺟﻤﻊ آوری زﺑﺎﻟﻪ ﺑﻪ ﺟﺎی ﮐﻨﺘﺮل واﺿﺢ و دﺳﺘﯽ ﺣﺎﻓﻈﻪ‬ ‫ﻣﺒﺎﻧﯽ ﻣﻮﺟﻮد ﺑﺮای ھﻤﺰﻣﺎﻧﯽ رﺷﺘﻪ ھﺎ‬ ‫ﻋﺪم وﺟﻮد ﻣﺎﮐﺮوﯾﯽ ﮐﻪ ﺑﻪ ﻃﻮر ﻏﯿﺮ ﻋﻤﺪی ﺑﻪ ﮐﺪ آﺳﯿﺐ ﺑﺰﻧﺪ ‪.‬‬ ‫ﺗﻮاﺑﻊ ‪ inline‬ﺑﻪ ﺟﺎی ﻣﺎﮐﺮوھﺎ‬ ‫ﮐﺎھﺶ وﺳﯿﻊ ﻧﯿﺎز ﺑﻪ اﺷﺎره ﮔﺮھﺎ‬ ‫ﺳﺎﯾﺰ اﻧﻮاع ﻣﺮﮐﺐ واﺿﺢ و ﻣﺸﺨﺺ اﺳﺖ‬ ‫ﻋﺪم ﺷﮏ در ﻣﻮرد ﻋﻼﻣﺖ دار ﺑﻮدن ﮐﺎراﮐﺘﺮ ھﺎ‬ ‫ﻋﺪم ﻧﯿﺎز ﺑﻪ دوﺑﺎر اﻋﻼن در ﮐﺪ ﻣﻨﺒﻊ و ﻓﺎﯾﻠﮫﺎی ‪header‬‬ ‫ﭘﺸﺘﯿﺒﺎﻧﯽ واﺿﺢ از ﺗﺠﺰﯾﻪ و ﺗﺤﻠﯿﻞ ﺑﺮای اﻓﺰودن ﮐﺪ اﺷﮑﺎل زداﯾﯽ‬

‫آﺷﻨﺎﯾﯽ ﺑﺎ زﺑﺎن ‪ D‬ﻗﺴﻤﺖ ﭼﮫﺎرم‬ ‫ﮐﻨﺘﺮل ھﺎی زﻣﺎن ﮐﺎﻣﭙﺎﯾﻞ‬ ‫ﮐﻨﺘﺮل ﻧﻮع ﻗﻮی ﺗﺮ‬ ‫• اﻧﺘﺴﺎب ﻣﻘﺎدﯾﺮ ﺑﻪ ﺻﻮرت واﺿﺢ ﻣﻮرد ﻧﯿﺎز اﺳﺖ‬ ‫• ﻣﺠﺎز ﻧﺒﻮدن ﻣﺘﻐﯿﯿﺮھﺎی ﻣﺤﻠﯽ ﺑﻪ ﮐﺎر ﻧﺮﻓﺘﻪ‬ ‫• ﻋﺪم ؛ ﺧﺎﻟﯽ در ﺑﺪﻧﻪ ﺣﻠﻘﻪ ھﺎ‬ ‫• اﻧﺘﺴﺎب ؛ ﻣﻘﺎدﯾﺮ ﺑﻮﻟﯽ ﺑﺮ ﻧﻤﯽ ﮔﺮداﻧﺪ‬ ‫• ﻧﭙﺴﻨﺪﯾﺪن ‪ API‬ھﺎی ﻣﺘﺮوک‬ ‫ﮐﻨﺘﺮل زﻣﺎن اﺟﺮا‬ ‫• ﻋﺒﺎرات اﺛﺒﺎت ﺻﺤﺖ ‪( ) assert‬‬ ‫• ﮐﻨﺘﺮل ﻣﺮزھﺎی آراﯾﻪ‬ ‫• ‪ case‬ﺗﻌﺮﯾﻒ ﻧﺸﺪه در اﺳﺘﺜﻨﺎی ‪switch‬‬ ‫• اﺳﺘﺜﻨﺎی ﺧﺎرج از ﺣﺎﻓﻈﻪ‬ ‫• ورودی ‪ ،‬ﺧﺮوﺟﯽ و ﻃﺮاﺣﯽ ﯾﮑﺴﺎن ﮐﻼس ﺑﻪ وﺳﯿﻠﻪ ﮐﻨﺘﺮاﮐﺖ‬

‫ﺳﺎزﮔﺎری‬ ‫ﺗﻘﺪم ﻋﻤﻠﮕﺮ و ﻗﻮاﻧﯿﻦ ﺳﻨﺠﺶ‬ ‫‪ D‬ﻋﻤﻠﮕﺮھﺎی ‪ C‬و ﻗﻮاﻧﯿﻦ ﺗﻘﺪم آﻧﮫﺎ را ﺣﻔﻆ ﻣﯽ ﮐﻨﺪ ھﻤﭽﻨﯿﻦ ﺗﺮﺗﯿﺐ ﻗﻮاﻧﯿﻦ ﺳﻨﺠﺶ و ﻗﻮاﻧﯿﻦ ﺗﻘﺪم ‪ .‬اﯾﻦ‬ ‫از اﺷﮑﺎﻻت رﯾﺰ ﮐﻪ از اﺑﺘﺪای ﺑﺮﻧﺎﻣﻪ ﻧﻤﺎﯾﺎن ﻣﯽ ﺷﻮد ﺟﻠﻮﮔﯿﺮی ﻣﯽ ﮐﻨﺪ ‪.‬‬ ‫دﺳﺘﺮﺳﯽ ﻣﺴﺘﻘﯿﻢ ﺑﻪ ‪ API‬ھﺎی ‪C‬‬ ‫ﻧﻪ ﺗﻨﮫﺎ ‪ D‬ﻧﻮع داده ھﺎی ﻣﻄﺎﺑﻖ ﺑﺎ ‪ C‬دارد ھﻤﭽﻨﯿﻦ دﺳﺘﺮﺳﯽ ﻣﺴﺘﻘﯿﻢ ﺑﻪ ﺗﻮاﺑﻊ ‪ C‬را ﻓﺮاھﻢ ﻣﯽ ﺳﺎزد ‪.‬‬ ‫ھﯿﭻ ﻧﯿﺎزی ﻧﯿﺴﺖ ﮐﻪ ﺗﻮاﺑﻊ ﺑﺴﺘﻪ ﺑﻨﺪی ﺷﺪه ﻧﻮﺷﺘﻪ ﺷﻮد ﯾﺎ ﮐﺪی ﺑﺮای ﮐﭙﯽ ﮐﺮدن اﺟﺰای ﻣﺘﺮاﮐﻢ ﯾﮏ‬ ‫ﺗﻮده ﺑﻪ ﺻﻮرت ﯾﮏ ﺑﻪ ﯾﮏ‬ ‫ﭘﺸﺘﯿﺒﺎﻧﯽ از ﺗﻤﺎم ﻧﻮع داده ھﺎی ‪C‬‬ ‫ارﺗﺒﺎط ﺑﺎ ھﺮ ‪ API‬زﺑﺎن ‪ C‬و ﯾﺎ ﮐﺪ ﮐﺘﺎﺑﺨﺎﻧﻪ ای ‪ C‬ﻣﻤﮑﻦ اﺳﺖ ‪ .‬اﯾﻦ ﭘﺸﺘﯿﺒﺎﻧﯽ ﺗﻤﺎم اﻧﻮاع ‪ ٩٩C‬را در ﺑﺮ ﻣﯽ‬ ‫ﮔﯿﺮد ‪ D .‬ﺷﺎﻣﻞ ﺗﻮاﻧﺎﯾﯽ ﺻﻒ ﺑﻨﺪی اﻋﻀﺎی ﺳﺎﺧﺘﻤﺎن اﺳﺖ ﺑﺮای ﻣﻄﻤﺌﻦ ﺷﺪن از ﺳﺎزﮔﺎری ﺑﺎ ﻓﺮﻣﺘﮫﺎی‬ ‫داده ﺧﺎرﺟﯽ ‪.‬‬ ‫ﭘﺮدازش اﺳﺘﺜﻨﺎی ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ‬ ‫ﻣﮑﺎﻧﯿﺴﻢ ﭘﺮدازش اﺳﺘﺜﻨﺎھﺎی ‪ D‬ﻣﺘﺼﻞ ﺑﻪ روﺷﯽ اﺳﺖ ﮐﻪ ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ در ﺳﻄﺢ زﯾﺮﯾﻦ اﺳﺘﺜﻨﺎھﺎ را‬ ‫در ﯾﮏ ﮐﺎرﺑﺮد ﭘﺮدازش ﻣﯽ ﮐﻨﺪ ‪.‬‬

‫اﺑﺰارھﺎی ﻣﻮﺟﻮد را ﺑﻪ ﮐﺎر ﻣﯽ ﮔﯿﺮد ‪.‬‬ ‫‪ D‬ﮐﺪ را در ﻓﺮﻣﺖ اﺳﺘﺎﻧﺪارد ﻓﺎﯾﻞ ‪ Object‬اﯾﺠﺎد ﻣﯽ ﮐﻨﺪ ﮐﻪ ﺑﺎﻋﺚ اﻣﮑﺎن اﺳﺘﻔﺎده از اﺳﻤﺒﻠﺮھﺎ ‪ ،‬ﻟﯿﻨﮑﺮھﺎ‬ ‫‪،‬اﺷﮑﺎل زداھﺎ ) ‪ ، ( debugger‬ﻓﺸﺮده ﺳﺎزھﺎی ‪ exe‬و دﯾﮕﺮ ﺗﺤﻠﯿﻞ ﮐﻨﻨﺪه ھﺎی اﺳﺘﺎﻧﺪارد ﺑﻪ ﺧﻮﺑﯽ ﻟﯿﻨﮏ‬ ‫ﮐﺮدن ﮐﺪی ﮐﻪ دﯾﮕﺮ زﺑﺎﻧﮫﺎ ﻧﻮﺷﺘﻪ ﺷﺪه اﺳﺖ ﻣﯽ ﺷﻮد‪.‬‬ ‫ﮐﻨﺘﺮل ﭘﺮوژه‬ ‫ﻧﺴﺨﻪ ﺳﺎزی‬ ‫‪ D‬ﺑﻪ ﺻﻮرت دروﻧﯽ اﻣﮑﺎن اﯾﺠﺎد ﻧﺴﺨﻪ ھﺎی ﻣﺘﻌﺪد از ﯾﮏ ﺑﺮﻧﺎﻣﻪ ﯾﺎ ھﻤﺎن ﻣﺘﻦ را دارد ‪ D .‬ﺗﮑﻨﯿﮏ ‪ if #‬و ‪#‬‬ ‫‪ end if‬ﭘﯿﺶ ﭘﺮدازﻧﺪهی ‪ C‬را ﺟﺎﯾﮕﺰﯾﻦ ﻣﯽ ﮐﻨﺪ ‪.‬‬ ‫ﻧﺒﻮد ھﺸﺪار‬ ‫ﮐﺎﻣﭙﺎﯾﻠﺮھﺎی ‪ D‬ھﺸﺪارھﺎﯾﯽ ﺑﺮای ﮐﺪھﺎی ﻧﺎﻣﻄﻤﺌﻦ ﺗﻮﻟﯿﺪ ﻧﻤﯽ ﮐﻨﻨﺪ ‪ .‬ﮐﺪ ﯾﺎ ﺗﻮﺳﻂ ﮐﺎﻣﭙﺎﯾﻠﺮ ﻗﺎﺑﻞ ﻗﺒﻮل‬ ‫اﺳﺖ ﯾﺎ ﻧﯿﺴﺖ ‪ .‬اﯾﻦ ھﺮ ﮔﻮﻧﻪ ﺑﺤﺜﯽ در اﯾﻦ زﻣﯿ ﻨﻪ ﮐﻪ آﯾﺎ ھﺸﺪار ﺧﻄﺎﯾﯽ ﺻﺤﯿﺢ اﺳﺖ ﯾﺎ ﻧﻪ و ﻧﯿﺰ ھﺮ‬ ‫ﺑﺤﺜﯽ در اﯾﻦ ﺑﺎره ﮐﻪ ﺑﺎ ﭼﻪ ﮐﻨﯿﻢ را از ﺑﯿﻦ ﻣﯽ ﺑــــﺮد ‪ .‬ﻧﯿﺎز ﺑﺮای ھﺸﺪار ﮐﺎﻣﭙﺎﯾﻠﺮ ﻧﺸﺎﻧﻪی ﻃﺮاﺣﯽ ﺿﻌﯿﻒ‬ ‫زﺑﺎن اﺳﺖ ‪.‬‬ ‫اﺳﺘـﮫﻼک‬ ‫ھﻤﺎن ﻃﻮر ﮐﻪ در ﻃﻮل زﻣﺎن رﺷﺪ ﻣﯽ ﮐﻨﺪ ﺑﻌﻀﯽ ﮐﺪھﺎی ﮐﮫﻨﻪ ﮐﺘﺎﺑﺨﺎﻧﻪ ﺑﺎ ﻧﻮ ﺗﺮ و ﻧﺴﺨﻪ ﺑﮫﺘﺮ ﺟﺎﯾﮕﺰﯾﻦ‬ ‫ﻣﯽ ﺷﻮد ‪ .‬ﻧﺴﺨﻪ ﻗﺪﯾﻤﯽ ﺑﺎﯾﺪ ﺑﺮای ﭘﺸﺘﯿﺒﺎﻧﯽ ﮐﺪھﺎی ﺑﻪ ﺟﺎ ﻣﺎﻧﺪه از ﻗﺒﻞ ﻣﻮﺟﻮد ﺑﺎﺷﺪ اﻣﺎ ﻣﯽ ﺗﻮاﻧﻨﺪ‬ ‫ﻟﻘﺐ ﻣﺴﺘﮫﻠﮏ ﺑﮕﯿﺮﻧﺪ ‪ .‬ﮐﺪھﺎﯾﯽ ﮐﻪ ﻧﺴﺨﻪ ھﺎی ﻣﺴﺘﮫﻠﮏ را ﺑﻪ ﮐﺎر ﻣﯽ ﮔﯿﺮﻧﺪ ﺑﻪ وﺳﯿﻠﻪ ﺗﻌﻮﯾﺾ ﮐﻤﭙﺎﯾﻠﺮ‬ ‫ﺑﺮﭼﺴﺐ ﻏﯿﺮ ﻗﺎﻧﻮﻧﯽ م ﯾﺦ ورﻧﺪ ﮐﻪ ﺑﺮای اﺑﻘﺎی ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺲ ﺑﺮای ﻧﺸﺎن دادن ھﺮ واﺑﺴﺘﮕﯽ ﺑﻪ ﺧﺼﻮﺻﯿﺎت‬ ‫ﻣﺴﺘﮫﻠﮏ ﺑﺎﻋﺚ آﺳﺎﻧﯽ اﺳﺖ ‪.‬‬ ‫ﻧﻤﻮﻧﻪ ﺑﺮﻧﺎﻣﻪ ‪ ) D‬ﻏﺮﺑﺎل اراﺗﺴﺘﻦ واﺣﺪ اول (‬

‫; ‪import c.stdio‬‬ ‫; ‪bit [8191] flags‬‬ ‫)( ‪int main‬‬ ‫; ‪{ int i , count , prime , k , inter‬‬ ‫;) ”‪print f(“ 10 iterations \n‬‬ ‫) ‪for ( iter = 1 ; iter<=10 ; iter ++‬‬ ‫; ‪{ count = 0‬‬ ‫; ‪flags [ ] = 1‬‬

‫) ‪for ( i = 0 ; i < flags . length ; i ++‬‬ ‫) ]‪{ if ( flags [i‬‬ ‫‪{ prime = i + i +3‬‬ ‫‪k = i + prime‬‬ ‫) ‪while ( k < flags . length‬‬ ‫; ‪{ flags , [ k] = 0‬‬ ‫}; ‪k + = prime‬‬ ‫}‪count + = 1‬‬ ‫; ) ‪print f ( “ % d primes” , count‬‬ ‫;‪return 0‬‬ ‫آﺷﻨﺎﯾﯽ ﺑﺎ زﺑﺎن ‪ D‬ﻗﺴﻤﺖ ﭘﻨﺠﻢ‬ ‫ﻣﻘﺎدﯾﺮ واﺳﻄﻪ ﻣﻤﯿﺰ ﺷﻨﺎور‬ ‫در ﺑﺴﯿﺎری ﮐﺎﻣﭙﯿﻮﺗﺮھﺎ ‪،‬اﻋﻤﺎل ﺑﺎ دﻗﺖ ﺑﺎﻻﺗﺮ ﺑﯿﺸﺘﺮ از اﻋﻤﺎل ﺑﺎ دﻗﺖ ﮐﻤﺘﺮ وﻗﺖ ﻧﻤﯽ ﮔﯿﺮﻧﺪ ‪.‬اﯾﻦ ﺑﺎﻋﺚ ﻣﯽ‬ ‫ﺷﻮﻧﺪ ﮐﻪ ﻣﻔﺎھﯿﻢ ﺷﻤﺎرﺷﯽ ﺑﺎﻻﺗﺮﯾﻦ دﻗﺖ ﻣﻤﮑﻦ را ﺑﺮای اﻋﻤﺎل داﺧﻠﯽ ﻣﻮﻗﺘﯽ ﺑﻪ ﮐﺎر ﺑﺒﺮﻧﺪ ‪ .‬ﻓﻠﺴﻔﻪ‬ ‫ﻣﻮرد ﺑﺤﺚ اﯾﻦ اﺳﺖ ﮐﻪ زﺑﺎن را ﺑﻪ ﭘﺎﺋﯿﻦ ﻣﻘﺴﻮم ﻋﻠﯿﻪ ﺳﺨﺖ اﻓﺰاری ﻣﺤﺪود ﮐﻨﯿﻢ ﺑﻠﮑﻪ آن را ﻗﺎدر ﺑﻪ‬ ‫ﺑﮫﺮهﺑﺮداری از ﺑﮫﺘﺮﯾﻦ ﺗﻮاﻧﺎﯾﯽ ھﺎی ﺳﺨﺖ اﻓﺰار ﻣﻮرد ﻧﻈﺮ ﻧﻤﺎﯾﯿﻢ ‪.‬‬ ‫ﺑﺮای اﻋﻤﺎل ﻣﻤﯿﺰ ﺷﻨﺎور و ﻣﻘﺎدﯾﺮ واﺳﻄﻪ ﻋﺒﺎرت ﯾﮏ دﻗﺖ ﺑﺎﻻﺗﺮ از ﻧﻮع ﻋﺒﺎرت ﻣﯽ ﺗﻮاﻧﺪ ﺑﻪ ﮐﺎر رود ‪ .‬ﺗﻨﮫﺎ‬ ‫ﺣﺪاﻗﻞ دﻗﺖ ﺗﻮﺳﻂ ﻧﻮع ﻋﻤﻠﻮﻧﺪھﺎ ﻣﺸﺨﺺ ﻣﯽ ﺷﻮﻧﺪ ﻧﻪ ﺣﺪاﮐﺜﺮ دﻗﺖ ‪ .‬ﻧﮑﺘﻪ ﭘﯿﺎده ﺳﺎزی ‪ :‬در ﻣﺎﺷﯿﻦ‬ ‫ھﺎی اﯾﻨﺘﻞ ‪ ٨۶x‬ﺑﺮای ﻧﻤﻮﻧﻪ اﻧﺘﻈﺎر ﻣﯽ رود ) اﻣﺎ ﻻزم ﻧﯿﺴﺖ ( ﮐﻪ ﻣﺤﺎﺳﺒﺎت واﺳﻄﻪ ای در دﻗﺖ ﮐﺎﻣﻞ‬ ‫ھﺴﺘﺎد ﺑﯿﺘﯽ ﮐﻪ ﺗﻮﺳﻂ ﺳﺨﺖ اﻓﺰار ﭘﯿﺎده ﺳﺎزی ﻣﯽ ﺷﻮد اﻧﺠﺎم ﺷﻮد ‪.‬‬ ‫اﻣﮑﺎن دارد ﮐﻪ در ﻣﺴﯿﺮ اﺳﺘﻔﺎده از ﻣﻘﺎدﯾﺮ ﻣﻮﻗﺖ و زﯾﺮ ﻋﺒﺎرات ﻣﻌﻤﻮل ‪ ،‬ﮐﺪ ﺑﮫﯿﻨﻪ ﺷﺪه ﯾﮏ ﺟﻮاب دﻗﯿﻘﺘﺮ‬ ‫از ﮐﺪ ﺑﮫﯿﻨﻪ ﻧﺸﺪه ﻓﺮاھﻢ ﺳﺎزد ‪.‬‬ ‫اﻟﮕﻮرﯾﺘﻢ ھﺎ ﺑﺎﯾﺪ ﻃﻮری ﻧﻮﺷﺘﻪ ﺷﻮد ﮐﻪ ﺑﺮاﺳﺎس ﺣﺪاﻗﻞ دﻗﺖ ﻣﺤﺎﺳﺒﺎت ﮐﺎر ﮐﻨﺪ ‪ .‬آﻧﮫﺎ ﻧﺒﺎﯾﺪ در ﻣﻮاﻗﻌﯽ‬ ‫ﮐﻪ دﻗﺖ واﻗﻌﯽ ﺑﺎﻻﺗﺮ اﺳﺖ از ﻧﻈﺮ ﻋﻤﻠﮑﺮد ﺗﻨﺰل ﯾﺎﺑﻨﺪ ﯾﺎ ﺷﮑﺴﺖ ﺑﺨﻮرﻧﺪ ‪ .‬اﻧﻮاع ‪ double‬ﯾﺎ ‪ float‬ﺑﺮﺧﻼف‬ ‫ﻧﻮع ﮔﺴﺘﺮش ﯾﺎﻓﺘﻪ ﻓﻘﻂ ﺑﺎﯾﺪ در ﻣﻮارد زﯾﺮ ﺑﻪ ﮐﺎر رود ‪:‬‬ ‫• ﮐﺎھﺶ ﻣﺼﺮف ﺣﺎﻓﻈﻪ ﺑﺮای آراﯾﻪ ھﺎی ﺑﺰرگ ‪.‬‬ ‫• داده ھﺎ و آرﮔﻮﻣﺎن ھﺎی ﺗﻮاﺑﻊ ﺳﺎزﮔﺎر ﺑﺎ ‪. C‬‬ ‫اﻧﻮاع ﻣﻮھﻮﻣﯽ و ﻣﺨﺘﻠﻂ‬ ‫در زﺑﺎن ھﺎی ﻣﻮﺟﻮد ‪ ،‬ﯾﮏ ﺗﻼش ﻋﺠﯿﺐ ﺑﺮای ﺑﻪ زور ﺟﺎ دادن اﻧﻮاع ﻣﺨﺘﻠﻂ در ﺗﺴﮫﯿﻼت ﺗﻌﺮﯾﻒ ﻧﻮع ﻣﻮﺟﻮد‬ ‫ﻣﺎﻧﻨﺪ ﻗﺎﻟﺐ ھﺎ ‪،‬ﺳﺎﺧﺘﻤﺎن ھﺎ و … وﺟـــــــﻮد دارد و ﺗﻤﺎم اﯾﻨــــﮫﺎ ﻣﻌﻤـــــﻮ ﻻً در ﻧﮫﺎﯾﺖ ﺑﺎ ﺷﮑﺴﺖ ﻣﻮاﺟﻪ‬ ‫ﻣﯽﺷﻮﻧﺪ ‪.‬‬ ‫ﺷﮑﺴﺖ ﻣﯽ ﺧﻮرﻧﺪ ﭼﻮن ﻣﻔﺎھﯿﻢ اﻋﻤﺎل ﻣﺨﺘﻠﻂ ﻣﯽ ﺗﻮاﻧﺪ ﺑﺴﯿﺎر دﻗﯿﻖ ﺑﺎﺷﺪ و ﮐﺎﻣﭙﺎﯾﻠﺮ ﻧﻤﯽ داﻧﺪ ﮐﻪ‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺲ در ﺗﻼش ﺑﺮای اﻧﺠﺎم ﭼﻪ ﮐﺎری اﺳﺖ ﺑﻨﺎﺑﺮاﯾﻦ ﻧﻤﯽ ﺗﻮاﻧﺪ ﭘﯿﺎده ﺳﺎزی ﻣﻌﻨﺎﯾﯽ را ﺑﮫﯿﻨﻪ ﻧﻤﺎﯾﺪ ‪.‬‬ ‫ﺗﻤﺎم اﯾﻦ ﮐﺎرھﺎ ﺑﺮای اﺟﺘﻨﺎب از اﺿﺎﻓﻪ ﮐﺮدن ﯾﮏ ﻧﻮع ﺟﺪﯾﺪ اﻧﺠﺎم ﺷﺪه اﺳﺖ ‪ .‬اﺿﺎﻓﻪ ﮐﺮدن ﯾﮏ ﻧﻮع ﺟﺪﯾﺪ‬ ‫ﺑﺪﯾﻦ ﻣﻌﻨﺎﺳﺖ ﮐﻪ ﮐﺎﻣﭙﺎﯾﻠﺮ ﻣﯽ ﺗﻮاﻧﺪ ﺗﻤﺎﻣﯽ ﻣﻔﺎھﯿﻢ اﻋﻤﺎل ﻣﺨﺘﻠﻂ را دﻗﯿﻖ ﭘﯿﺎده ﮐﻨﺪ ‪ .‬ﭘﺲ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺲ‬ ‫ﻣﯽ ﺗﻮاﻧﺪ ﺑﺮ ﯾﮏ ﭘﯿﺎده ﺳﺎزی ﺻﺤﯿﺢ ) ﯾﺎ ﺣﺪاﻗﻞ دارای ﺛﺒﺎت ( اﻋﺪاد ﻣﺨﺘﻠﻂ اﻋﺘﻤﺎد ﮐﻨﺪ ‪.‬‬ ‫ھﻤﺮاه ﺑﻮدن ﺑﺎ ﯾﮏ ﺑﺴﺘﻪ ﻧﻮع ﻣﺨﺘﻠﻂ ﺑﺮای ﯾﮏ ﻧﻮع ﻣﻮھﻮﻣﯽ ﻣﻮرد ﻧﯿﺎز اﺳﺖ ‪.‬ﯾﮏ ﻧﻮع ﻣﻮھﻮﻣﯽ ﺑﺮﺧﯽ از‬ ‫ﭘﯿﺎﻣﺪھﺎی ﻇﺮﯾﻒ ﻣﻌﻨﺎﯾﯽ را ﺣﺬف ﻣﯽ ﮐﻨﺪ و ﮐﺎرآﯾﯽ را ﺑﮫﺒﻮد ﻣﯽ ﺑﺨﺸﺪ ﺑﺪون اﯾﻨﮑﻪ ﻣﺠﺒﻮر ﺑﻪ اﻧﺠﺎم‬ ‫اﻋﻤﺎل اﺿﺎﻓﯽ روی ﻗﺴﻤﺖ ﺣﻘﯿﻘﯽ واﺿﺢ ﺻﻔﺮ ‪ ،‬ﺑﺎﺷﯿﻢ ‪ .‬اﻟﻔﺎظ ﻣﻮھﻮﻣﯽ دارای ﯾﮏ ﭘﺴﻮﻧﺪ ‪ i‬ﻣﯽ‬ ‫ﺑﺎﺷﻨﺪ ‪.‬‬ ‫= ‪; i ١٫٣imaginary j‬‬ ‫ھﯿﭻ اﻣﻼی ﺧﺎص ﻟﻔﻆ ﻣﺨﺘﻠﻂ وﺟﻮد ﻧﺪارد ﻓﻘﻂ ﯾﮏ ﻧﻮع ﺣﻘﯿﻘﯽ و ﻣﻮھﻮﻣﯽ را ﺑﺎ ھﻢ ﺟﻤﻊ ﮐﻨﯿﺪ ‪:‬‬ ‫=‪; i٢+ ۴٫۵complex c‬‬ ‫اﻓﺰودن دو ﻧﻮع ﺟﺪﯾﺪ ﺑﻪ زﺑﺎن ﮐﺎﻓﯽ اﺳﺖ از اﯾﻦ رو اﻧﻮاع ﻣﺨﺘﻠﻂ و ﻣﻮھﻮﻣﯽ دارای دﻗﺖ ﺗﻮﺳﻌﻪ ﯾﺎﻓﺘﻪ‬ ‫ھﺴﺘﻨﺪ ‪ .‬ھﯿﭻ ﻧﻮع اﻋﺸﺎری ﻣﺨﺘﻠﻂ و ﻣﻮھﻮﻣﯽ ﯾﺎ ﻧﻮع داﺑﻞ ﻣﺨﺘﻠﻂ ﯾﺎ ﻣﻮھﻮﻣﯽ وﺟﻮد ﻧﺪارد ) ﺗﻮﺟﻪ ‪ :‬راه‬ ‫ﺑﺮای اﻓﺰودن آﻧﮫﺎ در آﯾﻨﺪه ﺑﺎز اﺳﺖ اﻣﺎ ﻣﻄﻤﺌﻦ ﻧﯿﺴﺘﯿﻢ ﻣﻮرد ﻧﯿﺎز ﺑﺎﺷﺪ ( ‪.‬‬ ‫اﻋﺪاد ﻣﺨﺘﻠﻂ دارای دو ﺻﻔﺖ ﺧﺎﺻﻪ ھﺴﺘﻨﺪ ‪:‬‬ ‫ﻗﺴﻤﺖ ﺣﻘﯿﻘﯽ را ﺑﻪ ﻋﻨﻮان ﮔﺴﺘﺮش ﯾﺎﻓﺘﻪ ﺑﺪﺳﺖ ﻣﯽ دھﺪ ‪re. .‬‬ ‫ﻗﺴﻤﺖ ﻣﻮھﻮﻣﯽ را ﺑﻪ ﻋﻨﻮان ﻋﺪد ﻣﻮھﻮﻣﯽ ﺑﺪﺳﺖ ﻣﯽ دھﺪ ‪im. .‬‬ ‫ﺑﺮای ﻣﺜﺎل ‪:‬‬ ‫‪c . re is 4.5‬‬ ‫‪c . im is 2i‬‬

‫ﮐﻨﺘﺮل ﮔﺮد ﮐﺮدن‬ ‫ﺣﺴﺎﺑﮕﺮ ﻣﻤﯿﺰ ﺷﻨﺎور ‪ ٧۵۴IEEE‬ﺷﺎﻣﻞ ﺗﻮاﻧﺎﯾﯽ ﺗﻨﻈﯿﻢ ﮐﺮدن ﭼﮫﺎر روش ﮔﺮد ﮐﺮدن اﺳﺖ ‪ D .‬اﻣﻼﯾﯽ‬ ‫ﺧﺎص ﺑﺮای دﺳﺘﺮﺳﯽ ﺑﻪ آﻧﮫﺎ اﻓﺰوده اﺳﺖ ‪[ blah , blah , blah ] :‬‬ ‫ﭘﺮﭼﻤﮫﺎی اﺳﺘﺜﻨﺎء‬ ‫ﺣﺴﺎﺑﮕﺮ ﻣﻤﯿﺰ ﺷﻨﺎور ‪ ٧۵۴IEEE‬ﻣﯽ ﺗﻮاﻧﺪ ﭘﺮﭼﻤﮫﺎی ﻣﺨﺘﻠﻒ را ﺑﺮاﺳﺎس آن ﭼﻪ در ﯾﮏ ﻣﺤﺎﺳﺒﻪ رخ داده‬ ‫اﺳﺖ ﺗﻨﻈﯿﻢ ﻧﻤﺎﯾﺪ ‪ .[ blah , blah , blah ] :‬اﯾﻦ ﭘﺮﭼﻤﮫﺎ ﻣﯽ ﺗﻮاﻧﻨﺪ ﺑﻪ وﺳﯿﻠﻪ اﻣﻼی زﺑﺎن ‪Reset / SET‬‬ ‫ﺷﻮﻧﺪ ‪.‬‬ ‫ﻣﻘﺎﯾﺴﻪ ھﺎی ﻣﻤﯿﺰ ﺷﻨﺎور‬ ‫ﻋﻼوه ﺑﺮ ﻋﻤﻠﮕﺮھﺎی ﻣﻘﺎﯾﺴﻪ ﻣﻌﻤﻮﻟﯽ > ‪ =! , == , =< , < , = > ,‬زﺑﺎن ‪ D‬ﺗﻌﺪاد ﺑﯿﺸﺘﺮی ﮐﻪ ﺧﺎص‬ ‫اﻋﺪاد ﻣﻤﯿﺰ ﺷﻨﺎور اﺳﺖ اﺿﺎﻓﻪ ﻣﯽ ﮐﻨﺪ ‪.‬‬ ‫ﻣﺪﯾﺮﯾﺖ ﺣﺎﻓﻈﻪ‬ ‫ھﺮ ﺑﺮﻧﺎﻣﻪ ﻏﯿﺮ ﺟﺰﯾﯽ ﻧﯿﺎز ﺑﻪ ﺗﺨﺼﯿﺺ و آزاد ﺳﺎزی ﺣﺎﻓﻈﻪ دارد ‪ .‬ھﺮ ﭼﻪ ﭘﯿﭽﯿﺪﮔﯽ ‪ ،‬اﻧﺪازه و ﮐﺎرآﯾﯽ ﺑﺮﻧﺎﻣﻪ‬ ‫ھﺎ اﻓﺰاﯾﺶ ﻣﯽ ﯾﺎﺑﺪ ﺗﮑﻨﯿﮑﮫﺎی ﻣﺪﯾﺮﯾﺖ ﺣﺎﻓﻈﻪ ﻣﮫﻤﺘﺮ ﻣﯽ ﺷﻮﻧﺪ ‪ D .‬اﺧﺘﯿﺎرات ﻣﺘﻌﺪدی در زﻣﯿﻨﻪ ﻣﺪﯾﺮﯾﺖ‬ ‫ﺣﺎﻓﻈﻪ ﭘﯿﺸﮑﺶ ﻣﯽ ﮐﻨﺪ ‪.‬‬ ‫ﺳﻪ روش ﭘﺎﯾﻪ ﺗﺨﺼﯿﺺ ﺣﺎﻓﻈﻪ در ‪: D‬‬ ‫‪ -١‬داده اﺳﺘﺎﺗﯿﮏ ‪ :‬در ﺳﮕﻤﻨﺖ داده ﭘﯿﺶ ﻓﺮض ﺗﺨﺼﯿﺺ ﻣﯽ ﯾﺎﺑﻨﺪ ‪.‬‬ ‫‪ -٢‬داده ﭘﺸﺘﻪ ‪ :‬در ﭘﺸﺘﻪ ﺑﺮﻧﺎﻣﻪ ‪ CPU‬ﺗﺨﺼﯿﺺ ﻣﯽ ﯾﺎﺑﻨﺪ ‪.‬‬ ‫‪ -٣‬داده زﺑﺎﻟﻪ ﺟﻤﻊ آوری ﺷﺪه ‪ :‬ﺑﻪ ﺻﻮرت ﭘﻮﯾﺎ در ‪ heap‬ﺟﻤﻊ آوری زاﺑﻠﻪ ﺗﺨﺼﯿﺺ ﻣﯽ ﯾﺎﺑﻨﺪ ‪.‬‬ ‫اﯾﻦ ﻗﺴﻤﺖ ﺑﻌـــﺪی ﺗﮑﻨﯿــــﮑﮫﺎ را ﺑﺮای اﺳﺘــــﻔﺎده از آﻧﮫﺎ ﺗﻮﺿﯿﺢ ﻣﯽ دھﺪ ﺑﻪ ھﻤﺮاه ﺑﺮﺧﯽ ﻗﺎﺑﻠﯿﺖ ھﺎی‬ ‫ﭘﯿﺸﺮﻓﺘﻪ‪:‬‬ ‫رﺷﺘﻪ ھﺎ ) و آراﯾﻪ ھﺎ ( ‪copy – on – write‬‬ ‫ﻓﺮﺳﺘﺎدن ﯾﮏ آراﯾﻪ ﺑﻪ ﯾﮏ ﺗﺎﺑﻊ را در ﻧﻈﺮ ﺑﮕﯿﺮﯾﺪ و اﺣﺘﻤﺎﻻً ﺗﻐﯿﯿﺮ دادن آراﯾﻪ و ﺑﺮﮔﺮداﻧﺪن آراﯾﻪ ﺟﺪﯾﺪ ‪ .‬از آﻧﺠﺎ‬ ‫ﮐﻪ آراﯾﻪ ھﺎ ﺑﺎ ارﺟﺎع ﻓﺮﺳﺘﺎده ﻣﯽ ﺷﻮﻧﺪ ﻧﻪ ﺑﺎ ﻣﻘﺪار ‪ ،‬ﯾﮏ ﭘﯿﺎﻣﺪ وﺧﯿﻢ اﯾﻦ اﺳﺖ ﮐﻪ ﻣﺤﺘﻮﯾﺎت آراﯾﻪ از آن‬ ‫ﮐﯿﺴﺖ ؟ ﺑﺮای ﻣﺜﺎل ﺗﺎﺑﻌﯽ ﮐﻪ آراﯾﻪ ای از ﮐﺎراﮐﺘﺮھﺎ را ﺑﻪ ﺣﺮوف ﺑﺰرگ ﺑﺮﻣﯽ ﮔﺮداﻧﺪ ‪.‬‬ ‫) ‪char [] toupper ( char [] S‬‬ ‫; ‪int i‬‬ ‫) ‪for ( i =0 ; i < S . length ; i ++‬‬ ‫) ’‪char ( ‘a’ <= c && c<=’z‬‬ ‫;) ’‪S[i] = c – ( cast (char) ‘a’ – ‘A‬‬ ‫;‪Return S‬‬ ‫ﺗﻮﺟﻪ ﮐﻨﯿﺪ ﮐﻪ ﻧﺴﺨﻪ ‪ []S‬ﮐﻪ ﻓﺮاﺧﻮاﻧﯽ ﺷﺪ ﺗﻐﯿﯿﺮ ھﻢ ﮐﺮد ﺷﺎﯾﺪ اﯾﻦ اﺻﻼً آن ﭼﯿﺰ ﻣﻮرد ﺗﻮﻗﻊ ﻧﺒﻮد ﯾﺎ ﺑﺪﺗﺮ‬ ‫آﻧﮑﻪ ‪ []S‬ﻣﻤﮑﻦ اﺳﺖ ﺗﮑﻪ ای از ﺣﺎﻓﻈﻪ ﻓﻘﻂ ﺧﻮاﻧﺪﻧﯽ ﺑﺎﺷﺪ ‪.‬‬ ‫اﮔﺮ ﯾﮏ ﮐﭙﯽ از ‪ S‬ھﻤﻮاره ﺗﻮﺳﻂ ﺗﺎﺑﻊ ﺳﺎﺧﺘﻪ ﻣﯽ ﺷﺪ ﺑﻪ ﻃﻮر ﻧﺎﮐﺎرا و ﺑﺪون ﻟﺰوم زﻣﺎن ﺣﺎﻓﻈﻪ ﺑﺮای‬ ‫ﺣﺮوﻓﯽ ﮐﻪ ﺧﻮدﺷﺎن ﺑﺰرگ ھﺴﺘﻨﺪ ﻣﺼﺮف ﻣﯽ ﺷﺪ ‪.‬‬ ‫راه ﺣﻞ ﭘﯿﺎده ﺳﺎزی ‪ copy – on – write‬اﺳﺖ ﮐﻪ ﯾﻌﻨﯽ ﯾﮏ ﮐﭙﯽ ﺳﺎﺧﺘﻪ ﻣﯽ ﺷﻮد اﮔﺮ رﺷﺘﻪ ھﺎ ﻧﯿﺎز ﺑﻪ‬ ‫ﺗﻐﯿﯿﺮ دارﻧﺪ ﺑﻌﻀﯽ زﺑﺎن ھﺎی ﭘﺮدازﻧﺪه رﺷﺘﻪ ھﺎ اﯾﻦ ﻋﻤﻞ را ﺑﻪ ﻋﻨﻮان ﭘﯿﺶ ﻓﺮض اﻧﺠﺎم ﻣﯽ دھﻨﺪ اﻣﺎ‬ ‫ھﺰﯾﻨﻪ ﺑﺴﯿﺎر ﺳﻨﮕﯿﻦ اﺳﺖ ‪.‬‬ ‫در ﻧﺘﯿﺠﻪ آن رﺷﺘﻪ “ ”‪ ۵abcdwF‬ﻣﺮﺗﺒﻪ ﺑﻮﺳﯿﻠﻪ ﺗﺎﺑﻊ ﮐﭙﯽ ﻣﯽ ﺷﻮد ‪ .‬ﺑﺮای اﯾﻨﮑﻪ از اﯾﻦ ﻗﺮارداد ﺑﻪ ﻧﺤﻮی ﺑﺎ‬ ‫ﺣﺪاﮐﺜﺮ ﮐﺎرآﯾﯽ اﺳﺘﻔﺎده ﺷﻮد ﺑﺎﯾﺪ ﺑﻪ ﺻﻮرت واﺿﺢ در ﮐﺪ ﻇﺎھﺮ ﺷﻮد ‪.‬‬ ‫)‪char [] toupper (char [] s‬‬ ‫; ‪int changed‬‬ ‫; ‪int i‬‬ ‫; ‪changed = 0‬‬ ‫) ‪for i=0 ; i <S-length ; i ++‬‬ ‫; ] ‪char c – S[i‬‬ ‫) ’‪if (‘a’ <= c && c<= ‘z‬‬ ‫) ‪if ( ! changed‬‬ ‫; ]‪char [] r = new char [ S.length‬‬ ‫; ‪r []= S‬‬ ‫; ‪changed = 1‬‬

‫;) ’‪S [i] = c – ( cast ( char ) ‘a’ – ‘A‬‬ ‫; ‪return S‬‬ ‫‪ copy – on – write‬ﭘﺮوﺗﮑﻠﯽ اﺳﺖ ﮐﻪ ﺑﻪ وﺳﯿﻠﻪ ﺗﻮاﺑﻊ ﭘﺮدازش آراﯾﻪ ھﺎ در ﮐﺘﺎﺑﺨﺎﻧﻪ زﻣﺎن اﺟﺮای ‪phibo‬‬ ‫زﺑﺎن ‪ D‬ﭘﯿﺎده ﺳﺎزی ﺷﺪه اﺳﺖ ‪.‬‬ ‫ﺟﻤﻊ آوری زﺑﺎﻟﻪ‬ ‫‪ D‬زﺑﺎﻧﯽ دارای ﺟﻤﻊ آوی زﺑﺎﻟﻪ ﮐﺎﻣﻞ ﻣﯽ ﺑﺎﺷﺪ ‪ .‬ﺑﺪﯾﻦ ﻣﻌﻨﯽ ﮐﻪ ھﯿﭻ وﻗﺖ ﻧﯿﺎز ﺑﻪ آزادﺳﺎزی ﺣﺎﻓﻈﻪ‬ ‫ﻧﯿﺴﺖ ‪ .‬ﻓﻘﻂ ﺑﻪ ھﻨﮕﺎم ﻧﯿﺎز ﺣﺎﻓﻈﻪ را ﺗﺨﺼﯿﺺ دھﯿﺪ و ﺟﻤﻊ آور زﺑﺎﻟﻪ ﺑﻪ ﻃﻮر دوره ای ﺗﻤﺎم ﺣﺎﻓﻈﻪ ﺑﯽ‬ ‫اﺳﺘﻔﺎده را ﺑﻪ ﺗﻮده ﺣﺎﻓﻈﻪ آزاد ﺑﺮﻣﯽ ﮔﺮداﻧﺪ ‪.‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﺎن ‪ C ++ , C‬ﮐﻪ ﺑﻪ ﮐﻨﺘﺮل دﺳﺘﯽ ﺣﺎﻓﻈﻪ ھﻨﮕﺎم ﺗﺨﺼﯿﺺ و آزاد ﺳﺎزی آن ﻋﺎدت دارﻧﺪ‬ ‫اﺣﺘﻤﺎ ﻻً ﻣﺰاﯾﺎ و ﺗﺄﺛﯿﺮ ﺟﻤﻊ آوری زﺑﺎﻟﻪ ﯾﻘﯿﻦ ﻧﺪارﻧﺪ ‪ .‬ﺗﺠﺮﺑﻪی ﭘﺮوژه ھﺎی ﺟﺪﯾﺪ ﮐﻪ ﺑﺎ در ﻧﻈﺮ ﮔﺮﻓﺘﻦ ﺟﻤﻊ‬ ‫آوری زﺑﺎﻟﻪ ﻧﻮﺷﺘﻪ ﺷﺪه اﻧﺪ ھﻤﭽﻨﯿﻦ ﭘﺮوژه ھﺎی ﻣﻮﺟﻮد ﮐﻪ ﺑﻪ ﺳﺒﮏ ﺟﻤﻊ آوری زﺑﺎﻟﻪ ﺑﺮﮔﺮداﻧﺪه ﺷﺪه اﻧﺪ‬ ‫ﻧﺸﺎن ﻣﯽ دھﺪ ﮐﻪ ‪:‬‬ ‫• ﺑﺮﻧﺎﻣﻪ ھﺎی دارای ﺟﻤﻊ آور زﺑﺎﻟﻪ ﺳﺮﯾﻌﺘﺮ ھﺴﺘﻨﺪ ‪ .‬اﯾﻦ واﺿﺢ اﺳﺖ اﻣﺎ دﻻﯾﻠﯽ ﻗﺎﺑﻞ ﺑﯿﺎن اﺳﺖ ‪.‬‬ ‫• ﺷﻤﺎرش در ﺟﺎﻋﺎت ﯾﮏ روش ﻣﻌﻤﻮل ﺑﺮای ﺣﻞ ﻣﺴﺎﺋﻞ ﺗﺨﺼﯿﺺ ﺣﺎﻓﻈﻪ آﺷﮑﺎر اﺳﺖ ‪ .‬ﮐﺪ ﭘﯿﺎده ﺳﺎزی‬ ‫اﻋﻤﺎل اﺿﺎﻓﻪ و ﺗﻔﺮﯾﻖ ھﺮ ﺟﺎ ﮐﻪ اﻧﺘﺴﺎب ﺻﻮرت ﻣﯽ ﮔﯿﺮد ﯾﮑﯽ از دﻻﯾﻞ ﮐﻨﺪی اﺳﺖ ‪.‬‬ ‫• ﭘﻨﮫﺎن ﮐﺮدن ﮐﺪ ﻣﺬﮐﻮر در ﭘﺲ ﮐﻼﺳﮫﺎی اﺷﺎره ﮔﺮ ھﻮﺷﻤﻨﺪ ﺑﻪ اﻓﺰاﯾﺶ ﺳﺮﻋﺖ ﮐﻤﮏ ﻧﻤﯽ ﮐﻨﺪ ‪.‬‬ ‫) روش ﺷﻤﺎرش ارﺟﺎﻋﺎت ﺑﻪ ھﯿﭻ وﺟﻪ راه ﺣﻞ ﻋﻤﻮﻣﯽ ﻧﯿﺴﺖ ﺟﺎﯾﯽ ﮐﻪ ارﺟﺎﻋﺎت ﺣﻠﻘﻪ ای ھﺮﮔﺰ ﺣﺬف‬ ‫ﻧﻤﯽ ﺷﻮﻧﺪ ‪( .‬‬ ‫• ﻣﺨﺮب ھﺎی ﮐﻼس ﺑﺮای آزادﺳﺎزی ﻣﻨﺎﺑﻊ ﻣﻮرد ﻧﯿﺎز ﯾﮏ ﺷﯿﺌﯽ ﺑﻪ ﮐﺎر ﻣﯽ رود ‪ .‬ﺑﺮای اﻏﻠﺐ ﮐﻼﺳﮫﺎ اﯾﻦ‬ ‫ﻣﻨﺎﺑﻊ ‪ ،‬ﺣﺎﻓﻈﻪ ﺗﺨﺼﯿﺺ ﯾﺎﻓﺘﻪ اﺳﺖ ‪ .‬ﺑﺎ ﺟﻤﻊ آوری زﺑﺎﻟﻪ اﻏﻠﺐ ﻣﺨﺮب ھﺎ ﺧﺎﻟﯽ ﻣﯽ ﺷﻮﻧﺪ و در ﻧﮫﺎﯾﺖ‬ ‫ﻣﯽ ﺗﻮاﻧﻨﺪ دور اﻧﺪاﺧﺘﻪ ﺷﻮﻧﺪ ‪.‬‬ ‫• ﺗﻤﺎم ﻣﺨﺮب ھﺎﯾﯽ ﮐﻪ ﺣﺎﻓﻈﻪ را آزاد ﻣﯽ ﮐﻨﻨﺪ ﻣﯽ ﺗﻮاﻧﻨﺪ ﻣﻌﻨﯽ دار ﺷﻮﻧﺪ در ﻣﻮاﻗﻌﯽ ﮐﻪ اﺷﯿﺎء ‪ ،‬ﺑﺮ روی‬ ‫ﭘﺸﺘﻪ ﺗﺨﺼﯿﺺ ﺣﺎﻓﻈﻪ ﻣﯽ ﯾﺎﺑﻨﺪ ‪ .‬ﺑﺮای ھﺮ ﮐﺪام ﻣﮑﺎﻧﯿﺰﻣﯽ ﺑﺎﯾﺪ در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﺷﻮد ﻃﻮری ﮐﻪ اﮔﺮ ﯾﮏ‬ ‫اﺳﺘﺜﻨﺎء رخ داد ﺗﻤﺎم ﻣﺨﺮﺑﮫﺎ از ھﺮ ﭼﺎرﭼﻮب ﻓﺮاﺧﻮاﻧﯽ ﺷﻮﻧﺪ ﺗﺎ ھﺮ ﺣﺎﻓﻈﻪ ﺗﺨﺼﯿﺺ ﯾﺎﻓﺘﻪ ﺑﺮای آﻧﮫﺎ را رھﺎ‬ ‫ﮐﻨﻨﺪ ‪ .‬اﮔﺮ ﻣﺨﺮب ھﺎ ﻧﺎﻣﺮﺑﻮط ﺷﻮﻧﺪ ھﯿﭻ ﻧﯿﺎزی ﺑﺮای در ﻧﻈﺮ ﮔﺮﻓﺘﻦ ﭼﺎرﭼﻮب ھﺎی ﺧﺎص ﭘﺸﺘﻪ ﺑﺮای‬ ‫ﭘﺮدازش اﺳﺘﺜﻨﺎھﺎ ﻧﯿﺴﺖ در ﻧﺘﯿﺠﻪ ﮐﺪ ﺳﺮﯾﻌﺘﺮ اﺟﺮا ﻣﯽ ﺷﻮد ‪.‬‬ ‫• ﺗﻤﺎم ﮐﺪھﺎی ﻻزم ﺑﺮای ﻣﺪﯾﺮﯾﺖ ﺣﺎﻓﻈﻪ ﻣﯽ ﺗﻮاﻧﺪ ﺑﺮای ﺗﮑﺎﻣﻞ ﺟﺰﯾﯽ اﺿﺎﻓﻪ ﺷﻮد ‪ .‬ﺑﺮﻧﺎﻣﻪ ﺑﺰرﮔﺘﺮ ﮐﻤﺘﺮ در‬ ‫ﺣﺎﻓﻈﻪ اﺻﻠﯽ و ﺑﯿﺸﺘﺮ آن در ﺣﺎﻓﻈﻪ ﻣﺠﺎزی ﻗﺮار ﻣﯽ ﮔﯿﺮد و آراﻣﺘﺮ و ﮐﻨﺪﺗﺮ اﺟﺮا ﻣﯽ ﺷﻮد ‪.‬‬ ‫• ××××× ﺟﻤﻊ آور ﺣﺎﻓﻈﻪ ھﻨﮕﺎﻣﯽ ﺻﻮرت ﻣﯽ ﮔﯿﺮد ﮐﻪ ﺣﺎﻓﻈﻪ ﺗﻨﮓ و ﮐﻢ ﺷﻮد ‪ .‬ﺗﺎ وﻗﺘﯽ ﺣﺎﻓﻈﻪ ﺟﺎ‬ ‫دارد ﺑﺮﻧﺎﻣﻪ در ﺣﺪاﮐﺜﺮ ﺳﺮﻋﺖ ﻣﻤﮑﻦ اﺟﺮا ﻣﯽ ﺷﻮد و ھﯿﭻ وﻗﺘﯽ ﺑﺮای آزاد ﮐﺮدن ﺣﺎﻓﻈﻪ ‪ ،‬ﺻﺮف ﻧﻤﯽ‬ ‫ﮐﻨﺪ ‪.‬‬ ‫• ﺟﻤﻊ آورﻧﺪه ھﺎی زﺑﺎﻟﻪ ﻣﺪرن ‪ ،‬اﮐﻨﻮن ﺑﻪ ﻣﺮاﺗﺐ ﭘﯿﺸﺮﻓﺘﻪ ﺗﺮ از ﻗﺒﻠﯽ ھﺎ و ﮐﻨﺪﺗﺮھﺎ ھﺴﺘﻨﺪ ‪ .‬ﺟﻤﻊ آورﻧﺪه‬ ‫ھﺎی ﺗﻮﻟﯿﺪ ﮐﻨﻨﺪه و ﮐﭙﯽ ﮐﻨﻨﺪه ﻗﺴﻤﺖ ﻋﻤﺪه ﻧﺎﮐﺎراﯾﯽ اﻟﮕﻮرﯾﺘﻢ ھﺎی ﺟﺎرو ﮐﺮدن و اﺧﺘﺼﺎص دادن را ﺣﺬف‬ ‫ﻣﯽ ﮐﻨﻨﺪ ‪.‬‬ ‫• ﺟﻤﻊ آورﻧﺪه ھﺎی زﺑﺎﻟﻪ ﻣﺪرن ﻓﺸﺮده ﺳﺎزی ﺗﻮده ﺣﺎﻓﻈﻪ را اﻧﺠﺎم ﻣﯽ دھﻨﺪ ‪ .‬ﻓﺸﺮده ﺳﺎزی ﺗﻮده‬ ‫ﻣﺮاﻗﺐ اﺳﺖ ﮐﻪ ﺗﻌﺪاد ﺻﻔﺤﺎﺗﯽ ﮐﻪ ﺑﻪ ﻃﻮر ﻓﻌﺎل ﺑﻪ وﺳﯿﻠﻪ ﯾﮏ ﺑﺮﻧﺎﻣﻪ ارﺟﺎع ﺷﺪه اﻧﺪ را ﮐﺎھﺶ دھﺪ‬ ‫ﺑﺪﯾﻦ ﻣﻌﻨﯽ ﮐﻪ دﺳﺘﺮﺳﯽ ھﺎی ﺣﺎﻓﻈﻪ اﺣﺘﻤﺎﻻً ﺑﯿﺸﺘﺮ ﺑﻪ ﺣﺎﻓﻈﻪ ﻣﯽ رﺳﻨﺪ ﺗﺎ ﺑﻪ ﻣﺒﺎدﻟﻪ ﺣﺎﻓﻈﻪ ‪.‬‬ ‫• ﺟﻤﻊ آورﻧﺪه ھﺎی زﺑﺎﻟﻪ ﺣﺎﻓﻈﻪ اﺳﺘﻔﺎده ﺷﺪه را اﺻﻼح ﻣﯽ ﮐﻨﻨﺪ ‪ .‬ﺑﻨﺎﺑﺮاﯾﻦ ﺑﻪ رﺧﻨﻪ ھﺎی ﺣﺎﻓﻈﻪ ‪ -‬ﮐﻪ‬ ‫ﺑﺎﻋﺚ ﻣﯽ ﺷﻮﻧﺪ ﺑﺮﻧﺎﻣﻪ ھﺎی ﺑﺎ اﺟﺮای ﻃﻮﻻﻧﯽ ﻣﺪت آن ﻗﺪر ﺣﺎﻓﻈﻪ ﻣﺼﺮف ﮐﻨﻨﺪه ﺗﺎ ﺳﯿﺴﺘﻢ ھﻨﮓ ﮐﻨﺪ ‪-‬‬ ‫ﺗﻦ در ﻧﻤﯽ دھﺪ ‪.‬‬ ‫• ﺑﺮﻧﺎﻣﻪ ھﺎی دارای ﺟﻤﻊ آور زﺑﺎﻟﻪ دارای اﺷﮑﺎﻻت ﮐﻤﺘﺮ ﯾﺎﻓﺘﻦ اﺷﺎره ﮔﺮھﺎ ﻣﯽ ﺑﺎﺷﻨﺪ ﺑﻪ اﯾﻦ ﺧﺎﻃﺮ ﮐﻪ‬ ‫ھﯿﭻ ارﺟﺎع ﺳﺮﮔﺮدان ﺑﻪ ﺣﺎﻓﻈﻪ آزاد ﺷﺪه ﻧﻤﯽ ﻣﺎﻧﺪ ‪.‬‬ ‫• ﺑﺮﻧﺎﻣﻪ ھﺎی دارای ﺟﻤﻊ آور زﺑﺎﻟﻪ ﺑﺮای ﮔﺴﺘﺮش و اﺷﮑﺎل زداﯾﯽ ﺳﺮﯾﻌﺘﺮﻧﺪ ‪ .‬ﭼﻮن ھﯿﭻ ﻧﯿﺎزی ﺑﺮای‬ ‫ﮔﺴﺘﺮش ‪ ،‬اﺷﮑﺎل زداﯾﯽ ‪ ،‬اﻣﺘﺤﺎن ‪ ،‬ﯾﺎ اﺑﻘﺎء ﮐﻪ آزاد ﺳﺎزی آﺷﮑﺎر وﺟﻮد ﻧﺪارد ‪.‬‬ ‫• ﺑﺮﻧﺎﻣﻪ ھﺎی دارای ﺟﻤﻊ زﺑﺎﻟﻪ ﺑﻪ ﻃﻮر ﻣﻌﻨﯽ داری ﮐﻮﭼﮑﺘﺮﻧﺪ ﭼﻮن ھﯿﭻ ﮐﻪ آزادﺳﺎزی ﺣﺎﻓﻈﻪ وﺟﻮد ﻧﺪارد‬ ‫و از اﯾﻦ رو ﻧﯿﺎزی ﺑﻪ ﭘﺮدازﺷﮕﺮھﺎی اﺳﺘﺜﻨﺎھﺎ ﺑﺮای آزاد ﺳﺎزی ﺣﺎﻓﻈﻪ وﺟﻮد ﻧﺪارد ‪.‬‬ ‫• ﺟﻤﻊ آوی زﺑﺎﻟﻪ ﯾﮏ ﻧﻮﺷﺪاروی ھﻢ ﮐﺎره ﻧﯿﺴﺖ ﺑﻌﻀﯽ اﺷﮑﺎﻻت ھﻢ دارد ‪:‬‬ ‫• وﻗﺘﯽ ﯾﮏ ﻣﺠﻤﻮﻋﻪ ﺑﺮﻧﺎﻣﻪ ھﻤﺰﻣﺎن اﺟﺮا ﻣﯽ ﺷﻮد ﻗﺎﺑﻞ ﭘﯿﺸﮕﻮﯾﯽ ﻧﯿﺴﺖ ﺑﻨﺎﺑﺮاﯾﻦ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﻃﻮر دﻟ ﺨﻮاه‬ ‫ﻣﯽ ﺗﻮاﻧﺪ ﻣﮑﺚ ﮐﻨﺪ‪.‬‬ ‫• زﻣﺎﻧﯽ ﮐﻪ ﺑﺮای اﺟﺮای ﯾﮏ ﻣﺠﻤﻮﻋﻪ ﻣﻨﺼﺮف ﻣﯽ ﺷﻮد ﻧﺎﻣﺤﺪود اﺳﺖ ﺑﺎ اﯾﻨﮑﻪ در ﻋﻤﻞ ﺑﺴﯿﺎر ﮐﻮﺗﺎه‬ ‫اﺳﺖ اﻣﺎ ﺿﻤﺎﻧﺘﯽ وﺟﻮد ﻧﺪارد ‪.‬‬ ‫• ﺗﻤﺎم رﺷﺘﻪ ھﺎی اﺟﺮا ﺑﻪ ﻏﯿﺮ از رﺷﺘﻪ ﺟﻤـــﻊ آوری زﺑﺎﻟﻪ در ﺣﺎﻟﯽ ﮐﻪ ﺟﻤﻊ آوری در ﺟﺮﯾﺎن اﺳﺖ ﺑﺎﯾﺪ‬ ‫ﻣﮑﺚ ﮐﻨﺪ ‪.‬‬ ‫ﻧﺤﻮه ﺑﺮﻗﺮاری ارﺗﺒﺎط اﺷﯿﺎی دارای ﺟﻤﻊ آوری زﺑﺎﻟﻪ ﺑﺎ ﮐﺪ ﺑﯿﺮوﻧﯽ‪:‬‬

‫ﺟﻤﻊ آور زﺑﺎﻟﻪ ﺑﻪ دﻧﺒﺎل رﯾﺸﻪ ھﺎ د ﺳﮕﻤﻨﺖ داده اﯾﺴﺘﺎ و ﭘﺸﺘﻪ ھﺎ و ﻣﺤﺘﻮﯾﺎت رﺟﯿﺴﺘﺮ ھﺮ رﺷﺘﻪی اﺟﺮا‬ ‫ﻣﯽ ﮔﺮدد‪ .‬اﮔﺮ ﺗﻨﮫﺎ رﯾﺸﻪ ﯾﮏ ﺷﯿﺌﯽ ﺑﯿﺮون از آﻧﮫﺎ ﺑﺎﺷﺪ ‪ ،‬ﺟﻤــــﻊ آور زﺑﺎﻟﻪ آن را از ﺑﯿﻦ ﻣﯽ ﺑﺮد و ﺣﺎﻓﻈﻪ‬ ‫را آزاد ﻣﯽﺳﺎزد ‪.‬‬ ‫ﺑﺮای اﺟﺘﻨﺎب از اﯾﻦ واﻗﻌﻪ ﺑﺎﯾﺪ‪:‬‬ ‫رﯾﺸﻪ دﺳﺘﺮﺳﯽ ﺑﻪ ﯾﮏ ﺷﯿﺌﯽ را در ﺟﺎﯾﯽ اﺑﻘﺎ ﮐﻨﯿﻢ ﮐﻪ ﺟﻤﻊ آور زﺑﺎﻟﻪ در آن ﺟﺎ ﺑﻪ دﻧﺒﺎل رﯾﺸﻪ ﻣﯽ‬ ‫ﮔﺮدد ‪.‬‬ ‫ﺑﻪ ﺷﯿـــﺌﯽ ﻣﺠــــــﺪداً ﺗﻮﺳﻂ ﺗﺨﺼﯿﺺ دھﻨﺪه ﮐﻪ ﺧﺎرﺟﯽ ﯾﺎ ﮐﺘــــﺎﺑﺨﺎﻧﻪ ھﺎی زﻣﺎن اﺟﺮای ‪C‬‬ ‫‪ ، ( ( malloc/free‬ﺣﺎﻓﻈﻪ ﺗﺨﺼﯿﺺ دھﯿﻢ ‪.‬‬ ‫اﺷﺎره ﮔﺮھﺎ و ﺟﻤﻊ آور زﺑﺎﻟﻪ‬ ‫اﻟﮕﻮرﯾﺘﻢ ھﺎی ﺟﻤﻊ آوری زﺑﺎﻟﻪ ﺑﺴﺘﮕﯽ دارد ﺑﻪ اﺷﺎره ﮔﺮھﺎﯾﯽ ﮐﻪ ﺑﻪ ﭼﯿﺰی در ﺣﺎل اﺷﺎره اﻧﺪ و ﻏﯿﺮ‬ ‫اﺷﺎرهﮔﺮھﺎ ﮐﻪ ﺑﻪ ﭼﯿﺰی اﺷﺎره ﻧﻤﯽ ﮐﺮده اﻧﺪ ‪ .‬ﺑﺪﯾﻦ ﻣﻨﻈﻮر دﺳﺘﻮرات زﯾﺮ ﮐﻪ در ‪ C‬ﻏﯿﺮ ﻣﻌﻤﻮل ﻧﯿﺴﺘﻨﺪ‬ ‫ﺑﺎﯾﺪ ﺑﻪ دﻗﺖ در ‪ D‬از آﻧﮫﺎ ﺧﻮدداری ﺷﻮد ‪:‬‬ ‫‪ (١‬اﺷﺎره ﮔﺮھﺎ را ﺑﺎ ‪ xor‬ﮐﺮدن آﻧﮫﺎ ﺑﺎ ﻣﻘﺎدﯾﺮ دﯾﮕﺮ ﻣﺨﻔﯽ ﻧﮑﻨﯿﺪ ﻣﺎﻧﻨﺪ اﺷﺎره ﮔﺮ ‪ xor‬ﺷﺪه ﺣﻘﻪی ﻟﯿﺴﺖ‬ ‫ﭘﯿﻮﻧﺪی در ‪ . C‬از ﺣﻘﻪی ‪ xor‬ﺑﺮای ﺟﺎ ﺑﻪ ﺟﺎ ﮐﺮدن ﻣﻘﺎدﯾﺮ دو اﺷﺎره ﮔﺮ اﺳﺘﻔﺎده ﻧﮑﻨﯿﺪ ‪.‬‬ ‫‪ (٢‬اﺷﺎره ﮔﺮھﺎی ﺑﻪ ﻣﻘﺎدﯾﺮ ﺻﺤﯿﺢ را ﺗﻮﺳﻂ ‪ cast‬ﯾﺎ دﯾﮕﺮ ﺣﻘﻪ ھﺎ ذﺧﯿﺮه ﻧﮑﻨﯿﺪ ﭼﻮن ﺟﻤﻊ آوری زﺑﺎﻟﻪ اﻧﻮاع‬ ‫ﻏﯿﺮ اﺷﺎرهﮔﺮ را ﺑﺮای ﯾﺎﻓﺘﻦ رﯾﺸﻪ ھﺎی دﺳﺘﺮﺳﯽ ﺑﺮرﺳﯽ ﻧﻤﯽ ﮐﻨﺪ ‪.‬‬ ‫‪ (٣‬از ﻣﺰﯾﺖ ھﻢ ﺗﺮازی اﺷﺎره ﮔﺮھﺎ ﺑﺮای ذﺧﯿﺮه ﻓﻠﮕﮫﺎی ﺑﯿﺘﯽ در ﺑﯿﺘﮫﺎی ﺳﻄﺢ ﭘﺎﺋﯿﻦ ﯾﺎ ﺑﯿﺘﮫﺎی ﺳﻄﺢ ﺑﺎﻻ‬ ‫اﺳﺘﻔﺎده ﻧﮑﻨﯿﺪ ‪.‬‬ ‫‪ (۴‬ﻣﻘﺎدﯾﺮ ﺻﺤﯿﺢ را در اﺷﺎره ﮔﺮھﺎ ﻧﮕﮫﺪاری ﻧﮑﻨﯿﺪ و‬ ‫‪ (۵‬ﻣﻘﺎدﯾﺮ ﺳﺤﺮ آﻣﯿﺰ را در اﺷﺎره ﮔﺮھﺎ ذﺧﯿﺮه ﻧﮑﻨﯿﺪ ﺑﻪ ﻏﯿﺮ از ‪. null‬‬ ‫‪ (۶‬اﮔﺮ ﺷﻤﺎ ﺑﺎﯾﺪ ﯾﮏ ﻣﮑﺎن ﻧﮕﮫﺪاری ﺧﺎص را ﺑﯿﻦ اﻧﻮاع اﺷﺎره ﮔﺮ و ﻏﯿﺮ اﺷﺎره ﮔﺮ ﺑﻪ اﺷﺘﺮاک ﺑﮕﺬارﯾﺪ از‬ ‫‪ union‬اﺳﺘﻔﺎده ﮐﻨﯿﺪ ﺗﺎ ﺟﻤﻊ آور زﺑﺎﻟﻪ ﺗﮑﻠﯿﻒ ﺧﻮدش را در آن ﻣﻮرد ﺑﺪاﻧﺪ ‪.‬‬ ‫در ﺣﻘﯿﻘﺖ ﺗﺎ ﺟﺎﯾﯽ ﮐﻪ ﻣﯽ ﺷﻮد از اﺷﺎره ﮔﺮھﺎ اﺳﺘﻔﺎده ﻧﮑﻨﯿﺪ ‪ D .‬دارای ﺧﺼﻮﺻﯿﺎت اﺳﺖ ﮐﻪ ﻧﺸﺎن ﻣﯽ‬ ‫دھﺪ ﮐﻪ اﻏﻠﺐ اﺷﺎره ﮔﺮھﺎی آﺷﮑﺎرا ‪ ،‬ﻣﺘﺮوک و ﺑﻼاﺳﺘﻔﺎده ﺧﻮاھﻨﺪ ﺑﻮد ‪ .‬ﻣﺎﻧﻨﺪ اﺷﯿﺎء ﻣﺮﺟﻊ ‪ ،‬آراﯾﻪ ھﺎی‬ ‫ﭘﻮﯾﺎ و ﺟﻤﻊ آوری زﺑﺎﻟﻪ ‪ .‬اﺷﺎره ﮔﺮھﺎ ﺑﺮای ارﺗﺒﺎط ﻣﻮﻓﻖ ﺑﺎ ‪ API‬ھﺎی ‪ C‬و ﺑﻌﻀﯽ ﮐﺎرھﺎی ﮐﯿﻤﯿﺎﮔﺮاﻧﻪ ﭘﺪﯾﺪ‬ ‫آﻣﺪه ﺑﻮدﻧﺪ ‪.‬‬

‫ﺳﺎﺧﺘﻤﺎﻧﮫﺎ و ﯾﻮﻧﯿﻮن ھﺎ‬ ‫‪Aggregate Declaration‬‬ ‫ﺷﺒﯿﻪ ‪ C‬ﮐﺎر ﻣﯽ ﮐﻨﻨﺪ ﺑﺎ ﺗﻔﺎوﺗﮫﺎی زﯾﺮ ‪:‬‬ ‫‪ (١‬ﺑﺪون ﻓﯿﻠﺪ ھﺎی ﺑﯿﺖ‬ ‫‪ (٢‬ھﻢ ﺗﺮازی ﺑﻪ ﻃﻮر آﺷﮑﺎر ﻗﺎﺑﻞ ﻣﺸﺨﺺ ﮐﺮدن اﺳﺖ ‪.‬‬ ‫‪ (٣‬ﺑﺪون ﻓﻀﺎی ﻧﺎم ﺑﺮﭼﺴﺐ ﺟﺪاﮔﺎﻧﻪ – ﻧﺎم ﺑﺮﭼﺴﺐ ھﺎ در ﺣﻮزه ﮐﻨﻮﻧﯽ ﻣﯽ ﺑﺎﺷﻨﺪ ‪.‬‬ ‫‪ (۴‬اﻋﻼن ھﺎﯾﯽ ﻣﺎﻧﻨﺪ ‪ ; struct ABC x‬ﻣﺠﺎز ﻧﯿﺴﺘﻨﺪ ﺑﻨﻮﯾﺴﯿﺪ ‪; ABC x :‬‬

‫‪ (۵‬ﺳﺎﺧﺘﻤﺎﻧﮫﺎ ﯾﺎ ﯾﻮﻧﯿﻮن ھﺎی ﺑﯽ ﻧﺎم ﻣﯽ ﺗﻮاﻧﻨﺪ ﻋﻀﻮی از ﺳﺎﺧﺘﻤﺎﻧﮫﺎ ﯾﺎ ﯾﻮﻧﯿﻮن ھﺎی دﯾﮕﺮ ﺑﺎﺷﻨﺪ ‪.‬‬ ‫‪ (۶‬اﻧﺘﺴﺎب دھﻨﺪه ھﺎی ﭘﯿﺶ ﻓﺮض اوﻟﯿﻪ ﺑﺮای اﻋﻀﺎ ﭘﺸﺘﯿﺒﺎﻧﯽ ﻣﯽ ﺷﻮد ‪.‬‬ ‫‪ (٧‬ﺗﻮاﺑﻊ ﻋﻀﻮ و اﻋﻀﺎی اﺳﺘﺎﺗﯿﮏ ﻣﺠﺎز اﺳﺖ ‪.‬‬ ‫ﺳﺎﺧﺘﻤﺎﻧﮫﺎ و ﯾﻮﻧﯿﻮن ھﺎ ﺑﻪ ﻣﻌﻨﯽ اﺟﺘﻤﺎع ﺳﺎده داده ھﺎ ﯾﺎ راھﯽ ﺑﺮای رﻧﮓ و آب دادن ﺑﻪ ﯾﮏ ﺳﺎﺧﺘﻤﺎن‬ ‫داده ﻣﯽ ﺑﺎﺷﺪ ‪ ،‬ﻋﻼوه ﺑﺮ ﺳﺨﺖ اﻓﺰار ﯾﺎ ﯾﮏ ﻧﻮع ﺧﺎرﺟﯽ ‪ ،‬اﻧﻮاع ﺧﺎرﺟﯽ ﻣﯽ ﺗﻮاﻧﻨﺪ ﺗﻮﺳﻂ ‪ API‬ﺳﯿﺴﺘﻢ‬ ‫ﻋﺎﻣﻞ ﯾﺎ ﯾﮏ ﻓﺮﻣﺖ ﻓﺎﯾﻞ ﺗﻌﺮﯾﻒ ﺷﻮﻧﺪ ‪ .‬ﺧﺼﻮﺻﯿﺎت ﺷﯿﺌﯽ ﮔﺮا ﻧﯿﺰ ﺑﺎ ﻧﻮع داده ﮐﻼس ﻓﺮاھﻢ ﺷﺪه اﻧﺪ ‪.‬‬

‫اﻧﺘﺴﺎب اوﻟﯿﻪ اﺳﺘﺎﺗﯿﮏ ﺳﺎﺧﺘﻤﺎن ھﺎ‬ ‫ﺑﻪ اﻋﻀﺎی ﺳﺎﺧﺘﻤﺎن اﺳﺘﺎﺗﯿﮏ ﺑﻪ ﻃﻮر ﭘﯿﺶ ﻓﺮض ﻣﻘﺪار ﺻﻔﺮ اﻧﺘﺴﺎب داده ﻣﯽ ﺷﻮد و ﺑﻪ ﻣﻘﺎدﯾﺮ ﻣﻤﯿﺰ‬ ‫ﺷﻨﺎور ﻣﻘﺪار ‪ . NAN‬اﮔﺮ ﯾﮏ اﻧﺘﺴﺎب دھﻨﺪه اوﻟﯿﻪی اﺳﺘﺎﺗﯿﮏ ﻓﺮاھﻢ ﺷﻮد ‪ ،‬اﻋﻀﺎ ﺑﻪ وﺳﯿﻠﻪ ﻧﺎم ﻋﻀﻮ ‪،‬‬ ‫ﮐﻮﻟﻮم و اﻣﻼی ﻋﺒﺎرت اﻧﺘﺴﺎب اوﻟﯿﻪ ﻣﯽ ﺷﻮﻧﺪ ‪ .‬در ﺿﻤﻦ ﻣﻤﮑﻦ اﺳﺖ اﻋﻀﺎ ﺑﻪ ھﺮ ﻧﺤﻮ اﻧﺘﺴﺎب اوﻟﯿﻪ‬ ‫ﺷﻮﻧﺪ ‪.‬‬ ‫};‪struct X { int a; int b; int c; int d = 7‬‬ ‫‪static X x = { a:1, b:2}; // c is set to 0, d to 7‬‬ ‫‪static X z = { c:4, b:5, a:2 , d:5}; // z.a = 2, z.b = 5, z.c = 4, d = 5‬‬ ‫اﻧﺘﺴﺎب اوﻟﯿﻪی اﺳﺘﺎﺗﯿﮏ ﯾﻮﻧﯿﻮن ھﺎ‬ ‫ﯾﻮﻧﯿﻮن ھﺎ ﺑﻪ ﻃﻮر آﺷﮑﺎر ﻣﻘﺪار دھﯽ اوﻟﯿﻪ ﻣﯽ ﺷﻮﻧﺪ ‪:‬‬ ‫} ; ‪union U { int a ; double b‬‬ ‫‪static U u = { b : 5.0 } ; // u.b = 5.0‬‬ ‫دﯾﮕﺮ اﻋﻀﺎی ﯾﻮﻧﯿﻮن ﮐﻪ اﻧﺘﺴﺎب دھﻨﺪه را ﺟﺎی ﻣﯽ ﮔﺬارﻧﺪ وﻟﯽ ﻓﻀﺎی ﺑﯿﺸﺘﺮی اﺷﻐﺎل ﻣﯽ ﮐﻨﻨﺪ ﻣﻘﺪار‬ ‫ﺻﻔﺮ ﻣﯽ ﮔﯿﺮﻧﺪ ‪.‬‬ ‫‪Enums‬‬ ‫اﻋﻼن‪Enum‬‬ ‫{ ‪enum identifier‬اﻋﻀﺎ }‬ ‫{ ‪enum‬اﻋﻀﺎ }‬ ‫; ‪enum identifier‬‬ ‫‪ Enum‬ھﺎ ﮐﺎرﺑﺮد ﻣﻌﻤﻮﻟﯽ ﻣﺎﮐﺮوھﺎی ‪ define #‬را ﺑﺎ ﺛﺒﺎت ھﺎی ﺗﻌﺮﯾﻒ ﺟﺎﯾﮕﺰﯾﻦ ﻣﯽ ﮐﻨﻨﺪ ‪.‬‬ ‫‪ Enum‬ھﺎ ھﻤﭽﻨﯿﻦ ﻣﯽ ﺗﻮاﻧﻨﺪ ﺑﯽ ﻧﺎم ﺑﺎﺷﻨﺪ ﮐﻪ در آن ﻣﻮرد ﺑﻪ ﺳﺎدﮔﯽ ﺛﺎﺑﺖ ھﺎی ﻣﺠﺘﻤﻊ را ﺗﻌﯿﻒ ﻣﯽ‬ ‫ﮐﻨﻨﺪ و ﯾﺎ دارای ﻧﺎم ﺑﺎﺷﻨﺪ ﮐﻪ ﻣﻘﺪﻣﻪ ﯾﮏ ﻧﻮع ﺟﺪﯾﺪ ﺧﻮاھﻨﺪ ﺑﻮد ‪.‬‬ ‫= ‪ ٠, A= ١, b= ٢C‬ﺛﺎﺑﺘﮫﺎی ‪ {A,B,C } enum‬ﺑﺪون ﻧﺎم ‪enum‬‬

‫را ﺗﻌﺮﯾﻒ ﻣﯽ ﮐﻨﺪ ‪ .‬در ﺣﺎﻟﯽ ﮐﻪ ‪ Enum‬دارای ﻧﺎم ‪ {enum X { A,B,C‬ﻧﻮع ﺟﺪﯾﺪ ‪ x‬ﺑﺎ ﻣﻘﺎدﯾﺮ = ‪ ٠X.A‬و‬ ‫‪ ١ = X.B‬و = ‪ ٢X.C‬ﺗﻌﺮﯾﻒ ﻣﯽ ﮐﻨﺪ ‪.‬‬ ‫‪ Enum‬ھﺎ ﺑﺎﯾﺪ ﺣﺪاﻗﻞ دارای ﯾﮏ ﻋﻀﻮ ﺑﺎﺷﻨﺪ ‪ .‬اﮔﺮ ﺑﺮای ﯾﮏ ﻋﻀﻮ ‪ Enum‬ﯾﮏ ﻋﺒﺎرت رﯾﺎﺿﯽ ﻓﺮاھﻢ ﺷﺪه‬ ‫ﺑﺎﺷﺪ ارزش ﻋﻀﻮ ﻣﺬﮐﻮر ﺑﺮاﺑﺮ ﺣﺎﺻﻞ ﻋﺒﺎرت اﺳﺖ و ﻋﻀﻮ ﺑﻌﺪی ‪ Enum‬دارای ارزش ﻋﻀﻮ ﻗﺒﻠﯽ ﺑﻪ ﻋﻼوه‬ ‫ﯾﮏ اﺳﺖ ‪.‬‬ ‫} ‪Enum { A , B = 5 + 7 , C, D = 8 , E‬‬

‫دارﯾﻢ ‪٩, E = ٨, D = ١٣, C = ١٢B = , ٠ = A‬‬ ‫ﺻﻔﺎت ‪Enum‬‬ ‫ﮐﻮﭼﮑﺘﺮﯾﻦ ﻋﻀﻮ ‪min‬‬ ‫ﺑﺰرﮔﺘﺮﯾﻦ ﻋﻀﻮ ‪max‬‬ ‫ﺳﺎﯾﺰ ﻧﮕﮫﺪاری ارزش ﻋﻀﻮ ‪size‬‬ ‫ﻣﻘﺪار دھﯽ ‪Enum‬‬ ‫در ﻏﯿﺎب ﯾﮏ ﻣﻘﺪار دھﻨﺪه ﺑﻪ ﺻﻮرت آﺷﮑﺎر ‪ ،‬ﯾﮏ ﻣﺘﻐﯿﺮ ‪ Enum‬دارای ﻣﻘﺪار اوﻟﯿﻦ ﻋﻀﻮ اﺳﺖ ‪.‬‬ ‫} ‪Enum X { A = 3 , B,C‬‬ ‫ﻣﻘﺪار ‪ X‬ﺑﺮاﺑﺮ ‪ ٣‬ﻣﯽ ﺷﻮد ‪; X x .‬‬