Search for notes by fellow students, in your own course and all over the country.
Browse our notes for titles which look like what you need, you can preview any of the notes via a sample of the contents. After you're happy these are the notes you're after simply pop them into your shopping cart.
Title: Book Programming
Description: Book will help you to learn the programming language
Description: Book will help you to learn the programming language
Document Preview
Extracts from the notes are below, to see the PDF you'll receive please use the links above
ﳏﺘﻮﻳﺎﺕ ﺍﻟﻜﺘﺎﺏ ﺑﻨﻈﺮﺓ ﺳﺮﻳﻌﺔ
ﺣﻮﻝ ﺍﻟﻜﺘﺎﺏ
...
٩١
ﺍﻟﻔﺼﻞ ﺍﻷﻭﻝ – ﺃﺳﺎﺳﻴﺎﺕ ﰲ ﻟﻐﺔ
...
٢٢
٢,١ ﺍﻟﺒﺪﺀ ﻣﻊ ﻟﻐﺔ ٢٥
...
Variables and Constants
٤,١ ﺍﻟﺘﻌﻠﻴﻘﺎﺕ ٤٥
...
input
٦,١ ﺍﳌﺆﺛﺮﺍﺕ ٥١
...
if, else, else…if
٨,١ﻋﻨﺎﺻﺮ ﻟﻐﺔ ٦٤
...
٩٦
ﺍﻟﻔﺼﻞ ﺍﻟﺜﺎﱐ – ﺃﺳﺎﺳﻴﺎﺕ ﰲ ﻟﻐﺔ
...
Switch
٢,٢ ﺣﻠﻘﺎﺕ ﺍﻟﺘﻜﺮﺍﺭ ٨٦
...
Arrays
٤,٢ ﺍﳌﺆﺷﺮﺍﺕ ١١٤
...
Functions
٦,٢ ﺍﳌﻠﻔﺎﺕ ﺍﻟﺮﺃﺳﻴﺔ ١٣٥
...
Files I/O
٨,٢ ﺍﻟﺘﺮﺍﻛﻴﺐ ١٤٧
...
٧٥١
ﺍﻟﻔﺼﻞ ﺍﻟﺜﺎﻟﺚ – ﺍﻟﺘﻘﺪﻡ ﰲ ﻟﻐﺔ
...
Enumeration
٢,٣ ﻭﺳﺎﺋﻂ ﺍﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ١٨٢
...
Directives(Preprocessor
٤,٣ ﺩﻭﺍﻝ ﺫﺍﺕ ﻭﺳﺎﺋﻂ ﻏﲑ ﳏﺪﺩﺓ
...
Standard Library
ﺍﳋﺎﲤﺔ
...
ﺟﺪﻭﻝ ﺍﳉﺪﺍﻭﻝ
...
ﺃﻫﻢ ﺍﳌﺮﺍﺟﻊ
...
٨١
ﺍﳌﻘﺪﻣﺔ
...
C
١,١ ﺍﻷﺩﻭﺍﺕ ﺍﻟﻼﺯﻣﺔ
...
texts editor
٢,١,١ ﻣﺘﺮﺟﻢ ٢٢
...
linker
٢,١ ﺍﻟﺒﺪﺀ ﻣﻊ ﻟﻐﺔ ٢٥
...
٩٢
٢,٢,١ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ
...
٣٣
٣,١ ﺍﳌﺘﻐﲑﺍﺕ ﻭ ﺍﻟﺜﻮﺍﺑﺖ ٣٤
...
Variable Type
١,١,٣,١ ﻣﺘﻐﲑ ﺍﻷﻋﺪﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ ٣٥
...
float
٣,١,٣,١ ﻣﺘﻐﲑ ﺍﻷﻋﺪﺍﺩ ﺍﳊﻘﻴﻘﻴﺔ ٣٦
...
short
٥,١,٣,١ ﻣﺘﻐﲑ ﺍﻷﻋﺪﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ ٣٦
...
char
٢,٣,١ ﺍﺳﻢ ﺍﳌﺘﻐﲑ ٣٧
...
Variable Value
٤,٣,١ ﺃﻣﺜﻠﺔ ﺣﻮﻝ ﺍﳌﺘﻐﲑﺍﺕ
...
٠٤
٦,٣,١ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ
...
٤٤
٤,١ ﺍﻟﺘﻌﻠﻴﻘﺎﺕ ٤٥
...
٥٤
٢,٤,١ ﺃﻧﻮﺍﻉ ﺍﻟﺘﻌﻠﻴﻘﺎﺕ
...
٥٤
٢,٢,٤,١ ﺍﻟﺘﻌﻠﻴﻘﺎﺕ ﺑﺎﻷﺳﻄﺮ
...
٦٤
٤,٤,١ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ
...
٧٤
٥,١ ﺍﻹﺩﺧﺎﻝ ٤٨
...
٠٥
٢,٥,١ ﲤﺎﺭﻳﻦ
...
Operators
١,٦,١ ﺍﳌﺆﺛﺮﺍﺕ ﺍﳊﺴﺎﺑﻴﺔ ٥١
...
(++) increment
٢,١,٦,١ ﻣﺆﺛﺮ ﺍﻟﻨﻘﺼﺎﻥ ٥٢
...
٣٥
٢,٦,١ ﺍﳌﺆﺛﺮﺍﺕ ﺍﻟﻌﻼﻗﻴﺔ ٥٣
...
logical operators
٤,٦,١ ﻣﺆﺛﺮﺍﺕ ﺃﺧﺮﻯ
...
(bitwize
٦,٦,١ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ
...
٩٥
٧,١ ﺍﻟﻘﺮﺍﺭﺍﺕ ٦٠
...
if
٢,٧,١ ﺍﺳﺘﻌﻤﺎﻝ ٦١
...
else…if
٤,٧,١ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ
...
٣٦
٨,١ ﻋﻨﺎﺻﺮ ﻟﻐﺔ ٦٤
...
Comments
٢,٨,١ ﺍﻟﻜﻠﻤﺎﺕ ﺍﶈﺠﻮﺯﺓ ٦٤
...
Identifiers
١,٣,٨,١ ٦٥
...
Constants
١,٤,٨,١ ﺍﻟﺜﻮﺍﺑﺖ ﺍﻟﻨﺼﻴﺔ
...
٧٦
٥,٨,١ ﺍﻟﺮﻣﻮﺯ ٦٨
...
String literals
٧,٨,١ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ
...
٨٦
٩,١ ﻣﻠﺨﺺ ﻟﻠﻔﺼﻞ ﺍﻷﻭﻝ، ﻣﻊ ﺇﺿﺎﻓﺎﺕ
...
٩٦
١,١,٩,١ ﺍﻟﱪﻧﺎﻣﺞ ﺍﻷﻭﻝ، ﻋﻤﺮ ﺍﳌﺴﺘﺨﺪﻡ
...
٠٧
٣,١,٩,١ ﺍﻟﱪﻧﺎﻣﺞ ﺍﻟﺜﺎﻟﺚ، ﺍﺳﺘﺨﺮﺍﺝ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻄﻠﻘﺔ
...
٢٧
٢,٩,١ ﺍﻟﺪﺍﻟﺘﲔ putcharﻭ ٧٢
...
gets
٤,٩,١ ﺍﻟﺪﺍﻟﺘﲔ wprintfﻭ ٧٤
...
getche
٦,٩,١ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ ٧٦
...
wmain
٨,٩,١ ﺭﻣﻮﺯ ﺍﻹﺧﺮﺍﺝ ﻭ ﺍﻹﺩﺧﺎﻝ
...
٩٧
٠١,٩,١ ﲤﺎﺭﻳﻦ
...
(٢) C
١,٢ ﺍﻟﻘﺮﺍﺭ ٨١
...
case
٢,١,٢ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ ٨٤
...
default
٧,٨,٢ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ
...
٥٨
٢,٢ ﺣﻠﻘﺎﺕ ﺍﻟﺘﻜﺮﺍﺭ ٨٦
...
while
٢,٢,٢ ﺍﻟﺘﻜﺮﺍﺭ ﺑﻮﺍﺳﻄﺔ ٨٨
...
for
٤,٢,٢ ﺍﻟﺘﻜﺮﺍﺭ ﺑﻮﺍﺳﻄﺔ ٩٢
...
٣٩
٧,٢,٢ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ ٩٧
...
ASCII
٩,٢,٢ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ
...
٨٩
٣,٢ ﺍﳌﺼﻔﻮﻓﺎﺕ ١٠٠
...
١٠١
٢,٣,٢ ﺍﳌﺼﻔﻮﻓﺎﺕ ﺍﻟﺜﻨﺎﺋﻴﺔ ﺍﻷﺑﻌﺎﺩ
...
٤٠١
٣,٣,٢ ﻣﺼﻔﻮﻓﺔ ﺫﺍﺕ ﺣﺠﻢ ﻏﲑ ﻣﻌﺮﻭﻑ
...
٦٠١
١,٤,٣,٢ ﺍﻟﺪﺍﻟﺔ ١٠٩
...
strncpy
٣,٤,٣,٢ ﺍﻟﺪﺍﻟﺔ strcatﻭ ﺍﻟﺪﺍﻟﺔ ١١٠
...
١١١
٦,٣,٢ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ
...
٣١١
٤,٢ ﺍﳌﺆﺷﺮﺍﺕ ١١٤
...
Pointer Type
٢,٤,٢ ﺍﺳﻢ ﺍﳌﺆﺷﺮ ١١٤
...
٦١١
٤,٤,٢ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﻟﻨﺼﻮﺹ
...
reference
٦,٤,٢ ﻣﺆﺷﺮ ﻟـ ١٢٠
...
١٢١
٨,٤,٢ ﻣﺆﺷﺮ ﳌﺆﺷﺮ
...
٣٢١
٠١,٤,٢ ﲤﺎﺭﻳﻦ
...
Functions
١,٥,٢ ﻧﻮﻉ ﺍﻟﺪﺍﻟﺔ ١٢٨
...
Function Name
٣,٥,٢ ﻭﺳﺎﺋﻂ ﺍﻟﺪﺍﻟﺔ ١٣١
...
١٣١
٥,٥,٢ ﺍﳌﺨﺘﺼﺮﺍﺕ ١٣٢
...
٢٣١
٧,٥,٢ ﺩﻭﺍﻝ ﳍﺎ ﻭﺳﺎﺋﻂ ﻣﻦ ﻧﻮﻉ ﺩﻭﺍﻝ
...
٣٣١
٩,٥,٢ ﲤﺎﺭﻳﻦ
...
Header files
١,٦,٢ ﺍﺳﻢ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ
...
٦٣١
٣,٦,٢ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ
...
٧٣١
٧,٢ ﺍﻹﺩﺧﺎﻝ ﻭ ﺍﻹﺧﺮﺍﺝ ﰲ ﺍﳌﻠﻔﺎﺕ ١٣٨
...
٨٣١
١,١,٧,٢ ﺍﻟﺪﺍﻟﺔ ١٤٠
...
fclose
٣,١,٧,٢ ﺍﻟﺪﺍﻟﺔ ١٤١
...
١٤١
٣,٧,٢ ﺍﻹﺩﺧﺎﻝ ﰲ ﺍﳌﻠﻔﺎﺕ
...
r
١,٤,٧,٢ ﺍﻟﻨﻤﻂ +١٤٣
...
a
٣,٤,٧,٢ ﺍﻟﻨﻤﻂ +١٤٣
...
٣٤١
١,٥,٧,٢ ﺍﻟﺪﺍﻟﺔ fprintfﻭ ﺍﻟﺪﺍﻟﺔ ١٤٣
...
fputs
٣,٥,٧,٢ ﺍﻟﺪﺍﻟﺔ fgetcﻭ ﺍﻟﺪﺍﻟﺔ ١٤٥
...
٦٤١
٧,٧,٢ ﲤﺎﺭﻳﻦ
...
structures
١,٨,٢ ﺍﺳﻢ ﺍﻟﺒﻨﻴﺔ ١٤٧
...
union
٣,٨,٢ ﺍﳌﺼﻔﻮﻓﺎﺕ ﻭ ﺍﳌﺆﺷﺮﺍﺕ ﻋﻠﻰ ﺍﻟﺒﻨﻴﺎﺕ
...
٥٥١
٥,٨,٢ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ
...
٦٥١
٩,٢ ﻣﻠﺨﺺ ﻟﻠﻔﺼﻞ ﺍﻟﺜﺎﱐ، ﻣﻌﺎ ﺇﺿﺎﻓﺎﺕ
...
void
٢,٩,٢ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ ١٥٨
...
typedef
٤,٩,٢ ﺑﺮﺍﻣﺞ ﺗﺪﺭﻳﺒﻴﺔ
...
١٦١
٢,٤,٩,٢ ﺗﺒﺎﺩﻝ ﻗﻴﻢ ﺑﲔ ﻭﺳﻴﻄﲔ
...
٣٦١
٤,٤,٩,٢ ﻋﻜﺲ ﺳﻠﺴﻠﺔ ﻧﺼﻴﺔ
...
٤٦١
٦,٤,٩,٢ ﺍﻟﺘﺤﻮﻳﻞ ﻣﻦ ﺍﳊﺮﻭﻑ ﺍﻟﺼﻐﲑﺓ ﺇﱃ ﺍﳊﺮﻭﻑ ﺍﻟﻜﺒﲑﺓ
...
wcsncpy
٦,٩,٢ ﺍﻟﺪﺍﻟﺔ wcscatﻭ ﺍﻟﺪﺍﻟﺔ ١٦٦
...
putwchar
٨,٩,٢ ﺍﻟﺪﺍﻟﺔ _getwsﻭ ١٦٧
...
٧٦١
٠١,٩,٢ ﻣﻌﻠﻮﻣﺎﺕ ﺃﻛﺜﺮ ﺣﻮﻝ ﺍﳌﺘﻐﲑﺍﺕ
...
٨٦١
٢,٠١,٩,٢ ﺍﳌﺘﻐﲑﺍﺕ ﺍﳋﺎﺭﺟﻴﺔ )ﺍﻟﻌﺎﻣﺔ(
...
extern
٤,٠١,٩,٢ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ ١٧٠
...
register
١١,٩,٢ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ ١٧١
...
٢٧١
٣١,٩,٢ ﺍﻟﺘﺤﻜﻢ ﰲ ﻃﺒﺎﻋﺔ ﺍﻟﻨﺘﺎﺋﺞ
...
٣٧١
٥١,٩,٢ ﲤﺎﺭﻳﻦ
...
C
١,٣ ﺍﳊﺴﺎﺏ ١٧٦
...
Enumeration Name
٢,١,٣ ﺛﻮﺍﺑﺖ ﺍﳊﺴﺎﺏ
...
٠٨١
٤,١,٣ ﲤﺎﺭﻳﻦ
...
Command-line Arguments
١,٢,٣ ﺍﻟﻮﺳﻴﻂ ﺍﻷﻭﻝ ﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ
...
٣٨١
٣,٢,٣ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ
...
٤٨١
٣,٣ ﺍﻟﺘﻮﺟﻴﻬﺎﺕ )١٨٥
...
#include
٢,٣,٣ ﺍﻟﺘﻮﺟﻴﻪ ١٨٥
...
#undef
٤,٣,٣ ﺍﻟﺘﻮﺟﻴﻬﺎﺕ #else ،#elif ،#ifﻭ ١٨٧
...
#ifndef
٦,٣,٣ ﺍﻟﺘﻮﺟﻴﻪ ١٨٩
...
#error
٨,٣,٣ ﺍﻟﺘﻮﺟﻴﻪ ١٩٠
...
Predefined Names
٠١,٣,٣ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ
...
١٩١
٤,٣ ﺩﻭﺍﻝ ﺫﺍﺕ ﻭﺳﺎﺋﻂ ﻏﲑ ﳏﺪﺩﺓ
...
٤٩١
٢,٤,٣ ﲤﺎﺭﻳﻦ
...
Standard Library
١,٥,٣ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ١٩٥
...
h
٢,٥,٣ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ١٩٥
...
h
١,٢,٥,٣ ﺍﻟﺪﺍﻟﺔ ١٩٥
...
isalpha
٣,٢,٥,٣ ﺍﻟﺪﺍﻟﺔ ١٩٦
...
isdigit
٥,٢,٥,٣ ﺍﻟﺪﺍﻟﺔ ١٩٧
...
islower
٧,٢,٥,٣ ﺍﻟﺪﺍﻟﺔ ١٩٨
...
ispunct
٩,٢,٥,٣ ﺍﻟﺪﺍﻟﺔ ١٩٩
...
isupper
١١,٢,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٠٠
...
tolower
٣,٥,٣ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ٢٠١
...
h
١,٣,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٠١
...
float
...
limits
...
locale
...
math
...
sin
٢,٧,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٠٦
...
tan
٤,٧,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٠٧
...
log
٥,٧,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٠٨
...
sqrt
٧,٧,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٠٨
...
floor
٩,٧,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٠٩
...
ldexp
١١,٧,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٠٩
...
setjmp
...
signal
...
raise
٠١,٥,٣ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ٢١١
...
h
١١,٥,٣ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ٢١٢
...
h
٢١,٥,٣ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ٢١٣
...
h
١,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢١٣
...
sprintf
٣,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢١٤
...
vfprintf
٥,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢١٥
...
scanf
٧,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢١٦
...
sscanf
٩,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢١٧
...
fgets
١١,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢١٨
...
fputs
٣١,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢١٨
...
getchar
٥١,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢١٩
...
putc
٧١,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٢٠
...
puts
٩١,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٢٠
...
fopen
١٢,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٢١
...
fclose
٣٢,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٢٢
...
rename
٥٢,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٢٣
...
fread
٧٢,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٢٣
...
fseek
٩٢,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٢٥
...
rewind
١٣,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٢٦
...
stdlib
...
atof
٢,٣١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٢٧
...
atol
٤,٣١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٢٧
...
srand
٦,٣١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٢٨
...
exit
٨,٣١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٢٩
...
system
٠١,٣١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٣٠
...
labs
٢١,٣١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٣٠
...
ldiv
٤١,٥,٣ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ٢٣١
...
h
١,٤١,٥,٣ ﺍﻟﺪﺍﻟﺔ strcpyﻭ ﺍﻟﺪﺍﻟﺔ ٢٣١
...
strncat
٣,٤١,٥,٣ ﺍﻟﺪﺍﻟﺔ strcmpﻭ ﺍﻟﺪﺍﻟﺔ ٢٣٣
...
strrchr
٥,٤١,٥,٣ ﺍﻟﺪﺍﻟﺔ strspnﻭ ﺍﻟﺪﺍﻟﺔ ٢٣٤
...
strpbrk
٧,٤١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٣٥
...
strlen
٩,٤١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٣٥
...
strtok
٥١,٥,٣ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ٢٣٦
...
h
١,٥١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٣٧
...
time
٣,٥١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٣٩
...
localtime
٥,٥١,٥,٣ ﺍﻟﺪﺍﻟﺔ ٢٤٠
...
ctime
ﺍﳋﺎﲤﺔ
...
ﺟﺪﻭﻝ ﺍﳉﺪﺍﻭﻝ
...
ﺃﻫﻢ ﺍﳌﺮﺍﺟﻊ
...
ﺃﻣﺎ ﺑﻌﺪ، ﺇﻗﺘﺮﺑﺖ ﺍﳌﺪﺓ ﻋﺎﻡ ﻣﻦ ﺇﻧﺸﺎﺀ ﺍﻟﻨﺴﺨﺔ ﺍﻷﻭﱃ ﻣﻦ ﻛﺘﺎﺏ ﻟﻐﺔ Cﺍﻟﺸﺎﻣﻞ، ﻭ ﺍﻟﻴﻮﻡ ﻗﻤﺖ ﺑﺈﻧﺸﺎﺀ ﺍﻟﻠﻨـﺴﺨﺔ
ﺍﻟﺜﺎﻧﻴﺔ ﻣﻨﻪ، ﻭ ﻟﻜﻦ ﻫﺬﻩ ﺍﻟﻨﺴﺨﺔ ﱂ ﺃﺭﻛﺰ ﻋﻠﻰ ﺍﻟﺘﻮﺳﻴﻊ ﻓﻴﻬﺎ ﻋﻠﻰ ﺍﺳﺎﺑﻘﺔ، ﺇﳕﺎ ﺭﻛﺰﺕ ﻋﻠﻰ ﺗﺼﺤﻴﺢ ﺃﺧﻄﺎﺀﻫﺎ، ﺻـﺤﺤﺖ
ﺍﻟﺬﻱ ﺍﺳﺘﻄﻌﺖ ﻣﻼﺣﻈﺘﻪ، ﻭ ﻻﹶﺯِﻟﹾ ﺃﻧﺘﻈﺮ ﻣﻼﺣﻈﺔ ﺃﺧﻄﺎﺀ ﺃﺧﺮﻯ ﻣﻦ ﹸﺮﺍﺀ ﻫﺬﻩ ﺍﻟﻜﺘﺎﺏ، ﻟﺬﺍ ﺃﺭﺟﻮ ﻟﻜﻞ ﻣﻦ ﻗﺮﺃ ﺍﻟﻜﺘﺎﺏ ﻭ
ﻗ
ﺖ
ﻭﺟﺪ ﺑﻪ ﺃﺧﻄﺎﺀ ﺳﻮﺍﺀ ﻛﺎﻧﺖ ﺃﺧﻄﺎﺀ ﺇﻣﻼﺋﻴﺔ ﺃﻭ ﻣﻌﻨﻮﻳﺔ )ﻭ ﺧﺎﺻﺔ ﺍﳌﻌﻨﻮﻳﺔ( ﺃﻥ ﻳﻘﻮﻡ ﺑﺘﻨﺒﻴﻬﻲ ﻋﻠـﻰ ﺑﺮﻳـﺪﻱ ﺍﻹﻟﻴﻜﺘـﺮﻭﱐ
،khalil_ounis@yahoo
...
ﺣﻴﺚ ﺳﻴﺘﻢ ﺇﻧﺸﺎﺀ ﻗﺎﺋﻤﺔ ﻷﲰﺎﺀ ﻼﺣﻈﻲ
ﻣ
ﺃﺧﻄﺎﺀ ﻫﺬﺍ ﺍﻟﻜﺘﺎﺏ ﻭ ﻭﺿﻌﻬﺎ ﰲ ﺍﻟﺼﻔﺤﺎﺕ ﺍﻷﻭﱃ ﻣﻦ ﺍﻟﻜﺘﺎﺏ )ﻳﻌﲏ ﻋﻤﻞ ﲨﺎﻋﻲ(
...
ﻭ ﻃﺒﻌﺎ ﺗﻮﺟﺪ ﺃﺧﻄﺎﺀ ﺃﺧﺮﻯ ﻣﺘﻔﺮﻗـﺔ ﰲ
ﺍﻟﻜﺘﺎﺏ ﱂ ﺃﺫﻛﺮﻫﺎ
...
§ ﺍﻟﻔﺼﻞ ﺍﻟﺜﺎﱐ ﻣﻜﻤﻞ ﻟﻠﻔﺼﻞ ﺍﻷﻭﻝ ﰲ ﻛﻞ ﻣﻦ ﺍﻟﻘﺮﺍﺭ ،Switchﺣﻠﻘﺎﺕ ﺍﻟﺘﻜـﺮﺍﺭ، ﺍﳌـﺼﻔﻮﻓﺎﺕ ﻭ ﺍﳌﺆﺷـﺮﺍﺕ،
ﺍﻟﺪﻭﺍﻝ، ﺍﳌﻠﻔﺎﺕ ﺍﻟﺮﺃﺳﻴﺔ، ﺍﻹﺩﺧﺎﻝ ﻭ ﺍﻹﺧﺮﺍﺝ ﰲ ﺍﳌﻠﻔﺎﺕ ﻭ ﺍﻟﺘﺮﺍﻛﻴﺐ، ﻭ ﺃﺧﲑﺍ ﻣﻠﺨﺺ ﻟﻠﻔﺼﻞ ﺍﻟﺜﺎﱐ
...
C
ﺟ
ﻭ ﺍﻟﻜﺘﺎﺏ ﻣﻔﺘﻮﺡ ﻟﻜﻞ ﻣﻦ ﻳﺮﻳﺪ ﺇﺿﺎﻓﺔ ﺣﺮﻑ، ﻛﻠﻤﺔ، ﲨﻠﺔ ﺃﻭ ﻤﻞ، ﺃﺟﺰﺍﺀ ﺃﻭ ﺃﻱ ﺷﻲﺀ ﻣﻔﻴـﺪ)ﺷـﺎﺭﻛﻨﺎ ﺍﳋـﲑ(
...
ﺧﻠﻴﻞ ﺃﻭﻧﻴﺲ، ﺍﳉﺰﺍﺋﺮ
٨١٦٦٧٥٤٦٠ )ﻣﻦ ﺍﻟﺪﺍﺧﻞ(، ٨١٦٦٧٥٤٦٣١٢+
ﺗﺎﺭﻳﺦ ﺍﻹﻧﺘﻬﺎﺀ ﻣﻦ ﺍﻟﻨﺴﺨﺔ: ٩١-٨٠-٦٠٠٢
91
ﰲ ﺃﻳﺎﻡ ﺑﺪﺍﻳﺔ ﺍﳊﺎﺳﻮﺏ ﻛﺎﻧﺖ ﺍﻟﱪﳎﺔ ﺗﺘﻢ ﻋﻠﻰ ﻟﻐﺔ ﺑﺪﺍﺋﻴﺔ ﻣﻨﺨﻔﻀﺔ ﺍﳌﺴﺘﻮﻯ low-level languageﺗﺪﻋﻰ ﺑﻠﻐﺔ ﺍﻵﻟﺔ
،Machine languageﺣﻴﺚ ﻛﺎﻧﺖ ﺗﻔﻬﻤﻬﺎ ﺍﻵﻟﺔ ﻣﺒﺎﺷﺮﺓ، ﻭ ﻳﺘﻢ ﺍﻟﱪﳎﺔ ﻋﻠﻴﻬﺎ ﺑﺄﻭﺍﻣﺮ ﻤﺜﻞ ﲞﻴﻮﻁ ﻃﻮﻳﻠﺔ ﻜﻮﻧﺔ ﻣﻦ ﺍﻟﻮﺍﺣﺪ
ﻣ
ﺗ
ﻭ ﺍﻟﺼﻔﺮ )ﺍﻟﺼﻔﺮ ﺗﻌﲏ lowﻭ ﻫﻲ ﳏﺼﻮﺭﺓ ﺑﲔ ٥,٠- ﻭ ٥,٠+ ﻓﻮﻟﺖ، ﻭ ﺍﻟﻮﺍﺣﺪ ﻳﻌﲏ highﻭ ﻫﻮ ﳏﺼﻮﺭ ﺑـﲔ ٥,٤+ ﻭ
٥,٥+ ﻓﻮﻟﺖ( ﺃﻱ ﲟﺎ ﻳﺴﻤﻰ ﺑﺎﻟﻨﻈﺎﻡ ﺍﻟﺜﻨﺎﺋﻲ، ﻭ ﻛﺎﻧﺖ ﺍﻟﱪﳎﺔ ﻋﻠﻴﻬﺎ ﺻﻌﺒﺔ ﻭ ﻣﻌﻘﺪﺓ ﺣﱴ ﰎ ﺗﻄﻮﻳﺮ ﻟﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ assembly
،languageﻭ ﻫﻲ ﻣﻦ ﺍﻟﻠﻐﺎﺕ ﺍﳌﻨﺨﻔﻀﺔ ﺍﳌﺴﺘﻮﻯ low-level languagesﺃﻳﻀﺎ، ﺣﻴﺚ ﻛﺎﻧﺖ ﺳﻬﻠﺔ ﺑﺎﻟﻨﺴﺒﺔ ﻟـﻠﻐﺔ ﺍﻵﻟـﺔ،
ﻓﺒﺪﻝ ﺍﺳﺘﻌﻤﺎﻝ ﺳﻼﺳﻞ ﻣﻦ ﺍﻟﺼﻔﺮ ﻭ ﺍﻟﻮﺍﺣﺪ ﻧﺴﺘﻌﻤﻞ ﺃﻭﺍﻣﺮ ﺫﺍﺕ ﻛﻠﻤﺎﺕ ﻣﻔﻬﻮﻣﺔ ﻣﺜﻞ ADDﻭ
...
ﻭ ﻫﺬﻩ ﻣﻌﻠﻮﻣﺎﺕ ﳐﺘﺼﺮﺓ ﻋﻦ ﺑﻌﺾ ﺍﻟﻠﻐﺎﺕ:
ﻟﻐﺔ ﺍﳉﻤﻴﻊ ،Assembly Languageﰎ ﺗﻄﻮﻳﺮﻫﺎ ﰲ ﻋﺎﻡ ٦٥٩١ ﻣﻦ ﻗﺒﻞ ﺷﺮﻛﺔ
...
ﻟﻐـﺔ ﻛﻮﺑـﻮﻝ ،COBOL Language
ﺇﺧﺘﺼﺎﺭ ﻟـ ،Common Business Oriented Languageﺃﻱ ﻟﻐﺔ ﻣﻮﺟﻬﺔ ﻟﻸﻋﻤﺎﻝ ﺍﻟﺘﺠﺎﺭﻳﺔ، ﰎ ﺗﻄﻮﻳﺮﻫﺎ ﰲ ﻋـﺎﻡ ٩٥٩١
ﻣﻦ ﻗﺒﻞ ﳉﻨﺔ ﻗﺼﲑﺓ ﻣﻜﻮﻧﺔ ﻣﻦ ﺛﻼﺛﺔ ﺷﺮﻛﺎﺕ ﻣﻨﻬﺎ
...
ﻟﻐﺔ ﺁﻟﭭﻮﻝ ،Algol Languageﺇﺧﺘﺼﺎﺭ ﻟـ ،Algorithmic Languageﰎ ﺗﻄﻮﻳﺮﻫﺎ ﰲ ﻋﺎﻡ ٨٥٩١ ﻣﻦ ﻗﺒﻞ
ﳎﻤﻮﻋﺔ ﻣﻦ ﻋﻠﻤﺎﺀ ﺣﻮﺍﺳﻴﺐ ﺃﻭﺭﻭﺑﻴﲔ ﻭ ﺃﻣﺮﻳﻜﻴﲔ
...
Niklaus Wirthﻭ ﺗﺬﻛﺮ ﺃﻧﺎ ﻛﻞ ﻣـﻦ
ﺍﻟﻠﻐﺎﺕ ﺍﻟﺴﺎﺑﻘﺔ ﻫﻲ ﺃﻗﺪﻡ ﻟﻐﺎﺕ ﺑﺮﳎﺔ
...
Bellﻟﻐﺔ Cﻣﻦ ﺍﻟﻠﻐﺎﺕ ﺍﳌﻨﺨﻔﻀﺔ ﺍﳌﺴﺘﻮﻯ low-level languagesﺣﻴﺚ ﺃﺎ ﻗﺮﻳﺒﺔ ﻣﻦ ﺍﻷﺟﻬﺰﺓ ﻭ ﺷـﺒﻴﻬﺎ ﺑﻠﻐـﺔ
ﺍﻟﺘﺠﻤﻴﻊ assembly languageﰲ ﻋﻤﻠﻬﺎ، ﻭ ﻟﻜﻦ ﺍﻟﺒﻌﺾ ﻳﻌﺘﱪﻫﺎ ﻟﻐﺔ ﻣﺘﻮﺳﻄﺔ ﺍﳌﺴﺘﻮﻯ mid-level languageﻷـﺎ ﻟﻐـﺔ
ﲢﺎﻛﻲ ﻟﻐﺔ ﺍﻹﻧﺴﺎﻥ ﺑﻌﺾ ﺍﻟﺸﻲﺀ، ﻭ ﻫﻲ ﻟﻐﺔ ﻣﺴﺘﻘﻠﺔ ﻋﻦ ﺍﻟﺒﻨﻴﺔ ﺍﻟﺼﻠﺒﺔ ﻟﻠﺤﺎﺳﻮﺏ
...
ﰲ ﻋـﺎﻡ ٣٧٩١ ﰎ
ﺇﻃﻼﻕ ﻟﻐﺔ Cﺑﺸﻜﻞ ﺭﲰﻲ، ﻭ ﲰﻴﺖ ﺑﻠﻐﺔ Cﻷﺎ ﻛﺎﻧﺖ ﻣﺸﺘﻘﺔ ﻣﻦ ﻟﻐﺔ ﺍﻟـ ) Bﻭ ﻛﺎﻧﺖ ﻟﻐﺔ ﺍﻟـ Bﻧﻔﺴﻬﺎ ﻣﺸﺘﻘﺔ ﻣﻦ ﻟﻐﺔ
BCPLﺍﻟﱵ ﻗﺎﻡ ﺑﺘﻄﻮﻳﺮﻫﺎ ﻣﺎﺭﺗﻦ ﺭﻳﺘﺸﺎﺭﺩﺯ Martin Richardsﰲ ﻋﺎﻡ ٧٦٩١، ﻭ ﻫـﻲ ﳐﺘـﺼﺮﺓ ﻣـﻦ Basic Combined
،Programming Languageﺣﻴﺚ ﻛﺎﻥ ﺍﻟﻔﺮﻕ ﺑﲔ ﺍﻟﻠﻐﺘﲔ ﻫﻮ ﻧﻮﻉ ﺍﻟﺒﻴﺎﻧﺎﺕ( ﺍﻟﱵ ﻗﺎﻡ ﺑﺘﻄﻮﻳﺮﻫﺎ ﻛﲔ ﺗﻮﻣـﺴﻦ ﰲ ﻋـﺎﻡ
٩٦٩١ ﺣﻴﺚ ﺃﺧﺬ ﺍﳊﺮﻑ Bﻣﻦ ﺍﺳﻢ ﺍﳌﺨﺘﱪ Bellﺍﻟﺬﻱ ﻳﻌﻤﻞ ﺑﻪ، ﻭ ﺍﻟﺬﻱ ﻳﻠﻲ ﺍﳊﺮﻑ Bﰲ ﺍﻷﲜﺪﻳﺔ ﻫﻮ ،Cﻭ ﺫﻟﻚ ﻫﻮ
ﺳﺒﺐ ﺗﺴﻤﻴﺘﻬﺎ ﺑﻠﻐﺔ
...
Cﰲ ﻋﺎﻡ ٩٨٩١ ﰎ ﺇﻃﻼﻕ ﺍﻟﻨﺴﺨﺔ ﺍﻟﻘﻴﺎﺳﻴﺔ
ﻟﻠﻐﺔ Cﻭ ﲰﻴﺖ ﺑـ ANSI Cﻭ ﻫﻲ ﳐﺘﺼﺮﺓ ﻣﻦ American National Standards Institute Cﺃﻱ ﺍﻟﻠﺠﻨﺔ ﺍﻟﻮﻃﻨﻴﺔ ﺍﻷﻣﲑﻛﻴﺔ
ﻟﻠﻤﻌﺎﻳﺮ، ﻭ ﺑﺘﻌﺎﻭﻥ ﺑﲔ ﺍﻟﻠﺠﻨﺔ ﺍﻟﻮﻃﻨﻴﺔ ﺍﻷﻣﲑﻛﻴﺔ ﻟﻠﻤﻌﺎﻳﺮ ﻭ ﺍﳌﻨﻈﻤﺔ ﺍﻟﻌﺎﳌﻴﺔ ﻟﻠﻤﻌﺎﻳﺮ ﰎ ﺇﻃﻼﻕ ﻟﻐﺔ Cﺍﻟﻘﻴﺎﺳﻴﺔ ﰲ ﳐﺘﻠﻒ ﺃﳓﺎﺀ
ﺍﻟﻌﺎﱂ ﻭ ﲰﻴﺖ ﺑـ ISO Cﻭ ﻫﻲ ﺇﺧﺘﺼﺎﺭ ﻟــ
...
(ANSI C
ﺩﻧﻴﺲ ﺭﻳﺘﺸﻲ
ﻛﲔ ﺗﻮﻣﺴﻦ
١,١ ﺍﻷﺩﻭﺍﺕ ﺍﻟﻼﺯﻣﺔ
...
C
٣,١ ﺍﳌﺘﻐﲑﺍﺕ ﻭ ﺍﻟﺜﻮﺍﺑﺖ
...
Comments
٥,١ ﺍﻹﺩﺧﺎﻝ
...
Operators
٧,١ ﺍﻟﻘﺮﺍﺭﺍﺕ
...
C
٩,١ ﻣﻠﺨﺺ ﻟﻠﻔﺼﻞ ﺍﻷﻭﻝ،ﻣﻊ ﺇﺿﺎﻓﺎﺕ
...
ﺑﺎﻟﺘﻮﻓﻴﻖ ﺇﻥ ﺷﺎﺀ ﺍﷲ
ﻗﺎﻝ ﺍﷲ ﺗﻌﺎﱃ:
﴿ ﻳﺮﻓﻊ ﺍﷲ ﺍﻟﺬﻳﻦ ﺁﻣﻨﻮﺍ ﻣﻨﻜﻢ ﻭﺍﻟﺬﻳﻦ ﺃﻭﺗﻮﺍ ﺍﻟﻌﻠﻢ ﺩﺭﺟﺎﺕ ﴾
ﺻﺪﻕ ﺍﷲ ﺗﻌﺎﱃ
22
ﺃﺩﻭﺍﺕ ﻟﻐﺔ Cﻫﻲ ﺛﻼﺛﺔ ﺃﺷﻴﺎﺀ ﻻ ﺃﻛﺜﺮ، ﳏﺮﺭ ﻧﺼﻮﺹ ،texts editorﻣﺘـﺮﺟﻢ compilerﻭ ﻣـﺮﺑﻂ
...
ﻭ ﻻ ﳝﻜﻦ ﺍﻻﺳﺘﻐﻨﺎﺀ ﻋﻦ ﺃﺩﺍﺓ ﻣﻦ ﻫﺬﻩ
ﺍﻷﺩﻭﺍﺕ
...
ﺃﻣﺎ ﰲ ﺍﻟﺴﺎﺑﻘﺔ ﻓﻜﺎﻧﺖ ﺗﺘﻢ ﻫﺬﻩ ﺍﻟﻌﻤﻠﻴﺎﺕ ﻋﻠﻰ ﺷﻜﻞ ﺃﻭﺍﻣﺮ ﻣﻦ
...
cﻫﻨﺎﻙ ﺑﻌﺾ ﺍﳌﺘﺮﲨﺎﺕ )ﺍﻟﻘﺪﳝﺔ( ﺍﻟـﱵ ﻻ
ﻳﻬﻤﻬﺎ ﺍﻣﺘﺪﺍﺩ ﺍﳌﻠﻒ ﺍﻟﻨﺼﻲ ﻟﻠﱪﻧﺎﻣﺞ، ﻭ ﻟﻜﻦ ﻣﻦ ﺍﻷﻓﻀﻞ ﺍﺳﺘﻌﻤﺎﻝ ﺍﻟﺼﻴﻐﺔ ﺍﻟﺮﲰﻴﺔ
...
ASCIIﻻ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻝ ﺍﶈﺮﺭ Wordﰲ ﺃﻧﻈﻤﺔ Windowsﺃﻭ KWordﰲ ﺃﻧﻈﻤﺔ
...
objﲢﺘﻮﻱ ﻫﺬﻩ ﺍﳌﻠﻔﺎﺕ ﻋﻠﻰ ﺗﻌﻠﻴﻤﺎﺕ ﺍﻟﺘﺠﻤﻴﻊ ﺃﻭ ﺍﻵﻟﺔ ﻣﻢ ﻳﺴﻬﻞ ﻋﻤﻠﻴﺔ ﺭﺑﻂ ﻟﻐﺘﲔ ﺃﻭ ﺃﻛﺜـﺮ
ﻣﻊ ﺑﻌﻀﻬﺎ، ﻓﻤﺜﻼ ﳝﻜﻨﻨﺎ ﺍﺳﺘﺪﻋﺎﺀ ﺩﻭﺍﻝ ﻣﻦ ﻟﻐﺔ Pascalﰲ ﻟﻐﺔ
...
،Pelles C ،Quick C ،Turbo Cﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﺘﺮﺟﻢ ++ Visual Cﻓﻬﻮ ﻏﲑ ﳎﺎﱐ
...
bloodshed
...
html
32
ﺍﳌﺘﺮﺟﻢ Turbo Cﺃﻳﻀﺎ ﻣﻦ ﺍﳌﺘﺮﲨﺎﺕ ﺍﺎﻧﻴﺔ، ﻭ ﻫﻮ ﻣﻦ ﺃﻗﺪﻣﻬﺎ، ﻭ ﺍﻷﻛﺜﺮ ﺍﺳﺘﻌﻤﺎﻟﻨﺎ ﰲ ﺍﳉﺎﻣﻌﺎﺕ، ﺣﻴﺚ ﳝﻜﻦ ﲢﻤﻴﻠﻪ ﻣﻦ
ﺍﻟﺮﺍﺑﻂ ﺍﻟﺘﺎﱄ:
http://www
...
edu/~stephenp/misc/downloadTC
...
smorgasbordet
...
htm
ﺃﻣﺎ ﰲ ﺃﻧﻈﻤﺔ Unixﻭ ،Linuxﻓﻼ ﲢﺘﺎﺝ ﺇﱃ ﻣﺘﺮﲨﺎﺕ ﻷﺎ ﻣﺪﳎﺔ ﻣﻊ ﺃﻱ ﻧﺴﺨﺔ ﻣﻦ ﻧﺴﺦ Unixﻭ ،Linuxﻛﻞ ﻣﺎ ﲢﺘﺎﺟـﻪ
ﻫﻮ ﳏﺮﺭ ﻧﺼﻮﺹ
...
Windows
ﺃﺩﺧﻞ ﻋﻠﻰ ﺍﻟﺮﺍﺑﻂ ﺍﻟﺘﺎﱄ ﺣﻴﺚ ﺗﻮﺟﺪ ﻣﺘﺮﲨﺎﺕ ﳎﺎﻧﻴﺔ ﻋﺪﻳﺪﺓ ﰲ ﻛﻞ ﻣﻦ ﺃﻧﻈﻤﺔ Windowsﻭ ﺃﻧﻈﻤﺔ :Linux
http://www
...
com/compilers/cpp
...
ﻭ ﻫﻨﺎ ﺃﻳﻀﺎ ﻛﻨﺖ ﺃﺭﻳﺪ ﺃﻥ ﻧﺮﻯ ﻛﻴﻒ ﺗﺘﻢ ﺍﻟﺘﺮﲨﺔ ﰲ ﻫﺬﺍ ﺍﻷﻧﻈﻤﺔ، ﻭ ﻧﺄﺧـﺬ ﻣﺜـﺎﻻ
ﻟﺬﻟﻚ، ﻣﺜﻼ ﻟﺪﻳﻨﺎ ﺑﺮﻧﺎﻣﺞ ﳏﻔﻮﻅ ﺑﺈﺳﻢ ،cprog
...
c
ﻫﺬﻩ ﰲ ﺣﺎﻟﺔ ﺃﻥ ﺍﻟﱪﻧﺎﻣﺞ ﻣﻌﺘﻤﺪ ﻋﻠﻰ ﻟﻐﺔ Cﻓﻘﻂ، ﺃﻣﺎ ﺇﺫﺍ ﻛﺎﻥ ﻣﺪﻣﺞ ﻣﻊ ﻟﻐﺔ ++ Cﻓﺴﻨﻜﺘﺐ ﺍﻷﻣﺮ gccﺑﺪﻝ
...
c
ﻫﻨﺎ ﺳﺘﻜﻮﻥ ﻟﺪﻳﻚ ﺇﻣﻜﺎﻧﻴﺔ ﺇﻋﺎﺩﺓ ﺗﺴﻤﻴﺔ ﺍﻟﱪﻧﺎﻣﺞ، ﺃﻣﺎ ﻋﻤﻠﻴﺔ ﺗﻨﻔﻴﺬ ﺍﻟﱪﻧﺎﻣﺞ ﻓﺘﻜﻮﻥ ﻛﺘﺎﱄ:
...
objﰒ ﻳﻌﻄﻴﻨﺎ ﺍﻟﱪﺍﻣﺞ ﺍﻟﺘﻨﻔﻴﺬﻳﺔ ﻭ ﺍﻟﱵ ﺗﻜﻮﻥ ﻏﺎﻟﺒﺎ ﺑﺎﻣﺘﺪﺍﺩ ،
...
dllﻭ ﳝﻜﻦ ﺃﻥ ﺗﻜﻮﻥ ﻫﺬﻩ ﺍﳌﻠﻔﺎﺕ ﻣﻜﺘﻮﺑﺔ ﲟﺨﺘﻠﻒ ﺍﻟﻠﻐﺎﺕ
...
cﳝﻜﻦ ﻛﺘﺎﺑـﺔ main
...
h
)(main
{
;)"!printf("Hello, World
}
ﺍﻟﱪﻧﺎﻣﺞ ١,٢,١: ﺍﻟﱪﻧﺎﻣﺞ ﺍﻷﻭﻝ ﰲ ﻟﻐﺔ
1
2
3
4
5
6
C
ﻣﻼﺣﻈﺔ:
ﻗﻢ ﺑﻜﺘﺎﺑﺔ ﺍﻟﱪﻧﺎﻣﺞ ﺑﺪﻭﻥ ﺍﻟﺘﺮﻗﻴﻤﺎﺕ، ﺃﻱ ﻧﻜﺘﺐ ﺍﻟﱪﻧﺎﻣﺞ ﻋﻠﻰ ﺍﻟﺸﻜﻞ ﺍﻟﺘﺎﱄ:
>#include
Consoleﺍﻟﺴﻄﺮ ﺍﻷﻭﻝ ﻣﻦ ﺍﻟﱪﻧﺎﻣﺞ ﺑﻪ ﺍﻟﺸﻔﺮﺓ ) #include
ﻭ ﺍﻟﻘﺴﻢ ﺍﻟﺜﺎﱐ ﻫﻮ ﻣﺎ ﺑﲔ ﺍﻟﺮﻣﺰﻳﻦ ﺃﻛﱪ ﻣﻦ ﻭ ﺃﺻﻐﺮ ﻣﻦ > <، ﺣﻴﺚ ﻳﻮﺟﺪ ﺍﳌﻠﻒ ،stdio
...
ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ stdio
...
hﻓﻬﻮ ﺍﻣﺘﺪﺍﺩ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ﻭ ﻫﻮ ﳐﺘﺼﺮ ﻣﻦ
...
ﻳﻮﺟﺪ ﺍﻟﻌﺪﻳﺪ ﻣﻦ ﺍﳌﻠﻔﺎﺕ ﺍﻟﺮﺃﺳﻴﺔ،
ﺳﻨﺘﻄﺮﻕ ﺇﻟﻴﻬﺎ ﻓﻴﻤﺎ ﺑﻌﺪ
...
ﻭ ﻣﻦ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﻳﺒﺪﺃ ﺍﻟﱪﻧﺎﻣﺞ ﺑﺎﻟﺘﻨﻔﻴﺬ ﺑﺸﻜﻞ ﻣﺘﺮﺗﺐ، ﺃﻣﺎ ﺍﻟﻘﻮﺳﲔ ﺑﻌﺪ ﺍﺳﻢ ﺍﻟﺪﺍﻟـﺔ
ﻓﻬﻤﺎ ﺍﻟﻠﺬﺍﻥ ﻳﺒﻴﻨﺎﻥ ﻋﻠﻰ ﺃﺎ ﺩﺍﻟﺔ )ﻭ ﺃﺎ ﺩﺍﻟﺔ ﺑﺪﻭﻥ ﻭﺳﺎﺋﻂ( ﻭ ﻟﻴﺴﺖ ﻣﺘﻐﲑ ﺃﻭ ﺛﺎﺑﺖ
...
main
ﰲ ﺍﻟﺴﻄﺮ ﺍﳋﺎﻣﺲ ﺗﻮﺟﺪ ﺍﻟﻜﻠﻤﺔ printfﻭ ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻦ ﺩﺍﻟﺔ ﻣﻮﺟﻮﺩﺓ ﰲ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ،stdio
...
ﺗﺴﺘﻌﻤﻞ ﺍﻟﺪﺍﻟﺔ printfﺑﺼﻔﺔ
ﻋﺎﻣﺔ ﰲ ﻋﺮﺽ ﺃﻭ ﺇﺧﺮﺍﺝ ﻣﻌﻠﻮﻣﺎﺕ ﺇﱃ ﺃﺩﺍﺓ ﺍﻹﺧﺮﺍﺝ ﻭ ﻫﻲ ﺍﻟﺸﺎﺷﺔ Screenﺍﳋﺎﺻﺔ ﺑﺎﳊﺎﺳﻮﺏ
...
mainﻭ ﺗﺴﻤﻰ ﺣﺎﺿﻨﺔ ﺍﻟﺒﺪﺍﻳﺔ { ﻭ
ﺣﺎﺿﻨﺔ ﺍﻟﻨﻬﺎﻳﺔ } ﻭ ﻣﺎ ﺑﻴﻨﻬﻤﺎ ﺑﺎﻟـ ،blockﺻﻮﺭﺓ ﺗﻮﺿﻴﺤﻴﺔ:
ﺍﻟﺸﻜﻞ ١,٢,١:
block
ﳝﻜﻦ ﻛﺘﺎﺑﺔ ﺍﻟﱪﺍﻣﺞ ﺍﻟﺴﺎﺑﻖ ﺑﻄﺮﻕ ﳐﺘﻠﻔﺔ، ﺣﻴﺚ ﳝﻜﻦ ﺗﻘﺴﻴﻢ ﺍﳉﻤﻠﺔ
! Hello, World
ﺇﱃ ﻗﺴﻤﲔ ﻣﺜﻞ:
>#include
ﻭ ﳝﻜﻦ ﺃﻳﻀﺎ ﻛﺘﺎﺑـﺔ ﺍﳉﻤﻠـﺔ
ﺣﺮﻓﻴﺎ، ﻛﻞ ﺣﺮﻑ ﺑﺪﺍﻟﺔ ﻣﻦ
...
h
)(main
{
;)"!printf("Hello, "), printf("World
}
ﺃﻭ:
ﺍﻟﱪﻧﺎﻣﺞ ٣,٢,١: ﺍﻟﱪﻧﺎﻣﺞ ﺍﻷﻭﻝ ﰲ ﻟﻐﺔ (٣) C
1
2
3
4
5
6
>#include
h
1
2
3
4
5
6
7
)(main
{
;)"!printf("Hello, "); printf("World
}
ﺍﻟﱪﻧﺎﻣﺞ ٤,٢,١: ﺍﻟﱪﻧﺎﻣﺞ ﺍﻷﻭﻝ ﰲ ﻟﻐﺔ (٤) C
ﻭ ﺗﻮﺟﺪ ﻃﺮﻳﻘﺔ ﻻ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﳍﺎ ﻭ ﻫﻲ:
)(main
{
,printf("Hello
;)"!World
}
ﺍﻟﱪﻧﺎﻣﺞ ٥,٢,١: ﺍﻟﱪﻧﺎﻣﺞ ﺍﻷﻭﻝ ﰲ ﻟﻐﺔ (٥) C
ﻋﻨﺪ ﺗﺮﲨﺔ ﻫﺬﺍ ﺍﳌﺜﺎﻝ ﺳﻴﻨﺒﻬﻚ ﺍﳌﺘﺮﺟﻢ ﻋﻦ ﻭﺟﻮﺩ ﺃﺧﻄﺎﺀ، ﻣﻨﻬﺎ ﻧﺴﻴﺎﻥ ﻗﻮﺱ ﺍﻟﻨﻬﺎﻳﺔ ﻟﺪﺍﻟـﺔ ،printfﻭ ﻟﺘﻔـﺎﺩﻱ ﻫـﺬﻩ
ﺍﻷﺧﻄﺎﺀ ﻧﻘﻮﻡ ﺑﻮﺿﻊ anti-slashﰲ ﺎﻳﺔ ﺍﻟﺴﻄﺮ ﺍﻷﻭﻝ ﻣﻦ ﺍﻟﺪﺍﻟﺔ ،printfﻭ ﺗﺼﺒﺢ ﺍﻟﺪﺍﻟﺔ ﻛﺎﻵﰐ:
\ ,printf("Hello
;)"!World
ﺍﻟﱪﻧﺎﻣﺞ ٦,٢,١: ﺍﻟﱪﻧﺎﻣﺞ ﺍﻷﻭﻝ ﰲ ﻟﻐﺔ (٦) C
ﰲ ﺍﳌﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ ﺇﻥ ﻛﺘﺒﻨﺎ ﺍﻟﺴﻄﺮ ﺍﻷﻭﻝ )ﺍﻟﺬﻱ ﻳﺘﻤﺜﻞ ﰲ ﺿﻢ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ (stdio
...
ﳝﻜﻦ ﻛﺘﺎﺑﺔ ﺍﻟﻜﻠﻤﺔ , Helloﰲ ﺳﻄﺮ ﻭ ﺍﻟﻜﻠﻤﺔ ! Worldﰲ ﺳﻄﺮ ﺁﺧﺮ ﻭ ﺫﻟﻚ ﺑﺈﺿﺎﻓﺔ ﺍﻟﺮﻣﺰ \nﺑﲔ ﺍﻟﻜﻠﻤﺘﲔ، ﻣﺜﺎﻝ:
>#include
h
)(main
{
;)" ,printf("Hello
;)"printf("\n
;)"!printf("World
}
ﺍﻟﱪﻧﺎﻣﺞ ٨,٢,١: ﺍﻟﱪﻧﺎﻣﺞ ﺍﻷﻭﻝ ﰲ ﻟﻐﺔ (٨) C
ﻋﻨﺪ ﺗﺮﲨﺔ ﺍﻟﱪﻧﺎﻣﺞ ﻭ ﺗﻨﻔﻴﺬﻩ ﻓﻠﻦ ﲡﺪ ﺍﻟﺮﻣﺰ \nﻭ ﺳﺘﺠﺪ ﺃﻥ ﻛﻞ ﻣﻦ ﺍﻟﻜﻠﻤﺘﲔ ﰲ ﺳﻄﺮ، ﻳﺘﻢ ﺍﺳﺘﺒﺪﺍﻝ ﺍﻟﺮﻣﺰ
ﺟﺪﻳﺪ ﺣﻴﺚ ﻻ ﻳﺘﻢ ﻃﺒﺎﻋﺔ ﺍﻟﺮﻣﺰ، ﻭ ﺍﳊﺮﻑ nﻳﻌﲏ
...
h
1
2
3
>#include
h> main
};)"!printf("Hello, World
1
2
};)"!main(){printf("Hello, World
ﺍﻟﱪﻧﺎﻣﺞ ٩,٢,١: ﺍﻟﱪﻧﺎﻣﺞ ﺍﻷﻭﻝ ﰲ ﻟﻐﺔ (٩) C
ﰎ ﲨﻊ ﲨﻴﻊ ﺍﻷﺳﻄﺮ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﻟﺚ، ﻭ ﺍﻟﱪﻧﺎﻣﺞ ﻳﻌﻤﻞ ﻣﺜﻞ ﺍﻟﺴﺎﺑﻖ ﺑﺪﻭﻥ ﺃﺧﻄﺎﺀ، ﺣﻴﺚ ﺳﺘﻼﺣﻆ ﺃﻧﻪ ﳝﻜﻦ ﺍﺳـﺘﻌﻤﺎﻝ
ﺍﳊﺎﺿﻨﺔ { )ﺑﺪﺍﻳﺔ ﺍﻟﺪﺍﻟﺔ( ﻭ ﺍﳊﺎﺿﻨﺔ } )ﺎﻳﺔ ﺍﻟﺪﺍﻟﺔ( ﰲ ﻧﻔﺲ ﺍﻟﺴﻄﺮ، ﻭ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻝ ﺃﻛﺜﺮ ﻣﻦ ﺫﻟﻚ ﻣﺜﻞ:
{)(main
};)"!printf("Hello, World
ﺍﻟﱪﻧﺎﻣﺞ ٠١,٢,١: ﺍﻟﱪﻧﺎﻣﺞ ﺍﻷﻭﻝ ﰲ ﻟﻐﺔ (١٠) C
ﻭ ﻃﺮﻕ ﺃﺧﺮﻯ، ﻭ ﻟﻜﻦ ﳚﺐ ﺃﻥ ﺗﻜﻮﻥ ﺍﻷﻭﺍﻣﺮ، ﺍﻟﻮﻇﺎﺋﻒ ﻭ ﺍﻟﺪﻭﺍﻝ ﺍﳌﺮﺍﺩ ﺇﺳﺘﻌﻤﺎﳍﺎ ﺩﺍﺧﻞ ﺍﳊﺎﺿﻨﺘﲔ } { ﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ
...
ﻭ ﺗﻮﺟﺪ ﻃﺮﻳﻘﺔ ﻻ ﳝﻜﻦ ﺇﺳﺘﻌﻤﺎﳍﺎ ﻭ ﻫﻲ ﻣﻮﺿﺤﺔ
ﰲ ﺍﳌﺜﺎﻝ ﺍﻟﺘﺎﱄ:
ﺍﻟﱪﻧﺎﻣﺞ ١١,٢,١: ﺍﻟﱪﻧﺎﻣﺞ ﺍﻷﻭﻝ ﰲ ﻟﻐﺔ (١١) C
92
ﺇﺫﺍ ﺗﺮﲨﺔ ﻫﺬﺍ ﺍﳌﺜﺎﻝ ﻓﺴﻴﻨﺒﻬﻚ ﺍﳌﺘﺮﺟﻢ ﻋﻦ ﻭﺟﻮﺩ ﺧﻄﺄ ﻷﻥ ﺍﻟﻜﻠﻤﺔ #includeﺗﺘﻄﻠﺐ ﺳﻄﺮﺍ ﻛﺎﻣﻼ ﳍﺎ )ﻣـﻦ ﻗﻮﺍﻋـﺪ
ﺍﻟﻠﻐﺔ(
...
ﺗﻮﺟﺪ ﺍﻟﻜﺜﲑ ﻣﻦ ﺍﻟﺘﻮﺟﻴﻬﺎﺕ directiveﻭ ﳝﻜﻦ ﲤﻴﺰﻫﺎ ﺑﺎﻟﺮﻣﺰ
#، ﺳﻨﻌﺮﻓﻬﺎ ﰲ ﺍﻟﺪﺭﻭﺱ ﺍﻟﻘﺎﺩﻣﺔ
...
h
)(main
{
;)"printf("Hello, World!\n
{
;)"printf("Hello, World!\n
}
;)"printf("Hello, World!\n
}
1
2
3
4
5
6
7
8
9
01
ﺍﻟﱪﻧﺎﻣﺞ ٢١,٢,١: ﺍﻟﱪﻧﺎﻣﺞ ﺍﻷﻭﻝ ﰲ ﻟﻐﺔ (١٢) C
ﻭ ﻳﺘﻢ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ﻛﺎﻟﺘﻌﺎﻣﻞ ﻣﻊ blockﺍﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ، ﻭ ﳝﻜﻦ ﺇﻧﺸﺎﺀ ﺃﻛﺜﺮ ﻣﻦ blockﺩﺍﺧﻞ ﺍﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ، ﺃﻭ ﺍﺳﺘﻌﻤﺎﻝ
blockﺩﺍﺧﻞ blockﺁﺧﺮ
...
ﰲ ﻟﻐﺔ Cﻟﻜﻞ ﻧﻮﻉ ﻣﻦ ﺍﻷﻋﺪﺍﺩ ﺭﻣﺰ ﻟﺘﻌﺎﻣﻞ ﻣﻌﻪ، ﻣﺜﻼ ﺍﻷﻋﺪﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ ﻳﺘﻢ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ﺑﺎﻻﺳﺘﻌﻤﺎﻝ ﺍﻟﺮﻣـﺰ %dﺃﻭ ،%i
ﺍﻟﺮﻣﺰ ﺍﻷﻭﻝ ﳐﺘﺼﺮ ﻣﻦ Decimalﻭ ﺍﻟﺮﻣﺰ ﺍﻟﺜﺎﱐ ﳐﺘﺼﺮ ﻣﻦ ،Integerﻫﺬﺍ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻸﻋﺪﺍﺩ ﺍﻟﺼﺤﻴﺢ، ﺃﻣﺎ ﺍﻷﻋﺪﺍﺩ ﺍﳊﻘﻴﻘﻴـﺔ
ﻓﻴﺘﻢ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﺮﻣﺰ ،%fﻭ ﺍﳊﺮﻑ fﳐﺘﺼﺮ ﻣﻦ ،floatﻭ ﺃﻳﻀﺎ ﺗﻮﺟﺪ ﺭﻣﻮﺯ ﺃﺧﺮﻯ ﺧﺎﺻﺔ ﺑﺎﻟﺘﻌﺎﻣﻞ ﻣﻊ ﻛﻞ
ﻣﻦ ﺍﳊﺮﻭﻑ ﻭ ﺍﻟﻨﺼﻮﺹ، ﺳﻨﺘﻄﺮﻕ ﺇﻟﻴﻬﺎ ﻓﻴﻤﺎ ﺑﻌﺪ
...
h
ﺍﻟﱪﻧﺎﻣﺞ ٣١,٢,١:ﻃﺒﺎﻋﺔ ﻋﺪﺩ ﺻﺤﻴﺢ
)(main
{
;)02 ,"printf("%d
}
1
2
3
4
5
6
ﻫﻨﺎ ﻭﺿﻌﻨﺎ ﺭﻣﺰ ﺍﻷﻋﺪﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ ﺩﺍﺧﻞ ﺍﻟﺪﺍﻟﺔ printfﻭ ﺑﲔ ﺍﻻﻗﺘﺒﺎﺳﻴﲔ، ﻭ ﺑﻌﺪ ﺍﻻﻗﺘﺒﺎﺳﻴﲔ ﻧﻘﻮﻡ ﺑﻜﺘﺎﺑﺔ ﺍﻟﻌﺪﺩ ﺍﳌـﺮﺍﺩ
ﻃﺒﻌﻪ، ﻭ ﺍﳊﺮﺹ ﻋﻠﻰ ﺃﻥ ﻳﻜﻮﻥ ﺑﲔ ﺍﻻﻗﺘﺒﺎﺳﻴﲔ ﻭ ﺍﻟﻌﺪﺩ ﻓﺎﺻﻠﺔ، ﻭ ﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻝ ﻋﻤﻠﻴﺎﺕ ﻣﺜﻞ ﺍﳉﻤﻊ ﻣﺜﻼ ﻭ
ﺫﻟﻚ ﺑﺈﺿﺎﻓﺔ ﻣﺆﺛﺮ ﺍﳉﻤﻊ ﻣﻊ ﺍﻟﻌﺪﺩ ﺍﳌﺮﺍﺩ ﺍﳉﻤﻊ ﻣﻌﻪ ﻣﺜﻞ ﻣﺎ ﻫﻮ ﻣﻮﺿﺢ ﰲ ﺍﳌﺜﺎﻝ ﺍﻟﺘﺎﱄ:
>#include
ﻭ ﳝﻜﻦ ﺇﻇﻬﺎﺭ ﺃﻛﺜﺮ ﻣﻦ ﺭﻗـﻢ ﻭ ﺫﻟـﻚ
ﺑﺰﻳﺎﺩﺓ ﺍﻟﺮﻣﺰ %dﻣﻊ ﻓﺼﻠﻪ ﻣﻦ ﺍﻟﺮﻣﺰ ﺍﻟﺴﺎﺑﻖ ﺣﱴ ﺗﻜﻮﻥ ﺍﻷﺭﻗﺎﻡ ﻭﺍﺿﺤﺔ ﻣﺜﻞ ﻣﺎ ﻳﻠﻲ:
>#include
h
)(main
{
;)5+02 ,5 ,02 ,"printf("%d + %d = %d\n
}
ﺍﻟﱪﻧﺎﻣﺞ ٦١,٢,١: ﻋﻤﻠﻴﺔ ﲨﻊ
1
2
3
4
5
6
13
ﻭ ﻧﻔﺲ ﺍﻟﻄﺮﻳﻘﺔ ﻣﻊ ﺍﻷﻋﺪﺍﺩ ﺍﳊﻘﻴﻘﻴﺔ ﻓﻘﻂ ﻧﺴﺘﻌﻤﻞ ﺍﻟﺮﻣﺰ %fﺑﺪﻝ ﺍﻟﺮﻣﺰ
...
h
)(main
{
;)41
...
1 ,41
...
1 ,"printf("%f + %f = %f\n
}
ﺍﻟﱪﻧﺎﻣﺞ ٧١,٢,١: ﲨﻊ ﻭ ﺇﻇﻬﺎﺭ ﺃﻋﺪﺍﺩ ﺣﻘﻴﻘﻴﺔ
1
2
3
4
5
6
ﻣﻼﺣﻈﺔ:
ﰲ ﺍﳌﺜﺎﻝ ﺍﻟﺴﺎﺑﻘﺔ ﻭﺿﻌﻨﺎ ﺍﻟﻨﻘﻄﺔ ﰲ ﻣﻜﺎﻥ ﺍﻟﻔﺎﺻﻠﺔ، ﻫﻜﺬﺍ ﻛﻲ ﳝﻴﺰ ﺍﳌﺘﺮﺟﻢ ﻋﻠﻰ ﺃﺎ ﻗﻴﻢ ﻟﻸﻋﺪﺍﺩ ﺣﻘﻴﻘﻴﺔ ﺃﻱ ﺃﺎ ﺃﻋﺪﺍﺩ
ﳍﺎ ﻓﻮﺍﺻﻞ، ﺃﻣﺎ ﺇﺫﺍ ﻭﺿﻌﺖ ﺍﻟﻔﺎﺻﻠﺔ ﰲ ﻣﻜﺎﻥ ﺍﻟﻨﻘﻄﺔ ﻓﺴﻴﻌﺘﱪﻫﺎ ﺍﳌﺘﺮﺟﻢ ﻣﻨﻔﺼﻠﺔ ﻋﻦ ﺍﻷﺧﺮﻯ ﻭ ﻫﻜﺬﺍ ﺳـﺘﻨﺠﻢ ﺃﺧﻄـﺎﺀ
ﻛﺜﲑﺓ، ﻭ ﺗﺬﻛﺮ ﺃﻥ ﺍﻟﻔﺎﺻﻠﺔ ﺗﺴﺘﻌﻤﻞ ﰲ ﻓﺼﻞ ﻭﺳﺎﺋﻂ ﺩﺍﻟﺔ
...
ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﺤﺮﻭﻑ ﻓﻬﺬﺍ ﻣﺜﺎﻝ ﻳﻮﺿﺢ ﻃﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﳍﺎ:
>#include
h
ﺍﻟﱪﻧﺎﻣﺞ ٩١,٢,١: ﻃﺒﺎﻋﺔ ﺣﺮﻑ )٢(
ﻫﻨﺎ ﺳﻴﻄﺒﻊ ﺍﻟﱪﻧﺎﻣﺞ ﺍﳊﺮﻑ ،aﻭ ﰲ ﺣﺎﻟﺔ ﺃﺭﺩﻧﺎ ﻃﺒﻊ ﻧﺺ ﻧﻜﺘﺐ ﻛﻤﺎ ﻳﻠﻲ:
1
2
3
4
5
6
>#include
h
)(main
{
;)"printf("%s", "Hello, " "\n" "World
}
ﺍﻟﱪﻧﺎﻣﺞ ١٢,٢,١: ﻃﺒﺎﻋﺔ ﻧﺺ )٢(
ﻭ ﺗﻮﺟﺪ ﺭﻣﻮﺯ ﺃﺧﺮﻯ ﻣﻨﻬﺎ ﻣﻦ ﻫﻲ ﺧﺎﺻﺔ ﺑﺄﺭﻗﺎﻡ ﺍﻟﻨﻈﺎﻡ ﺍﻟﺴﺪﺍﺳﻲ ﻋﺸﺮ ﻭ ﺍﻟﱵ ﻳﻜﻮﻥ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﺮﻣﺰ %xﺃﻭ
%Xﺣﻴﺚ ﺗﺒﺪﺃ ﻣﻦ 0xﺃﻭ ،0Xﻣﺜﻼ ﺍﻟﺮﻗﻢ ،0x000Fﻭ ﺍﻟﺮﻣﺰ %oﻷﻋﺪﺍﺩ ﺍﻟﻨﻈﺎﻡ ﺍﻟﺜﻤﺎﱐ، ﻭ ﺭﻣﻮﺯ ﺃﺧـﺮﻯ ﺳـﻨﻌﺮﻓﻬﺎ ﰲ
ﺍﻟﺪﺭﻭﺱ ﺍﻟﻘﺎﺩﻣﺔ
...
ﰲ ﻟﻐﺔ Cﺍﳌﺘﺮﲨﺎﺕ ﺗﻔﺮﻕ ﺑﲔ ﺍﳊﺮﻭﻑ ﺍﻟﻜﺒﲑﺓ ﻭ ﺍﳊﺮﻭﻑ ﺍﻟﺼﻐﲑﺓ، ﻣﺜﻼ ﺍﻟﺪﺍﻟﺔ mainﻻ ﳝﻜﻦ ﻛﺘﺎﺑﺘﻬﺎ Mainﺃﻭ
...
ﻻ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ printfﺃﻭ ﺩﻭﺍﻝ ﺃﺧﺮﻯ ﺧﺎﺭﺝ ﺍﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ،mainﻣﺜﻼ ﻻ ﳝﻜﻦ ﻛﺘﺎﺑﺔ:
>#include
٣
...
33
٤
...
printf
٥
...
٣,٢,١ ﲤﺎﺭﻳﻦ:
١
...
٢
...
٤
...
ﺃﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮﻡ ﺑﻄﺒﺎﻋﺔ ﺍﳉﻤﻠﺔ ! ،Hello, Worldﻛﻞ ﺣﺮﻑ ﰲ ﺳﻄﺮ
...
٧
...
(%c
٨
...
ﻭ ﺗﻔﻘﺪ ﻫﺬﻩ ﺍﻟﺬﺍﻛﺮﺓ ﲨﻴﻊ ﺑﻴﺎﻧﺎﺎ ﻋﻨﺪ ﻗﻄﻊ ﺍﻟﺘﻴﺎﺭ
...
ﺻﻮﺭﺓ ﺗﻮﺿﻴﺤﻴﺔ:
ﺍﻟﺸﻜﻞ ١,٣,١: ﺍﻟﺬﺍﻛﺮﺓ ﻭ ﺍﻟﻌﻨﺎﻭﻳﻦ ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ
real mode
ﰲ ﻟﻐﺔ Cﻳﻮﺟﺪ ﻋﺪﺕ ﺃﻧﻮﺍﻉ ﻣﻦ ﺍﳌﺘﻐﲑﺍﺕ ﻭ ﺍﻟﺜﻮﺍﺑﺖ، ﻣﻨﻬﺎ ﻣﺘﻐﲑﺍﺕ ﺧﺎﺹ ﺑﺎﻷﻋﺪﺍﺩ ﺍﻟﺼﺤﻴﺢ ﻭ ﺃﺧﺮﻯ ﺑﺎﻷﻋﺪﺍﺩ ﺍﳊﻘﻴﻘﻴﺔ
ﻭ ﺃﺧﺮﻯ ﺑﺎﻷﺣﺮﻑ ﻭ
...
ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺘﻐﲑ ﻫﻲ ﻛﺘﺎﺑﺔ ﻧﻮﻉ ﺍﳌﺘﻐﲑ ﰒ ﺍﺳﻢ ﺍﳌﺘﻐﲑ ﰒ ﺍﻟﻘﻴﻤﺔ ﺍﻟﱵ ﺳـﻴﺤﺘﻮﻳﻬﺎ
)ﻫﺬﺍ ﰲ ﺣﺎﻟﺔ ﺇﻋﻄﺎﺀﻩ ﻗﻴﻤﺔ ﻣﺒﺎﺷﺮﺓ( ﺍﳌﺘﻐﲑ، ﺻﻮﺭﺓ ﺗﻮﺿﻴﺤﻴﺔ:
53
ﺍﻟﺸﻜﻞ ٢,٣,١: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺘﻐﲑ
١,٣,١ ﻧﻮﻉ ﺍﳌﺘﻐﲑ :Variable Type
ﻛﻤﺎ ﻗﻠﻨﺎ ﺳﺎﺑﻘﺎ، ﺗﻮﺟﺪ ﻋﺪﺓ ﺃﻧﻮﺍﻉ ﻟﻠﻤﺘﻐﲑﺍﺕ، ﻭ ﻟﻜﻦ ﺍﻟﺬﻱ ﳚﺐ ﺃﻥ ﻧﻌﺮﻓﻪ ﻫﻮ ﺃﻥ ﺗﻠﻚ ﺍﻷﻧﻮﺍﻉ ﻻ ﲣﺘﻠﻒ ﻋﻦ ﺑﻌﻀﻬﺎ
ﺇﻻ ﰲ ﺍﳊﺠﻢ، ﻭ ﻫﺬﺍ ﻳﻌﲏ ﻟﻮ ﺃﻋﻠﻨﺎ ﻋﻦ ﻣﺘﻐﲑ ﻷﻋﺪﺍﺩ ﺻﺤﻴﺢ ﳝﻜﻨﻨﺎ ﺃﻥ ﻧﻌﻄﻴﻪ ﺣﺮﻓﺎ ﺑﺪﻝ ﻣﻦ ﻗﻴﻤﺔ ﺻﺤﻴﺢ، ﻭ ﻋﻜـﺲ
...
ﺃﻧﻮﺍﻉ ﺍﳌﺘﻐﲑﺍﺕ ﻫﻲ:
١,١,٣,١ ﻣﺘﻐﲑ ﺍﻷﻋﺪﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ :int
ﻧﻘﻮﻡ ﺑﺎﻹﻋﻼﻥ ﻋﻦ ﻣﺘﻐﲑ ﻣﻦ ﻧﻮﻉ ﺍﻷﻋﺪﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ ﺑﻜﺘﺎﺑﺔ ﺍﻟﻜﻠﻤﺔ intﰲ ﻣﻜﺎﻥ ،Variable_Typeﺣﻴﺚ ﻳﺄﺧﺬ ﻣﺘﻐﲑ
ﻣﻦ ﻧﻮﻉ Integerﻣﺴﺎﺣﺔ ﻗﺪﺭﻫﺎ ٢ ﺑﺎﻳﺖ ﻭ ﺍﻟﱵ ﺗﺴﺎﻭﻱ ٦١ ﺑﺖ ﻭ ﺗﺴﺎﻭﻱ ٦٣٥٥٦ ﺍﺣﺘﻤﺎﻝ، ﺃﻱ ﺃﻥ ﺃﻗﺼﻰ ﻗﻴﻤﺔ ﳝﻜﻦ
ﺃﻥ ﳛﻤﻠﻬﺎ ﺍﳌﺘﻐﲑ ﻫﻲ ٥٣٥٥٦، ﺍﺑﺘﺪﺍﺀ ﻣﻦ ﺍﻟﺼﻔﺮ، ﺃﻭ ﺍﺑﺘﺪﺍﺀ ﻣﻦ ٨٦٧،٢٣- ﺇﱃ ٧٦٧،٢٣ ﰲ ﺣﺎﻟـﺔ ﺿـﻢ ﺍﻷﻋـﺪﺍﺩ
ﺍﻟﺴﺎﻟﺒﺔ
...
ﻣﺜﺎﻝ:
>#include
2Eﺇﱃ 83+
...
4Eﻣﺜﺎﻝ:
>#include
0 = float Variable_Name
ﺍﻟﱪﻧﺎﻣﺞ ٢,٣,١: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺘﻐﲑ ﻣﻦ ﻧﻮﻉ ﻋﺪﺩ ﺣﻘﻴﻘﻲ
}
5
6
٣,١,٣,١ ﻣﺘﻐﲑ ﺍﻷﻋﺪﺍﺩ ﺍﳊﻘﻴﻘﻴﺔ :double
doubleﻫﻲ ﺿﻌﻒ ،floatﻭ ﻳﺘﻢ ﺍﻹﻋﻼﻥ ﻋﻨﻬﺎ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﻜﻠﻤﺔ ،doubleﺣﻴﺚ ﺣﺠﻤﻬﺎ ٨ ﺑﺎﻳﺖ ﻭ ﺗﺒﺪﺃ ﻣـﻦ
803- 2
...
1
...
h
)(main
{
;0
...
ﻣﺜﺎﻝ:
>#include
ﻣﺜﺎﻝ:
>#include
ASCII
ﻣﺜﺎﻝ:
>#include
ﻭ ﻻﺳﻢ ﺍﳌﺘﻐﲑ ﺣﺪﻭﺩ ﻻ ﳚﺐ ﲡﺎﻭﺯﻫﺎ ﻭ ﻫﻲ:
§
§
§
§
§
§
ﺃﻥ ﻻ ﻳﺘﺠﺎﻭﺯ ﺍﺳﻢ ﺍﳌﺘﻐﲑ ﺃﻛﺜﺮ ﻣﻦ ١٣ ﺣﺮﻑ
...
ﺃﻥ ﻻ ﻳﻜﻮﻥ ﺍﺳﻢ ﺍﳌﺘﻐﲑ ﳛﺘﻮﻱ ﻋﻠﻰ ﻣﺆﺛﺮﺍﺕ ﻣﺜﻞ ﺍﳉﻤﻊ ﻭ ﺍﻟﻄﺮﺡ ﻭ
...
)ﺑﺎﺳﺘﺜﻨﺎﺀ ﺍﻟﺮﻣﺰ _(
...
ﺃﻥ ﻻ ﻳﻜﻮﻥ ﺍﺳﻢ ﺍﳌﺘﻐﲑ ﻣﻦ ﺃﲰﺎﺀ ﺍﻟﻜﻠﻤﺎﺕ ﺍﶈﺠﻮﺯﺓ
...
floatﻭ ﻗﻴﻤﺔ ﺍﳌﺘﻐﲑ
ﳝﻜﻦ ﺃﻥ ﻧﻌﻄﻴﻬﺎ ﻟﻪ ﻣﺒﺎﺷﺮﺓ ﺑﻌﺪ ﺍﻹﻋﻼﻥ ﻋﻨﻪ، ﺃﻭ ﻧﻘﻮﻡ ﺑﺎﻹﻋﻼﻥ ﻋﻨﻪ ﻭ ﻧﻀﻊ ﺑﻪ ﻗﻴﻤﺔ ﻓﻴﻤﺎ ﺑﻌﺪ)ﺃﻭ ﻧﻀﻊ ﺑﻪ ﻗﻴﻤﺔ ﺇﺳﺘﻘﺒﻠﻨﺎ ﻣﻦ
ﺍﳌﺴﺘﺨﺪﻡ ﻣﺜﻼ(
...
h
)(main
{
;5 = int Var
;)printf("%d\n", Var
}
ﺍﻟﱪﻧﺎﻣﺞ ٧,٣,١: ﻃﺮﻳﻘﺔ ﻃﺒﺎﻋﺔ ﳏﺘﻮﻯ ﻣﺘﻐﲑ ﻣﻦ ﻧﻮﻉ ﻋﺪﺩ ﺻﺤﻴﺢ
1
2
3
4
5
6
7
8
ﰲ ﻫﺬﺍ ﺍﳌﺜﺎﻝ، ﰲ ﺍﻟﺴﻄﺮ ﺍﳋﺎﻣﺲ ﰎ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺘﻐﲑ ﺑﺎﺳﻢ Varﻭ ﻣﻦ ﻧﻮﻉ ) intﻋﺪﺩ ﺻﺤﻴﺢ( ﻭ ﺑﻪ ﺍﻟﻘﻴﻤـﺔ ٥، ﻭ ﰲ
ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ ﺍﺳﺘﻌﻤﻠﻨﺎ ﺍﻟﺪﺍﻟﺔ printfﻟﻄﺒﺎﻋﺔ ﻗﻴﻤﺔ ﺍﳌﺘﻐﲑ ،Varﻭ ﺗﻮﺟﺪ ﻃﺮﻕ ﺃﺧﺮﻯ ﻹﻋﻄﺎﺀ ﻟﻠﻤﺘﻐﲑﺍﺕ ﻗﻴﻢ، ﺳـﺄﻋﻄﻲ
ﻃﺮﻳﻘﺘﲔ، ﺍﻷﻭﱃ ﻫﻲ ﺍﻹﻋﻼﻥ ﻋﻦ ﺍﳌﺘﻐﲑ ﰲ ﺳﻄﺮ ﰒ ﺇﻋﻄﺎﺀﻩ ﻗﻴﻤﺔ ﰲ ﺳﻄﺮ ﺁﺧﺮ ﻣﺜﻞ:
>#include
h
)(main
{
;5 = 1_int Var
;1_int Var_2 = Var
;)2_printf("%d\n", Var
ﺍﻟﱪﻧﺎﻣﺞ ٩,٣,١: ﻃﺮﻳﻘﺔ ﲢﺪﻳﺚ ﻗﻴﻤﺔ ﻣﺘﻐﲑ ﻣﻌﻄﺎﺓ ﻣﻦ ﻣﺘﻐﲑ ﺁﺧﺮ
}
1
2
3
4
5
6
7
8
9
ﻣﺜﺎﻝ ﺁﺧﺮ:
>#include
ﻭ ﻧﻔﺲ ﺍﻟﻄﺮﻕ ﺍﻟﺴﺎﺑﻘﺔ ﳝﻜﻦ ﺇﺳﺘﻌﻤﺎﳍﺎ ﻣﻊ ﻣـﺘﻐﲑﺍﺕ
ﻣﻦ ﻧﻮﻉ floatﻭ shortﻭ ،longﺃﻣﺎ ﺍﳌﺘﻐﲑ charﻓﻄﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﻟﻪ ﻟﻴﺴﺖ ﳐﺘﻠﻔﺔ ﻛﺜﲑ، ﺣﻴﺚ ﳝﻜﻨﻨﺎ ﺃﻳﻀﺎ ﺃﻥ ﻧﻌﻄﻴﻪ
ﻋﺪﺩ ﺑﺪﻝ ﺍﳊﺮﻑ ﺣﻴﺚ ﻋﻨﺪ ﻃﺒﺎﻋﺘﻪ ﻻ ﻳﻄﺒﻊ ﻋﺪﺩﺍ، ﺇﳕﺎ ﺍﳊﺮﻑ ﺍﻟﺬﻱ ﳛﻤﻞ ﺫﻟﻚ ﺍﻟﺮﻗﻢ ﰲ ﺟﺪﻭﻝ ،ASCIIﻭ ﻟﻜﻲ ﺗﻔﻬـﻢ
ﻃﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﻝ ﻣﺘﻐﲑﺍﺕ ﻣﻦ ﻧﻮﻉ charﺇﻟﻴﻚ ﺍﳌﺜﺎﻝ ﺍﻟﺘﺎﱄ:
>#include
h
)(main
{
;79 = char ch
;)printf("%c\n", ch
ﺍﻟﱪﻧﺎﻣﺞ ٢١,٣,١: ﻃﺮﻳﻘﺔ ﻃﺒﺎﻋﺔ ﺣﺮﻑ ﺑﺎﻹﻋﺘﻤﺎﺩ ﻋﻠﻰ ﺭﻗﻤﻪ ﰲ ﺟﺪﻭﻝ ﺃﺳﻜﻲ
}
1
2
3
4
5
6
7
8
ﻭ ﻛﻤﺎ ﻗﻠﻨﺎ ﺳﺎﺑﻘﺎ ﺃﻥ ﺃﻗﺼﻰ ﻗﻴﻤﺔ ﳝﻜﻦ ﺃﻥ ﳛﻤﻠﻬﺎ ﻣﺘﻐﲑ ﻣﻦ ﻧﻮﻉ charﻫﻲ ٥٥٢ ﺍﺑﺘﺪﺍﺀ ﻣﻦ ﺍﻟﺼﻔﺮ، ﻭ ﻛﻞ ﺭﻗـﻢ ﳝﺜـﻞ
ﺑﺮﻣﺰ
...
h
)(main
{
;5 = signed Num
;)printf("%d\n", Num
}
ﺍﻟﱪﻧﺎﻣﺞ ٣١,٣,١: ﻣﺘﻐﲑ ﺫﺍﺕ ﺇﺷﺎﺭﺓ
1
2
3
4
5
6
7
8
ﻫﺬﺍ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﺘﻐﲑﺍﺕ ﺍﻟﱵ ﲢﺘﻮﻱ ﻋﻠﻰ ﺃﻋﺪﺍﺩ ﻣﻮﺟﺒﺔ ﻭ ﺃﻋﺪﺍﺩ ﺳﺎﻟﺒﺔ، ﺃﻣﺎ ﰲ ﺣﺎﻟﺔ ﺃﺭﺩﻧﺎ ﺃﻋﺪﺍﺩ ﻣﻮﺟﺒﺔ ﻓﻘﻂ ﻓﺴﻨـﺴﺘﻌﻤﻞ
ﺍﻟﻜﻠﻤﺔ unsignedﻗﺒﻞ ﺍﺳﻢ ﺍﳌﺘﻐﲑ، ﻣﺜﻠﻤﺎ ﻫﻮ ﻣﻮﺿﺢ ﰲ ﺍﳌﺜﺎﻝ ﺍﻟﺘﺎﱄ:
>#include
ﻣﻼﺣﻈﺔ:
ﻋﻨﺪ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺘﻐﲑ ﻃﺒﻴﻌﻲ ﻣﺜﻼ charﻓﺈﻧﻪ ﺳﻴﺤﺘﻮﻱ ٦٥٢ ﺍﺣﺘﻤﺎﻝ ﻛﻤﺎ ﻗﻠﻨﺎ ﺳﺎﺑﻘﺎ،ﺣﻴﺚ ﳝﻜﻦ ﺃﻥ ﻳﺒﺪﺃ ﻣﻦ ٠ ﺇﱃ
٥٥٢ ﰲ ﺣﺎﻟﺔ ﻋﺪﻡ ﺍﳊﺎﺟﺔ ﺇﱃ ﺃﻋﺪﺍﺩ ﺳﺎﻟﺒﺔ، ﻭ ﳝﻜﻦ ﺃﻳﻀﺎ ﺃﻥ ﻳﺒﺪﺃ ﻣﻦ ٨٢١- ﺇﱃ ٧٢١ ﰲ ﺣﺎﻟﺔ ﺍﺳﺘﻌﻤﺎﻝ ﺃﻋﺪﺍﺩ ﺳﺎﻟﺒﺔ،
ﻭ ﻟﻜﻲ ﺗﻌﺮﻑ ﺍﻟﺴﺒﺐ ﰲ ﺫﻟﻚ ﺇﻟﻴﻚ ﺍﻟﺸﺮﺡ:
ﻟﻜﻞ ﻣﺘﻐﲑ ﺣﺠﻤﻪ، ﻣﺜﻼ ﻣﺘﻐﲑ ﻣﻦ ﻧﻮﻉ charﺣﺠﻤﻪ ١ ﺑﺎﻳﺖ ﺃﻣﺎ intﻓﺤﺠﻤﻪ ﻫﻮ ٢ﺑﺎﻳﺖ، ﻭ ﻛﻤﺎ ﻧﻌﺮﻑ ﺃﻥ ١ ﺑﺎﻳـﺖ
ﻳﺴﺎﻭﻱ ٨ ﺑﺖ، ﺃﻱ ﺃﻥ ﻣﺘﻐﲑ ﻣﻦ ﻧﻮﻉ charﺣﺠﻤﻪ ٨ ﺑﺖ، ﻭ ١ ﺑﺖ ﻳﺴﺎﻭﻱ ﺇﻣﺎ ١ ﺃﻭ ٠ ﺣﻴﺚ ﻫﺬﺍ ﻳﻌﲏ ﺃﻥ ١ ﺑـﺖ
14
ﻟﺪﻳﻪ ﺍﺣﺘﻤﺎﻟﲔ )٠ ﺃﻭ ١(، ﺃﻣﺎ ٨ ﺑﺖ ﻓﻠﺪﻳﻬﺎ ٦٥٢ ﺍﺣﺘﻤﺎﻝ ﺗﺒﺪﺃ ﻣﻦ ٠ ﻭ ﺗﻨﺘﻬﻲ ﻋﻨﺪ ٥٥٢ ﺇﻥ ﱂ ﺗﻜﻦ ﲢﺘﻮﻱ ﻋﻠﻰ ﺃﻋﺪﺍﺩ
ﺳﺎﻟﺒﺔ، ﺃﻣﺎ ﰲ ﺣﺎﻟﺔ ﺃﺭﺩﻧﺎ ﺃﻋﺪﺍﺩ ﺳﺎﻟﺐ ﻓﺴﻴﺘﻢ ﺳﺤﺐ ١ ﺑﺖ ﻣﻦ ،٨ ﺃﻱ ﺳﻴﺼﺒﺢ ﺣﺠﻢ ﻣﺘﻐﲑ ﻣﻦ ﻧﻮﻉ ٧ charﺑﺖ ﺃﻣـﺎ
ﺍﻟﺒﺖ ﺍﻟﺜﺎﻣﻦ ﺳﻨﺘﺮﻛﻪ ﻟﻺﺷﺎﺭﺓ، ﻭ ﺳﻴﺤﻤﻞ ﺇﻣﺎ ﺍﻹﺷﺎﺭﺓ + ﺃﻭ ﺍﻹﺷﺎﺭﺓ -، ﻭ ٧ ﺑﺖ ﺗﺴﺎﻭﻱ ٨٢١ ﺍﺣﺘﻤﺎﻝ
...
h
)(main
{
;int num
;5 = num
;)printf("%d\n", num
;8 = num
;)printf("%d\n", num
ﺍﻟﱪﻧﺎﻣﺞ ٥١,٣,١: ﻃﺮﻳﻘﺔ ﲢﺪﻳﺚ ﻗﻴﻤﺔ ﻣﺘﻐﲑ
}
1
2
3
4
5
6
7
8
9
01
11
21
31
41
24
ﻫﻨﺎ ﺳﻴﺘﻢ ﺗﻐﲑ ﻗﻴﻤﺔ ﺍﳌﺘﻐﲑ numﻣﻦ ٥ ﺇﱃ ٨، ﻭ ﻫﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ ﺻﺤﻴﺢ
...
h
)(main
{
;const int num
;5 = num
;)printf("%d\n", num
;8 = num
;)printf("%d\n", num
ﺍﻟﱪﻧﺎﻣﺞ ٦١,٣,١: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺛﺎﺑﺖ ﻭ ﺍﻟﺘﺤﺪﻳﺚ ﰲ ﻗﻴﻤﺘﻪ
}
1
2
3
4
5
6
7
8
9
01
11
21
31
41
ﺍﻹﺿﺎﻓﺔ ﻣﻮﺟﻮﺩﺓ ﰲ ﺍﻟﺴﻄﺮ ﺍﳋﺎﻣﺲ، ﻭ ﻫﻲ ﺇﺿﺎﻓﺔ ﺍﻟﻜﻠﻤﺔ constﺇﱃ ﺍﳌﺘﻐﲑ int numﻭ ﺍﻟﱵ ﺗﻌﲏ ﺃﻥ ﺍﳌﺘﻐﲑ numﺛﺎﺑﺖ،
ﻭ ﻫﻨﺎ ﺍﻟﱪﻧﺎﻣﺞ ﻟﻦ ﻳﻌﻤﻞ ﻭ ﺍﻟﺴﺒﺐ ﻫﻮ ﺃﻧﻪ ﻻ ﳝﻜﻦ ﲢﺪﻳﺚ ﺍﻟﻘﻴﻤﺔ ﺍﻷﻭﱃ ﻟﺜﻮﺍﺑﺖ، ﻭ ﰲ ﻣﺜﺎﻟﻨﺎ ﺍﻟﺴﺎﺑﻘﺔ ﻻ ﺗﻮﺟﺪ ﻗﻴﻤﺔ ﻟﻠﻤﺘﻐﲑ
numﺑﻌﺪﻣﺎ ﺃﻥ ﰎ ﺍﻹﻋﻼﻥ ﻋﻨﻪ، ﻭ ﳚﺐ ﺩﺍﺋﻤﺎ ﺇﻋﻄﺎﺀ ﻗﻴﻢ ﻟﺜﻮﺍﺑﺖ ﻣﺒﺎﺷﺮﺓ ﺑﻌﺪ ﺍﻹﻋﻼﻥ ﻋﻨﻬﺎ ﻭ ﺇﻻ ﺳﺘﻜﻮﻥ ﻋﺒﺎﺭﺓ ﻋﻦ ﺛﻮﺍﺑﺖ
ﺫﺍﺕ ﺃﻋﺪﺍﺩ ﻋﺸﻮﺍﺋﻴﺔ ﺛﺎﺑﺘﺔ ﻻ ﳝﻜﻦ ﺍﻟﺘﺤﺪﻳﺚ ﻓﻴﻬﺎ، ﻭ ﻫﺬﺍ ﺍﳌﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ ﺑﻌﺪ ﺍﻟﺘﺼﺤﻴﺢ:
>#include
h
)(main
{
;5 = int const num
;)printf("%d\n", num
ﺍﻟﱪﻧﺎﻣﺞ ٨١,٣,١: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺛﺎﺑﺖ )٢(
}
1
2
3
4
5
6
7
8
34
ﻭ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻝ ﻧﻔﺲ ﺃﻧﻮﺍﻉ ﺍﳌﺘﻐﲑﺍﺕ ﻋﻠﻰ ﺍﻟﺜﻮﺍﺑﺖ
...
h
5 #define num
)(main
{
;)printf("%d\n", num
}
1
2
3
4
5
6
7
8
ﺍﻟﱪﻧﺎﻣﺞ ٩١,٣,١: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺛﺎﺑﺖ )٣(
ﰎ ﺍﻹﻋﻼﻥ ﻋﻦ ﺍﻟﺜﺎﺑﺖ numﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﻟﺚ، ﰒ ﻃﺒﺎﻋﺔ ﻗﻴﻤﺘﻪ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ
...
٦,٣,١ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ:
١
...
block
٣
...
٤
...
٦
...
ﳚﺐ ﺍﳊﺮﺹ ﻋﻠﻰ ﺃﻥ ﺑﲔ ﻧﻮﻉ ﺍﳌﺘﻐﲑ ﻭ ﺍﺳﻢ ﺍﳌﺘﻐﲑ ﻣﺴﺎﻓﺔ ﻭﺍﺣﺪﺓ ﻋﻠﻰ ﺍﻷﻗﻞ
...
ﻻ ﳝﻜﻦ ﺗﻐﲑ ﺍﺳﻢ ﻣﺘﻐﲑ ﺃﻭ ﺛﺎﺑﺖ
...
44
٧,٣,١ ﲤﺎﺭﻳﻦ:
١
...
٣
...
٥
...
ﻣﺎﺫﺍ ﳛﺪﺙ ﺇﻥ ﺃﻋﻄﲔ ﳌﺘﻐﲑ ﻣﻦ ﻧﻮﻉ intﻗﻴﻤﺔ ﺃﻛﺜﺮ ﻣﻦ ٥٣٥٥٦ ؟
ﺃﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮﻡ ﺑﻄﺒﺎﻋﺔ ﺍﳊﺮﻑ Aﺑﺪﻝ ﺍﻟﺮﻗﻢ ٥٦، ﺑﺪﻭﻥ ﺍﺳﺘﺨﺪﺍﻡ ﻣﺘﻐﲑﺍﺕ ﺃﻭ ﺛﻮﺍﺑﺖ
...
char
ﺃﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﺑﻪ ﺛﻼﺛﺔ ﻣﺘﻐﲑﺍﺕ، ﺍﳌﺘﻐﲑ ﺍﻷﻭﻝ ﺑﻪ ﺍﻟﻘﻴﻤﺔ ٨١ ﻭ ﺍﻟﺜﺎﱐ ٩٨، ﺃﻣﺎ ﺍﻟﺜﺎﻟﺚ ﻳﻜﻮﻥ ﺍﻟﻨﺎﺗﺞ ﺍﳊﺎﺻﻞ ﺑـﲔ
ﺍﳌﺘﻐﲑ ﺍﻷﻭﻝ ﻭ ﺍﻟﺜﺎﱐ ﰲ ﻛﻞ ﻣﻦ ﺍﳉﻤﻊ، ﺍﻟﻄﺮﺡ، ﺍﻟﻘﺴﻤﺔ ﻭ ﺍﻟﻀﺮﺏ
...
54
ﺍﻟﺘﻌﻠﻴﻘﺎﺕ ﻫﻲ ﳎﻤﻮﻋﺔ ﻣﻦ ﺳﻼﺳﻞ ﻧﺼﻴﺔ ﻧﺴﺘﻌﻤﻠﻬﺎ ﻟﺘﻮﺿﻴﺢ ﺃﻭﺍﻣﺮ ﰲ ﻣﺼﺎﺩﺭ ﺑﺮﺍﳎﻨﺎ، ﻭ ﳝﻜﻦ ﺃﻥ ﲢﺘـﻮﻱ ﺗﻠـﻚ
ﺍﻟﻨﺼﻮﺹ ﻋﻠﻰ ﺃﺭﻗﺎﻡ، ﺃﺣﺮﻑ، ﺃﻭ ﺭﻣﻮﺯ ﻳﻘﻮﻡ ﺍﳌﺘﺮﺟﻢ ﺑﺘﺠﺎﻫﻠﻬﺎ
...
٢,٤,١ ﺃﻧﻮﺍﻉ ﺍﻟﺘﻌﻠﻴﻘﺎﺕ:
ﻳﻮﺟﺪ ﻧﻮﻋﲔ ﻣﻦ ﺍﻟﺘﻌﻠﻴﻘﺎﺕ ﳘﺎ:
١,٢,٤,١ ﺍﻟﺘﻌﻠﻴﻘﺎﺕ ﺑﺎﻟﻨﺼﻮﺹ ﺍﻟﻄﻮﻳﻠﺔ:
ﺍﻟﺘﻌﻠﻴﻘﺎﺕ ﺑﺎﻟﻨﺼﻮﺹ ﺍﻟﻄﻮﻳﻠﺔ ﻫﻲ ﻧﺼﻮﺹ ﺎ ﺃﻛﺜﺮ ﻣﻦ ﺳﻄﺮ، ﻭ ﻃﺮﻳﻘﺔ ﺍﺳﺘﺨﺪﺍﻣﻬﺎ ﻫﻲ ﲢﺪﻳﺪ ﺑﺪﺍﻳﺔ ﺍﻟﺘﻌﻠﻴﻖ ﻭ ﺍﻟﱵ ﺗﺒﺪﺃ
ﺑـ /* ﻭ ﻧﻀﻊ */ ﰲ ﺎﻳﺔ ﺍﻟﺘﻌﻠﻴﻖ، ﻣﺜﺎﻝ:
*/
:My First Program
!Hello, World
/*
/*#include
h> //Standart Input Output Header File
)(main
//main function
{//Start of main function
!printf("Hello, World!");//to print Hello, World
}//End of main function
ﺍﻟﱪﻧﺎﻣﺞ ٢,٤,١: ﺍﻟﺘﻌﻠﻴﻘﺎﺕ ﺍﻟﺴﻄﺮﻳﺔ
4
5
6
7
8
9
ﻭ ﻫﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ ﻟﻴﺴﺖ ﻣﻦ ﻃﺮﻕ ﻟﻐﺔ Cﺍﻟﻘﻴﺎﺳﻴﺔ ﰲ ﺍﻟﺘﻌﻠﻴﻘﺎﺕ، ﻭ ﻟﻜﻦ ﺍﻟﻜﺜﲑ ﻣﻦ ﺍﳌﺘﺮﲨﺎﺕ ﺗﺪﻋﻤﻬﺎ
...
ﰲ ﺍﻟﺘﻌﻠﻴﻘﺎﺕ ﺑﺎﻟﻨﺼﻮﺹ ﺍﻟﻄﻮﻳﻠﺔ ﺇﻥ ﱂ ﻳﺘﻢ ﲢﺪﻳﺪ ﺎﻳﺔ ﺍﻟﺘﻌﻠﻴﻖ ﻓﺈﻥ ﻛﻞ ﻣﺎ ﻫﻮ ﺑﻌﺪ ﺑﺪﺍﻳﺔ ﺍﻟﺘﻌﻠﻴﻖ ﻳﻌﺘﱪ ﺗﻌﻠﻴﻖ، ﻭ ﻫﺬﺍ
ﻣﺜﺎﻝ ﺗﻮﺿﻴﺤﻲ:
/*comment
>#include
٢
...
h
)(main
{
;)"!printf("Hello, World
}
ﺍﻟﱪﻧﺎﻣﺞ ٥,٤,١: ﺍﳋﻄﺄ ٢
ﻫﻨﺎ ﺳﻴﺨﱪﻙ ﺍﳌﺘﺮﺟﻢ ﻋﻠﻰ ﺃﻥ ﺍﻟﺪﺍﻟﺔ printfﻏﲑ ﻣﻌﺮﻓﺔ ﺳﺎﺑﻘﺎ، ﻭ ﻫﺬﺍ ﺍﳋﻄﺄ ﺳﺒﺒﻪ ﻫﻮ ﺟﻌﻞ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ
ﺍﳋﺎﺻﺔ ﺑﻀﻢ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ stdio
...
stdio
...
1
2
3
4
5
6
#include
84
ﰲ ﺍﻟﺪﺭﻭﺱ ﺍﻟﺴﺎﺑﻘﺔ ﱂ ﻧﺪﺭﺱ ﺇﻻ ﺍﻹﺧﺮﺍﺝ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﺪﺍﻟﺔ ،printfﺍﻵﻥ ﺳﻨﻌﺮﻑ ﻛﻴﻔﻴﺔ ﺍﻹﺩﺧﺎﻝ ﺑﻮﺍﺳﻄﺔ ﺍﻟﺪﺍﻟﺔ
ﺩﻭﺍﻝ ﺧﺎﺻﺔ ﺑﺎﻹﺧﺮﺍﺝ، ﺣﺎﻟﻴﺎ ﺳﻨﺮﻯ ﺍﻟﺪﺍﻟﺔ ،scanfﺍﻟﺘﺸﺎﺑﻪ ﻛﺒﲑ ﺟﺪﺍ ﺑﲔ ﺍﻟـﺪﺍﻟﻴﺘﲔ printfﻭ ،scanfﻓﻘـﻂ ﺍﻷﻭﱃ
ﺧﺎﺻﺔ ﺑﺎﻹﺧﺮﺍﺝ ﻭ ﺍﻟﺜﺎﻧﻴﺔ ﺧﺎﺻﺔ ﺑﺎﻹﺩﺧﺎﻝ
...
keyboardﺍﻵﻥ ﺳﻨﻘﻮﻡ ﺑﻜﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﻳﻄﻠﺐ ﻣﻦ ﺍﳌﺴﺘﺨﺪﻡ ﺇﺩﺧﺎﻝ ﻗﻴﻤﺔ ﰒ ﻧﻌﻄﻴﻪ ﺍﻟﻘﻴﻤﺔ ﺍﻟﱵ ﻗﺎﻡ ﺑﺈﺩﺧﺎﳍﺎ:
/*اﻹدﺧﺎل*/
>#include
، ﺇﻻ ﻫﻨـﺎ ﺗﻜـﻮﻥ ﻗﻴﻤـﺔ
usr_valﻗﺪ ﺃﺻﺒﺤﺖ ﺍﻟﻘﻴﻤﺔ ﺍﻟﱵ ﺃﺩﺧﻠﻬﺎ ﺍﳌﺴﺘﺨﺪﻡ ﰒ ﻧﻘﻮﻡ ﺑﻄﺒﺎﻋﺘﻬﺎ ﻋﻠﻰ ﺍﻟﺸﺎﺷﺔ
...
h
)(main
{
;char usr_char
;)" :printf("Enter a character
;)scanf("%c", &usr_char
;)printf("Your character is: %c\n", usr_char
}
1
2
3
4
5
6
7
8
9
01
94
ﺍﻟﱪﻧﺎﻣﺞ ٢,٥,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ scanfﻹﺩﺧﺎﻝ ﺣﺮﻑ
ﺍﻵﻥ ﺳﻨﻘﻮﻡ ﺑﻜﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ ﻳﻄﻠﺐ ﻣﻦ ﺍﳌﺴﺘﺨﺪﻡ ﺇﺩﺧﺎﻝ ﻗﻴﻤﺔ، ﰒ ﻳﻄﻠﺐ ﻣﻨﻪ ﺇﺩﺧﺎﻝ ﻗﻴﻤﺔ ﺛﺎﻧﻴﺔ، ﻭ ﻧﻌﻄﻴﻪ ﺍﻟﻨﺘـﺎﺋﺞ ﲜﻤﻴـﻊ
ﺍﳌﺆﺛﺮﺍﺕ ﺍﻷﺳﺎﺳﻴﺔ:
>#include
h
1
2
3
4
5
6
7
8
9
01
11
21
31
41
)(main
{
;2int val1, val
;)" :printf("1)Enter a value
;)1scanf("%d", &val
;)" :printf("2)Enter a value
;)2scanf("%d", &val
;)2val1+val
;)2val1-val
;)2val1*val
;)2val1/val
,2val
,2val
,2val
,2val
,1val
,1val
,1val
,1val
,"%d\n
,"%d\n
,"%d\n
,"%d\n
=
=
=
=
%d
%d
%d
%d
+
*
/
printf("%d
printf("%d
printf("%d
printf("%d
}
ﺍﻟﱪﻧﺎﻣﺞ ٣,٥,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ scanfﻹﺩﺧﺎﻝ ﻗﻴﻤﺔ ﺻﺤﻴﺤﺔ )٢(
ﺍﳌﺜﺎﻝ ﻭﺍﺿﺢ، ﻗﻤﻨﺎ ﺑﺎﻹﻋﻼﻥ ﻋﻦ ﻣﺘﻐﲑﻳﻦ ﰲ ﺍﻟﺴﻄﺮ ﺍﳋﺎﻣﺲ، ﰒ ﻃﻠﺒﻨﺎ ﻣﻦ ﺍﳌﺴﺘﺨﺪﻡ ﺇﺩﺧﺎﻝ ﻗﻴﻤﺔ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ ﻭ ﻗﻤﻨﺎ
ﺑﺄﺧﺬ ﺍﻟﻘﻴﻤﺔ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﻣﻦ، ﻭ ﺑﻌﺪﻫﺎ ﻃﻠﺒﻨﺎ ﻣﻦ ﺍﳌﺴﺘﺨﺪﻡ ﺇﺩﺧﺎﻝ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺜﺎﻧﻴﺔ ﰒ ﺃﺧﺬﻧﺎ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺜﺎﻧﻴﺔ ﰲ ﺍﻟﺴﻄﺮ ﺍﳊﺎﺩﻱ
ﻋﺸﺮ، ﰒ ﻃﺒﻌﻨﺎ ﺍﻟﻨﺘﺎﺋﺞ ﰲ ﻛﻞ ﻣﻦ ﺍﻟﺴﻄﺮ ٣١، ٤١، ٥١ ﻭ ٦١
...
١,٥,١ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ:
١
...
٢
...
ﳚﺐ ﺍﻻﻧﺘﺒﺎﻩ ﺇﱃ ﻋﺪﺩ ﺍﳌﺘﻐﲑﺍﺕ ﺍﳌﺮﺍﺩ ﻓﺤﺼﻬﺎ، ﳚﺐ ﺃﻥ ﻳﻜﻮﻥ ﻋﺪﺩ ﺭﻣﻮﺯ ﺃﻧﻮﺍﻉ ﺍﳌﺘﻐﲑﺍﺕ ﻧﻔﺴﻪ ﻋﺪﺩ ﺍﳌـﺘﻐﲑﺍﺕ
ﺍﳌﺮﺍﺩ ﻓﺤﺼﻬﺎ
...
ﺃﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻄﻠﺐ ﻣﻦ ﺍﳌﺴﺘﺨﺪﻡ ﺇﺩﺧﺎﻝ ﺍﳊﺮﻑ ﺍﻷﻭﻝ ﻭ ﺍﻷﺧﲑ ﻣﻦ ﺍﲰﻪ ﰒ ﻳﻘﻮﻡ ﺍﻟﱪﻧﺎﻣﺞ ﺑﺈﺧﺒﺎﺭ ﺍﳌﺴﺘﺨﺪﻡ ﺃﻥ
ﺇﺳﻢ ﻳﺒﺪﺃ ﺑـ "ﺍﳊﺮﻑ ﺍﻷﻭﻝ ﺍﻟﺬﻱ ﺃﺩﺧﻠﻪ ﺍﳌﺴﺘﺨﺪﻡ" ﻭ ﻳﻨﺘﻬﻲ ﺑﺎﳊﺮﻑ "ﺍﳊﺮﻑ ﺍﻷﺧﲑ ﺍﻟﺬﻱ ﺃﺩﺧﻠﻪ ﺍﳌﺴﺘﺨﺪﻡ"
...
ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﺠﻤﻊ، ﺍﻟﻄﺮﺡ، ﺍﻟﻘﺴﻤﺔ ﻭ ﺍﻟﻀﺮﺏ ﻓﻘﺪ ﺃﺧﺬﻧﺎ ﺃﻣﺜﻠﺔ ﻋﻨﻬﺎ ﺳﺎﺑﻘﺎ
...
ﻣﺆﺛﺮ ﺍﻟﺰﻳﺎﺩﺓ ﻳﻌﲏ ﺯﻳﺎﺩﺓ ﺭﻗﻢ ﻭﺍﺣﺪ ﺇﱃ ﺍﳌﺘﻐﲑ ﺍﻟﺬﻱ ﻧﺮﻳﺪ ﺍﻟﺰﻳﺎﺩﺓ ﺇﻟﻴﻪ، ﻭ ﻫﺬﺍ ﻣﺜﺎﻝ
ﻳﻮﺿﺢ ﺫﻟﻚ:
>#include
ﻭ
ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻝ ﻃﺮﻕ ﺃﺧﺮﻯ ﻣﺜﻞ:
;)printf("Inc = %d\n", Inc
1
2
25
;1+Inc = Inc
;)printf("Inc = %d\n", Inc
;1 =+ Inc
;)printf("Inc = %d\n", Inc
3
4
5
6
7
8
9
ﺍﻟﱪﻧﺎﻣﺞ ٢,٦,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﻣﺆﺛﺮ ﺍﻟﺰﻳﺎﺩﺓ )٢(
ﺍﻟﻄﺮﻳﻘﺔ ﺍﻷﻭﱃ ﻫﻲ 1+ Inc = Incﻭ ﺍﻟﱵ ﻣﻮﺟﻮﺩ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﻟﺚ، ﻫﻲ ﻣﻄﺎﺑﻘﺔ ﲤﺎﻣﺎ ﻟـ ++ Incﻭ ﻟﻜﻦ ﰲ ﺍﻟـﺴﺎﺑﻘﺔ
ﳝﻜﻦ ﺃﻥ ﻧﻘﻮﻡ ﺑﺰﻳﺎﺩﺓ ﺃﻛﺜﺮ ﻣﻦ ١ ﻳﻌﲏ ﺇﻥ ﻛﺘﺒﻨﺎ 3+ Inc = Incﻓﺴﻴﺘﻢ ﺍﻹﺿﺎﻓﺔ ﺇﱃ ﺍﳌﺘﻐﲑ Incﺛﻼﺛﺔ ﺃﺭﻗـﺎﻡ، ﻛـﺬﻟﻚ
ﺍﻟﻄﺮﻳﻘﺔ ﺍﻟﺜﺎﻧﻴﺔ 1 =+ ،Incﻫﻲ ﻣﺜﻞ 1+ Inc = Incﲤﺎﻡ
...
ﻭ ﺍﻟﻔﺮﻕ ﺑﲔ ﺃﻥ ﻳﻜﻮﻥ ﺍﳌﺆﺛﺮﻳﻦ ++ ﰲ ﺑﺪﺍﻳﺔ ﺍﺳﻢ
ﺍﳌﺘﻐﲑ ﺃﻭ ﺎﻳﺘﻪ ﻫﻮ ﻣﻮﺿﺢ ﰲ ﺍﳌﺜﺎﻝ ﺍﻟﺘﺎﱄ:
>#include
ﻭ ﰲ ﺍﻟﺴﻄﺮ ﺍﳊـﺎﺩﻱ
ﻋﺸﺮ ﺳﻴﺘﻢ ﺗﻨﻔﺬ ﻣﺆﺛﺮ ﺍﻟﺘﺰﺍﻳﺪ ﺃﻭﻻ ﱘ ﻃﺒﺎﻋﺔ ﺍﻟﻨﺘﻴﺠﺔ ﺍﻟﱵ ﻫﻲ ٢، ﻭ ﻛﺬﻟﻚ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﱐ ﻋﺸﺮ ﺳﻴﺘﻢ ﻃﺒﺎﻋﺔ ﺍﻟﻌﺪﺩ ٢
...
h
)(main
1
2
3
35
{
;int Dec
;2 = Dec
;)printf("Dec = %d\n", Dec
;--Dec
;)printf("Dec = %d\n", Dec
;--Dec
;)printf("Dec = %d\n", Dec
ﺍﻟﱪﻧﺎﻣﺞ ٤,٦,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﻣﺆﺛﺮ ﺍﻟﻨﻘﺼﺎﻥ
}
4
5
6
7
8
9
01
11
21
31
41
51
61
71
ﻭ ﳝﻜﻦ ﺃﻳﻀﺎ ﺍﺳﺘﻌﻤﺎﻝ ﻧﻔﺲ ﺍﻟﻄﺮﻕ ﺍﻟﺴﺎﺑﻘﺔ ﰲ ﺍﻟﻨﻘﺼﺎﻥ:
;)printf("Dec = %d\n", Dec
;1-Dec = Dec
;)printf("Dec = %d\n", Dec
;1 =- Dec
;)printf("Dec = %d\n", Dec
ﺍﻟﱪﻧﺎﻣﺞ ٥,٦,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﻣﺆﺛﺮ ﺍﻟﻨﻘﺼﺎﻥ )٢(
1
2
3
4
5
6
7
8
9
٣,١,٦,١ ﻣﺆﺛﺮ ﺑﺎﻗﻲ ﺍﻟﻘﺴﻤﺔ )%(:
ﺃﻳﻀﺎ ﳝﻜﻦ ﺍﻋﺘﺒﺎﺭﻩ ﻣﻦ ﺍﳌﺆﺛﺮﺍﺕ ﺍﳌﻬﻤﺔ، ﻭ ﻃﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﻟﻪ ﺳﻬﻞ ﻓﻤﺜﻼ ﻟﻮ ﺃﺭﺩﻧﺎ ﺃﻥ ﳒﺪ ﺑﺎﻗﻲ ﺍﻟﻘﺴﻤﺔ ﺑﲔ ﺍﻟﻌـﺪﺩ ٥ ﻭ
ﺍﻟﻌﺪﺩ ٣ ﻧﻜﺘﺐ 3%5، ﻭ ﻫﺬﺍ ﻣﺜﺎﻝ ﺗﻮﺿﻴﺤﻲ:
>#include
h
1
45
)(main
{
;)3<5 ,"printf("%d\n
;)3==5 ,"printf("%d\n
;)3>5 ,"printf("%d\n
}
ﺍﻟﱪﻧﺎﻣﺞ ٧,٦,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﳌﺆﺛﺮﺍﺕ ﺍﻟﻌﻼﻗﻴﺔ
2
3
4
5
6
7
8
ﻫﻨﺎ ﺳﺘﺠﺪ ﻧﺘﺎﺋﺞ ﺍﻟﱪﻧﺎﻣﺞ:
٠: ﻷﻥ ﺍﻟﻌﺪﺩ ٥ ﻟﻴﺲ ﺃﻗﻞ ﻣﻦ ٣
...
١: ﻷﻥ ﺍﻟﻌﺪﺩ ٥ ﺃﻛﺒﲑ ﻣﻦ ٣
...
ﻭ
ﻳﻮﺟﺪ ﻛﺬﻟﻚ ﺍﳌﺆﺛﺮ ﺃﻛﱪ ﻣﻦ ﺃﻭ ﻳﺴﺎﻭﻱ ﻭ ﳝﺜﻞ ﰲ ﻟﻐﺔ Cﺑـ =>، ﻭ ﻣﺆﺛﺮ ﺃﺻﻐﺮ ﻣﻦ ﺃﻭ ﻳﺴﺎﻭﻱ ﺑــ =<، ﻭ ﺍﳌـﺆﺛﺮ ﻻ
ﻳﺴﺎﻭﻱ ﺑـ =!
...
h
)(main
{
;)3>5 && 3<5 ,"printf("%d\n
;)5==3 && 3==5 ,"printf("%d\n
;)3<5 && 3>5 ,"printf("%d\n
;)3>5 || 3<5 ,"printf("%d\n
;)5==3 || 3==5 ,"printf("%d\n
;)3<5 || 3>5 ,"printf("%d\n
1
2
3
4
5
6
7
8
9
01
11
21
55
;))3<5(! ,"printf("%d\n
;))3==5(! ,"printf("%d\n
;))3>5(! ,"printf("%d\n
ﺍﻟﱪﻧﺎﻣﺞ ٨,٦,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﳌﺆﺛﺮﺍﺕ ﺍﳌﻨﻄﻘﻴﺔ
}
31
41
51
61
ﻧﺘﺎﺋﺞ ﺍﻟﱪﻧﺎﻣﺞ ﻫﻲ:
٠: ﻷﻧﻪ ﺗﻮﺟﺪ ﻋﻼﻗﺔ ﺧﺎﻃﺌﺔ ﻭ ﻫﻲ 3<5
...
٠: ﻷﻧﻪ ﺗﻮﺟﺪ ﻋﻼﻗﺔ ﺧﺎﻃﺌﺔ ﻭ ﻫﻲ 3<5
...
٠: ﻷﻥ ﻛﻼ ﺍﻟﻌﻼﻗﺘﲔ ﺧﻄﺎﺀﺗﲔ
...
١: ﻷﻥ ٥ ﻟﻴﺴﺖ ﺃﺻﻐﲑ ﻣﻦ ٣
...
٠: ﻷﻥ ٥ ﺃﻛﱪ ﻣﻦ ٣
...
h
)(main
{
;)7<<1 ,"printf("%d\n
}
ﺍﻟﱪﻧﺎﻣﺞ ٩,٦,١: ﻣﺆﺛﺮ ﺍﻹﺯﺍﺣﺔ ﺇﱃ ﺍﻟﻴﺴﺎﺭ
ﻫﻨﺎ ﺍﻟﻨﺎﺗﺞ ﺳﻴﻜﻮﻥ ٨٢١، ﻭ ﺍﻟﺼﻮﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﺫﻟﻚ:
1
2
3
4
5
6
65
ﺍﻟﺸﻜﻞ ١,٦,١: ﺍﻹﺯﺍﺣﺔ ﺇﱃ ﺍﻟﻴﺴﺎﺭ
ﺍﳌﺆﺛﺮ ﺍﳌﻌﺎﻛﺲ ﻟﺴﺎﺑﻖ ﻫﻮ >>، ﻭ ﻳﺴﻤﻰ ﲟﺆﺛﺮ ﺍﻹﺯﺍﺣﺔ ﺇﱃ ﺍﻟﻴﻤﲔ ،Right Shiftﻭ ﻫﺬﺍ ﻣﺜﺎﻝ ﺗﻮﺿﻴﺤﻲ ﻟﻄﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﻟﻪ:
>#include
h
)"#define printer(str) printf(#str "\n
ﺍﻟﱪﻧﺎﻣﺞ ١١,٦,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﳌﺆﺛﺮ
)(main
{
;)printer(Hello
}
#
1
2
3
4
5
6
7
8
9
75
ﺍﳌﺆﺛﺮﻳﻦ ## ﻣﻌﺎ، ﺃﻳﻀﺎ ﻳﺘﻢ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﻤﺎ ﻣﻊ ﺍﻟﺘﻮﺟﻴﻪ ،#defineﻭ ﳝﻜﻦ ﺗﺴﻤﻴﺘﻬﻤﺎ ﺑﺎﻟـ Mergeﺃﻱ ﺍﻟﺪﻣﺞ، ﻣﺜﺎﻝ:
>#include
ﻧﺒﺪﺃ ﺑﺎﳌﺆﺛﺮ "ﺃﻭ" ORﻭ ﺍﻟﺬﻱ ﻫﻮ ﺍﻟﺮﻣﺰ | ﻭﺣﺪﻩ، ﻭ ﻗﻠﻨﺎ ﺳﺎﺑﻘﺎ ﺃﻥ ﺍﳌﺆﺛﺮ "ﺃﻭ" ﳛﺘﺎﺝ ﺇﱃ ﺷﺮﻁ ﻭﺍﺣﺪ ﺻـﺤﻴﺢ، ﺻـﻮﺭﺓ
ﺗﻮﺿﻴﺤﻴﺔ:
ﺍﻟﺸﻜﻞ ٣,٦,١: ﺇﺳﺘﻌﻤﺎﻝ ﺍﳌﺆﺛﺮ ﺃﻭ
| OR
ﺍﻟﻌﻤﻠﻴﺔ ﻫﻲ ﺇﺫﺍ ﻛﺎﻥ ﺑﺖ ﺑﻪ ﺍﻟﻘﻴﻤﺔ ٠ ﻳﻘﺎﺭﻥ ﻣﻊ ﺑﺖ ﺑﻪ ﻗﻴﻤﺔ ٠ ﻓﺴﻴﻜﻮﻥ ﺍﻟﻨﺎﺗﺞ ﺻﻔﺮ ﻷﻥ ﻛﻼ ﺍﻟﺒﺘﺎﺕ ﳛﺘﻮﻱ ﻋﻠﻰ ﺍﻟﻘﻴﻤـﺔ
٠ ﺃﻱ ﺧﻄﺄ، ﻭ ﺇﺫﺍ ﻛﺎﻥ ﺑﺖ ﺑﻪ ﺍﻟﻘﻴﻤﺔ ٠ ﻳﻘﺎﺭﻥ ﻣﻊ ﺑﺖ ﺑﻪ ﺍﻟﻘﻴﻤﺔ ١ ﻓﺴﻴﻜﻮﻥ ﺍﻟﻨﺎﺗﺞ ﻭﺍﺣﺪ ﻷﻧﻪ ﺗﻮﺟـﺪ ﺍﻟﻘﻴﻤـﺔ ١ ﺃﻱ
ﺻﺤﻴﺢ ﺣﻴﺚ ﻗﻠﻨﺎ ﺃﻥ ﺍﳌﺆﺛﺮ "ﺃﻭ" ﳛﺘﺎﺝ ﺇﱃ ﻗﻴﻤﺔ ﺻﺤﻴﺤﺔ ﻭﺍﺣﺪﺓ ﺣﱴ ﻳﻜﻮﻥ ﺍﻟﻨﺎﺗﺞ ﺻﺤﻴﺢ
...
h
)(main
{
/*int x = 1; /* 1 decimal = 00000001 Binary
;4|x = x
/*/* 4 decimal = 00000100 Binary
*/
/*= 00000101 Binary, x = 5 decimal
;)printf("x = %d\n", x
}
1
2
3
4
5
6
7
8
9
85
ﺍﻟﱪﻧﺎﻣﺞ ٣١,٦,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﳌﺆﺛﺮ ﺃﻭ
| OR
ﺑﻌﺪ ﻫﺬﺍ ﺍﳌﺆﺛﺮ ﻳﺄﰐ ﺍﳌﺆﺛﺮ "ﻭ" ANDﻭ ﻳﻜﻮﻥ ﺑﺈﺳﺘﺨﺪﺍﻡ ﺍﻟﺮﻣﺰ &، ﺻﻮﺭﺓ ﺗﻮﺿﻴﺤﻴﺔ:
ﺍﻟﺸﻜﻞ ٤,٦,١: ﺇﺳﺘﻌﻤﺎﻝ ﺍﳌﺆﺛﺮ ﻭ
& AND
ﳛﺘﺎﺝ ﺍﳌﺆﺛﺮ "ﻭ" ﺇﱃ ﺃﻥ ﺗﻜﻮﻥ ﻛﻼ ﺍﻟﻘﻴﻤﺘﲔ ﺻﺤﻴﺤﺘﲔ، ﺣﻴﺚ ﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺑﺖ ٠ ﻭ ﻗﻴﻤﺔ ﺍﻟﺒﺖ ﺍﻟﺜـﺎﱐ ٠ ﻓـﺴﻴﻜﻮﻥ
ﺍﻟﻨﺎﺗﺞ ٠ ﻷﻥ ﻛﻼ ﺑﺘﺎﺕ ﺧﺎﻃﺌﲔ، ﻭ ﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻤﺔ ﺑﺖ ١ ﻭ ﺍﻵﺧﺮ ٠ ﻓﺄﻳﻀﺎ ﺳﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ٠ ﺃﻱ ﺧﺎﻃﺌﺔ ﻷﻥ ﺍﳌـﺆﺛﺮ
"ﻭ" ﳛﺘﺎﺝ ﺇﱃ ﻗﻴﻤﺘﲔ ﺻﺤﻴﺤﺘﲔ، ﺃﻣﺎ ﺇﺫﺍ ﻛﺎﻥ ﺑﺖ ١ ﻭ ﺍﻵﺧﺮ ١ ﻓﺴﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ﻫﻨﺎ ١ ﺃﻱ ﺻﺤﻴﺢ
...
h
)(main
{
/*int x = 1; /* 1 decimal = 00000001 Binary
;4&x = x
/*/* 4 decimal = 00000100 Binary
*/
/*0 = = 00000000 Binary, x
;)printf("x = %d\n", x
}
ﺍﻟﱪﻧﺎﻣﺞ ٤١,٦,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﳌﺆﺛﺮ ﻭ
1
2
3
4
5
6
7
8
9
& AND
ﻭ ﺑﻌﺪ ﻫﺬﺍ ﺍﳌﺆﺛﺮ ﺳﻨﺮﻯ ﺍﳌﺆﺛﺮ ،XORﻭ ﻫﻮ ﻟﻴﺲ ﻛﺴﺎﺑﻘﻪ، ﻭ ﻟﻜﻨﻪ ﻣﺸﺎﺑﻪ ﻟﻠﻤﺆﺛﺮ ORﺇﻻ ﺃﻧﻪ ﺳﻴﻜﻮﻥ ﺍﻟﻨﺎﺗﺞ ٠ ﺇﺫﺍ ﻛـﺎﻥ
ﻛﻼ ﺍﻟﺒﺘﺎﺕ ﺑﻪ ﺍﻟﻘﻴﻤﺔ ١، ﻭ ﺫﻟﻚ ﻋﱪ ﺍﻟﺮﻣﺰ ^، ﺻﻮﺭﺓ ﺗﻮﺿﻴﺤﻴﺔ:
ﺍﻟﺸﻜﻞ ٥,٦,١: ﺇﺳﺘﻌﻤﺎﻝ ﺍﳌﺆﺛﺮ
^ XOR
95
ﻫﻨﺎ ﺇﺫﺍ ﻛﺎﻥ ﺑﺖ ﺑﻪ ﺍﻟﻘﻴﻤﺔ ٠ ﻭ ﺍﻟﺜﺎﱐ ﺑﻪ ﺍﻟﻘﻴﻤﺔ ٠ ﻓﺴﻴﻜﻮﻥ ﺍﻟﻨﺎﺗﺞ ٠، ﻭ ﺇﺫﺍ ﻛﺎﻥ ﺑﺖ ﺑﻪ ﻗﻴﻤﺔ ١ ﻭ ﺍﻵﺧﺮ ﺑـﻪ ﺍﻟﻘﻴﻤـﺔ ٠
ﻓﺴﻴﻜﻮﻥ ﺍﻟﻨﺎﺗﺞ ١، ﺃﻣﺎ ﺇﺫﺍ ﻛﺎﻥ ﻛﻼ ﺍﻟﺒﺘﺎﺕ ﺑﻪ ﺍﻟﻘﻴﻤﺔ ١ ﻓﺴﻴﻜﻮﻥ ﺍﻟﻨﺎﺗﺞ ٠ ﺃﻱ ﺧﺎﻃﺊ ﻭ ﻫﺬﺍ ﻫﻮ ﺍﻟﻔﺮﻕ ﺑﲔ ﻫﺬﺍ ﺍﳌﺆﺛﺮ ﻭ
ﻣﺆﺛﺮ
...
h
)(main
{
/*int x = 4; /* 4 decimal = 00000100 Binary
;4^x = x
/*/* 4 decimal = 00000100 Binary
*/
/*0 = = 00000000 Binary, x
;)printf("x = %d\n", x
}
ﺍﻟﱪﻧﺎﻣﺞ ٥١,٦,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﳌﺆﺛﺮ
1
2
3
4
5
6
7
8
9
^ XOR
ﻭ ﺃﺧﲑﺍ ﺍﳌﺆﺛﺮ "ﻻ" NOTﻋﱪ ﺍﻟﺮﻣﺰ ~، ﻭ ﻻ ﻳﺴﺘﻌﻤﻞ ﻫﺬﺍ ﺍﳌﺆﺛﺮ ﻟﻮﺣﺪﻩ، ﻭ ﻳﺴﺘﻌﻤﻞ ﺑﻜﺜﺮ ﻣﻊ ﺍﳌﺆﺛﺮ "ﻭ" ANDﻟﺘﺜﺒﻴﺖ ﺑﺖ
ﻣﺎ ﻋﻠﻰ ٠ ﺑﺪﻭﻥ ﺍﻟﺘﺄﺛﲑ ﻋﻠﻰ ﺑﺎﻗﻲ ﺍﻟﺒﺘﺎﺕ
...
h
)(main
{
/*int x = 5; /* 5 decimal = 101 Binary
/*x = x& ~4; /* 4 decimal = 100 Binary
*/
/*1 = = 001 Binary, x
;)printf("x = %d\n", x
}
٦,٦,١ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ:
ﺍﻟﱪﻧﺎﻣﺞ ٦١,٦,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﳌﺆﺛﺮ ﻻ
ﻻ ﺗﻮﺟﺪ ﺃﺧﻄﺎﺀ ﳏﺘﻤﻠﺔ ﰲ ﻫﺬﺍ ﺍﻟﺪﺭﺱ
...
ﻫﻞ ﳝﻜﻦ ﺃﻥ ﻧﻘﻮﻡ ﺑﺎﻟﺘﺰﺍﻳﺪ ﻭ ﺍﻟﺘﻨﺎﻗﺺ ﺩﺍﺧﻞ ﺍﻟﺪﺍﻟﺔ printf؟
٢
...
ﻣﺎﺫﺍ ﺗﻌﲏ ﻛﻞ ﻣﻦ && ﻭ || ﻭ ! ؟
~ NOT
1
2
3
4
5
6
7
8
9
06
ﺗﺴﺘﻌﻤﻞ ﺍﻟﻘﺮﺍﺭﺍﺕ )ﻭ ﳝﻜﻦ ﺗﺴﻤﻴﺘﻬﺎ ﺑﺎﳉﻤﻞ ﺍﻟﺸﺮﻃﻴﺔ( ﻟﻠﻤﻘﺎﺭﻧﺔ ﺑﲔ ﻋﻼﻗﺔ ﺣﻴﺚ ﺗﻜﻮﻥ ﺇﻣﺎ ﺻﺤﻴﺤﺔ ﺃﻭ ﺧﺎﻃﺌﺔ، ﰲ
ﻛﻞ ﻣﻦ ﺣﺎﻟﺔ ﳍﺎ ﺃﻭﺍﻣﺮ ﺧﺎﺻﺔ ﻧﻘﻮﻡ ﺑﺘﺤﺪﻳﺪﻫﺎ، ﻣﺜﻼ ﺇﺫﺍ ﻛﺎﻧﺖ ﺍﳌﻘﺎﺭﻧﺔ ﺻﺤﻴﺢ ﻓﺴﻴﺘﻢ ﺗﻨﻔﻴﺬ ﺍﻷﻭﺍﻣﺮ ﺍﻟﱵ ﺣﺪﺩﻧﺎﻫﺎ ﰲ ﺣﺎﻟﺔ
ﺃﻥ ﺍﳌﻘﺎﺭﻧﺔ ﺻﺤﻴﺤﺔ، ﺃﻣﺎ ﺇﺫﺍ ﻛﺎﻧﺖ ﺍﳌﻘﺎﺭﻧﺔ ﺧﺎﻃﺌﺔ ﻓﺴﻴﺘﻢ ﺗﻨﻔﻴﺬ ﺍﻷﻭﺍﻣﺮ ﺍﳌﻌﺎﻛﺴﺔ
...
h
)(main
{
;int usr_val
;)" :printf("Enter a value
;)scanf("%d", &usr_val
1
2
3
4
5
6
7
8
16
)001< if(usr_val
{
;)printf("%d are less than 100\n", usr_val
}
)001> if(usr_val
{
;)printf("%d are great than 100\n", usr_val
}
ﺍﻟﱪﻧﺎﻣﺞ ١,٧,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ
}
9
01
11
21
31
41
51
61
71
81
91
if
ﰲ ﻫﺬﺍ ﺍﻟﱪﻧﺎﻣﺞ ﻃﻠﺒﻨﺎ ﻣﻦ ﺍﳌﺴﺘﺨﺪﻡ ﺇﺩﺧﺎﻝ ﻗﻴﻤﺔ، ﰒ ﺍﺳﺘﻌﻤﻠﻨﺎ ﺍﻟﺸﺮﻁ ﺃﻭ ﺍﳌﻘﺎﺭﻧﺔ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﻌﺎﺷﺮ ﻭ ﺍﻟﺴﻄﺮ ﺍﳋﺎﻣﺲ ﻋﺸﺮ
ﻭ ﻫﻮ ﺍﳌﻘﺎﺭﻧﺔ ﺑﲔ ﺍﻟﻘﻴﻤﺔ ﺍﻟﱵ ﺃﺩﺧﻠﻬﺎ ﺍﳌﺴﺘﺨﺪﻡ ﻭ ٠٠١، ﺇﺫﺍ ﻛﺎﻧﺖ ﺍﳌﻘﺎﺭﻧﺔ ﺻﺤﻴﺤﺔ ﻓﺴﻴﻘﻮﻡ ﺍﻟﱪﻧﺎﻣﺞ ﺑﺘﻨﻔﻴﺬ ﻣﺎ ﻫﻮ ﺩﺍﺧﻞ
ﺍﻟـ blockﺍﳋﺎﺹ ﺑـ ،ifﻭ ﰲ ﺣﺎﻟﺔ ﺃﻥ ﺍﳌﻘﺎﺭﻧﺔ ﺧﺎﻃﺌﺔ ﻓﺴﻴﺘﻢ ﲡﺎﻫﻞ ﻣﺎ ﻫﻮ ﺩﺍﺧﻞ ﺍﻟـ blockﺍﻟﺬﻱ ﻳﻠﻲ
...
h
)(main
{
;int usr_val
;)" :printf("Enter a value
;)scanf("%d", &usr_val
)001< if(usr_val
;)printf("%d are less than 100\n", usr_val
)001> if(usr_val
;)printf("%d are great than 100\n", usr_val
ﺍﻟﱪﻧﺎﻣﺞ ٢,٧,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ (٢) if
ﻷﻧﻪ ﰲ ﻛﻼ ﺍﻟﺸﺮﻃﲔ ﻻ ﻳﻮﺟﺪ ﻤﺎ ﺇﻻ ﺃﻣﺮ ﻭﺍﺣﺪ
...
h
)(main
{
1
2
3
4
26
;int usr_val
;)" :printf("Enter a value
;)scanf("%d", &usr_val
)001<if(usr_val
;)printf("%d are less than 100\n", usr_val
else
;)printf("%d are great than 100\n", usr_val
ﺍﻟﱪﻧﺎﻣﺞ ٣,٧,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ
}
5
6
7
8
9
01
11
21
31
41
else
ﺍﺳﺘﻌﻤﻠﻨﺎ elseﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﱐ ﻋﺸﺮ ﻭ ﺳﺘﺮﻯ ﺃﻥ ﺍﳌﺜﺎﻝ ﺳﻴﻌﻤﻞ ﻣﺜﻞ ﺍﳌﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ ﻭ ﻫﻨﺎ ﲡﺪ ﻓﺎﺋﺪﺓ
...
elseﻭ ﻫﺬﻩ ﺻﻮﺭﺓ ﺗﻮﺿﺢ ﻟﻄﺮﻳﻘﺔ ﻋﻤﻠﻬﻤﺎ:
ﺍﻟﺸﻜﻞ ٣,٧,١: ﻃﺮﻳﻘﺔ ﻋﻤﻞ ifﻭ
else
٣,٧,١ ﺍﺳﺘﻌﻤﺎﻝ :else…if
ﰲ ﺍﳌﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ ﻟﻄﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﻝ elseﺇﺫﺍ ﻗﻤﺖ ﺑﺘﻨﻔﻴﺬ ﺍﻟﱪﻧﺎﻣﺞ ﻭ ﺃﻋﻄﻴﺘﻪ ﺍﻟﻘﻴﻤﺔ ٠٠١ ﻓﺴﻴﻘﻮﻝ ﻟﻚ ﺃﻥ ﺍﻟﻨﺘﻴﺠﺔ ﺍﻟـﱵ
ﺃﺩﺧﻠﺘﻬﺎ ﺃﻛﱪ ﻣﻦ ٠٠١، ﻭ ﻟﺘﻔﺎﺩﻱ ﻫﺬﺍ ﺍﳌﺸﻜﻠﺔ ﻧﺴﺘﻌﻤﻞ ﺍﻟﻜﻠﻤﺘﲔ else…ifﻣﻌﺎ، ﻭ ﻫﺬﺍ ﻣﺜﺎﻝ ﻳﻮﺿﺢ ﺫﻟﻚ:
>#include
else
٤,٧,١ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ:
١
...
٢
...
if
٥,٧,١ ﲤﺎﺭﻳﻦ:
١
...
٢
...
ﺃﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻄﻠﺐ ﻣﻦ ﺍﳌﺴﺘﺨﺪﻡ ﺇﺩﺧﺎﻝ ﻗﻴﻤﺔ ﻻ ﺗﺘﻌﺪﻯ ﺍﻟﻌﺪﺩ ٩، ﻭ ﻋﻨﺪ ﺇﺩﺧﺎﻝ ﺃﻱ ﻋﺪﺩ ﳜﱪﻩ ﺍﻟﱪﻧﺎﻣﺞ ﺃﻧﻪ ﻗﺪ
ﺃﺩﺧﻞ ﺫﻟﻚ ﺍﻟﻌﺪﺩ )ﺑﺎﺳﺘﻌﻤﺎﻝ
...
ﺍﻟﺘﻌﻠﻴﻘﺎﺕ ﻫﻲ ﺳﻠﺴﻠﺔ ﻣﻦ ﺍﻟﺮﻣﻮﺯ ﺗﺒﺪﺃ ﺑﺎﻟﺮﻣﺰ / slashﻭ ﺍﻟﻨﺠﻤﺔ * ﻭ ﺗﻨﺘﻬﻲ
ﺑﻨﺠﻤﺔ ﻭ ،/* slashﻭ ﳝﻜﻦ ﺃﻥ ﳛﻤﻞ ﺍﻟﺘﻌﻠﻴﻖ ﺃﻱ ﺭﻣﻮﺯ ﺃﻭ ﺃﺭﻗﺎﻡ
...
٢,٨,١ ﺍﻟﻜﻠﻤﺎﺕ ﺍﶈﺠﻮﺯﺓ :Keywords
ﺍﻟﻜﻠﻤﺎﺕ ﺍﶈﺠﻮﺯﺓ ﻫﻲ ﻛﻠﻤﺎﺕ ﺃﺳﺎﺳﻴﺔ ﰲ ﺍﻟﻠﻐﺔ ﻭ ﺍﻟﱵ ﻳﻜﻮﻥ ﻟﻮﺎ ﰲ ﺃﻏﻠﺐ ﺍﳌﺘﺮﲨﺎﺕ ﺃﺯﺭﻕ، ﻭ ﲰﻴﺖ ﺑﺎﻟﻜﻠﻤـﺎﺕ
ﺍﶈﺠﻮﺯﺓ ﻷﺎ ﳏﺠﻮﺯﺓ ﺳﺎﺑﻘﺎ، ﻛﻞ ﻣﻦ if ،double ،char ،intﻭ elseﺗﻌﺘﱪ ﻛﻠﻤﺎﺕ ﳏﺠﻮﺯﺓ ﻭ ﺍﻟﻜﺜﲑ ﻣﻨﻬﺎ، ﻭ ﻫﺬﺍ
ﺟﺪﻭﻝ ﳉﻤﻴﻊ ﺍﻟﻜﻠﻤﺎﺕ ﺍﶈﺠﻮﺯﺓ ﺍﻷﺳﺎﺳﻴﺔ ﰲ ﻟﻐﺔ :C
float
static
default
goto
struct
case
switch
extern
void
typedef
union
enum
return
continue
break
sizeof
volatile
for
while
do
else
register
auto
const
ﺍﳉﺪﻭﻝ ١,٨,١: ﺍﻟﻜﻠﻤﺎﺕ ﺍﶈﺠﻮﺯﺓ ﻟﻠﻐﺔ
char
signed
unsigned
if
int
short
long
double
C
ﻭ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ ،asmﻋﺪﺩﻫﺎ ٣٣، ﻭ ﺳﻨﺪﺭﺱ ﲨﻴﻊ ﺍﻟﻜﻠﻤﺎﺕ ﺍﶈﺠﻮﺯﺓ ﰲ ﺍﻟﺪﺭﻭﺱ ﺍﻟﻘﺎﺩﻣﺔ
...
ﺟﺪﻭﻝ ﻟﻸﺣﺮﻑ ﺍﻟﱵ ﳝﻜﻦ ﺃﻥ ﺗـﺴﺘﻌﻤﻞ ﰲ ﺃﲰـﺎﺀ
ﺍﳌﻌﺮﻓﺎﺕ:
ﺍﻷﺣﺮﻑ
a b c d e f g h i j k l m n o p q r s t u v w x
_
y z
A B C D E F G H I J K L M N O P Q R S T U V W X Y
Z
ﺍﻷﺭﻗﺎﻡ
٠١٢٣٤٥٦٧٨٩
56
١,٣,٨,١ ﺳﻼﺳﻞ :Trigraphs
ﺍﳉﺪﻭﻝ ٢,٨,١: ﺣﺪﻭﺩ ﺃﲰﺎﺀ ﺍﳌﻌﺮﻓﺎﺕ
ﻫﻲ ﺳﻼﺳﻞ ﻣﻜﻮﻧﺔ ﻣﻦ ﺛﻼﺛﺔ ﺭﻣﻮﺯ ﻳﻘﻮﻡ ﺍﳌﺘﺮﺟﻢ ﺑﺎﺳﺘﺒﺪﺍﳍﺎ ﺇﱃ ﺭﻣﻮﺯ ﺑﺪﻳﻠﻴﻪ، ﻭ ﻫﺬﺍ ﺟﺪﻭﻝ ﺗﻮﺿﻴﺤﻲ ﳍﺬﻩ ﺍﻟﺮﻣﻮﺯ:
Trigraphs
ﺍﻟﺮﻣﺰ ﺍﻟﺬﻱ ﻳﻘﺎﺑﻠﻪ
=??
>??
(??
)??
/??
’??
!??
-??
#
{
}
[
]
\
^
|
~
ﺍﳉﺪﻭﻝ ٣,٨,١:
Trigraphs
ﻭ ﻫﺬﺍ ﻣﺜﺎﻝ ﻳﻮﺿﺢ ﻃﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﻝ ﺗﻠﻚ ﺍﻟﺮﻣﻮﺯ:
>??=include
h
)(main
{
;)"printf("??=\n
;)"printf("??<\n
;)"printf("??>\n
;)"printf("??(\n
;)"printf("??)\n
;)"printf("??//\n
;)"printf("??'\n
;)"printf("??!\n
;)"printf("??-\n
}
٤,٨,١ ﺍﻟﺜﻮﺍﺑﺖ :Constants
ﺍﻟﱪﻧﺎﻣﺞ ٢,٨,١: ﺇﺳﺘﻌﻤﺎﻝ ﺭﻣﻮﺯ (٢) Trigraphs
1
2
3
4
5
6
7
8
9
01
11
21
31
41
66
ﺍﻟﺜﻮﺍﺑﺖ ﺗﻜﻮﻥ ﺇﻣﺎ ﺃﺭﻗﺎﻡ ﺃﻭ ﺃﺣﺮﻑ ﺃﻭ ﺳﻼﺳﻞ ﺣﺮﻓﻴﺔ، ﻻ ﳝﻜﻦ ﺍﻟﺘﻐﲑ ﻓﻴﻬﺎ ﺃﺛﻨﺎﺀ ﺍﻟﱪﻧﺎﻣﺞ، ﻭ ﺗﻮﺟﺪ ﻧﻮﻋﺎﻥ ﻣﻨﻬﺎ ﻭ ﻫﻲ:
١,٤,٨,١ ﺍﻟﺜﻮﺍﺑﺖ ﺍﻟﻨﺼﻴﺔ:
ﺍﻟﺜﻮﺍﺑﺖ ﺍﻟﻨﺼﻴﺔ ﻫﻲ ﺗﻜﻮﻥ ﺇﻣﺎ ﺑﺎﻻﺳﺘﻌﻤﺎﻝ ﺍﳌﻮﺟﻪ #defineﺃﻭ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ ،constﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﻮﺟﻪ
ﻓﻬﺬﺍ ﻣﺜﺎﻝ ﻟﻪ:
#define
>#include
ﺃﻣﺎ ﺍﻟﺜﻮﺍﺑـﺖ ﺑﺎﺳـﺘﺨﺪﺍﻡ
ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ constﻓﺴﺄﻋﻄﻲ ﻣﺜﺎﻝ ﳊﺮﻑ ﺛﺎﺑﺖ، ﺍﳌﺜﺎﻝ:
>#include
ﻭ ﺗﻮﺟﺪ ﺭﻣﻮﺯ ﺛﺎﺑﺘﺔ ﺃﺧﺮﻯ ﺧﺎﺻﺔ ﺑﻠﻐﺔ Cﻭ
ﻫﻲ ﻣﻮﺿﺤﺔ ﻋﻠﻰ ﺍﳉﺪﻭﻝ ﺍﻟﺘﺎﱄ:
ﺍﻟﺘﺄﺛﲑ
ﻃﺒﺎﻋﺔ ﺍﻟﺮﻣﺰ
ﺍﻟﺮﻣﺰ
'
ﺍﻟﺘﺄﺛﲑ
ﺍﻟﺮﻣﺰ
’\
ﺍﻹﻧﺬﺍﺭ، ﺗﻘﻮﻡ ﺑﺈﺻﺪﺍﺭ ﺻﻮﺕ ﻣﻦ
\a
76
ﺍﻟﻠﻮﺣﺔ ﺍﻷﻡ،
Alert
ﻃﺒﺎﻋﺔ ﺍﻟﺮﻣﺰ
"
"\
ﺍﻟﻔﻀﺎﺀ ﺍﳋﻠﻔﻲ،
Backspace
\b
ﻃﺒﺎﻋﺔ ﺍﻟﺮﻣﺰ
?
?\
ﺻﻔﺤﺔ ﺟﺪﻳﺪﺓ،
Form feed
\f
ﻃﺒﺎﻋﺔ ﺍﻟﺮﻣﺰ
\
\\
ﺳﻄﺮ ﺟﺪﻳﺪ،
New line
\n
ﻷﻋﺪﺍﺩ ﻧﻈﺎﻡ ﺍﻟﺜﻤﺎﱐ
\0oo
ﻷﻋﺪﺍﺩ ﻧﻈﺎﻡ ﺍﻟﺴﺪﺍﺳﻲ ﻋﺸﺮ
\xhh
ﺍﻟﻌﻮﺩﺓ ﲟﺆﺷﺮ ﺍﻟﻜﺘﺎﺑﺔ ﺇﱃ ﺑﺪﺍﻳﺔ ﺍﻟﺴﻄﺮ،
Carriage return
\r
٨ ﻓﺮﺍﻏﺎﺕ ﰲ ﺍﻻﲡﺎﻩ ﺍﻷﻓﻘﻲ
\t
٨ ﻓﺮﺍﻏﺎﺕ ﰲ ﺍﻻﲡﺎﻩ ﺍﻟﻌﻤﻮﺩﻱ
\v
ﺍﳉﺪﻭﻝ ٤,٨,١: ﺛﻮﺍﺑﺖ ﺧﺎﺻﺔ ﺑﻠﻐﺔ
C
٢,٤,٨,١ ﺍﻟﺜﻮﺍﺑﺖ ﺍﻟﺮﻗﻤﻴﺔ:
ﻫﻲ ﺍﻹﻋﻼﻥ ﻋﻦ ﺛﻮﺍﺑﺖ ﺎ ﻗﻴﻢ ﺛﺎﺑﺘﺔ ﻻ ﳝﻜﻦ ﺍﻟﺘﺤﺪﻳﺚ ﻓﻴﻬﺎ ﺃﺛﻨﺎﺀ ﺍﻟﱪﻧﺎﻣﺞ، ﻭ ﳝﻜﻦ ﺃﻥ ﺗﻜﻮﻥ ﺃﻱ ﻧﻮﻉ ﻣـﻦ ﺍﻷﻋـﺪﺍﺩ
،short, long, int, unsigned, signed, float, doubleﻭ ﳝﻜﻦ ﺃﻳﻀﺎ ﺍﻹﻋﻼﻥ ﻋﻨﻬﺎ ﰲ ﻛـﻞ ﻣـﻦ ﺍﳌﻮﺟـﻪ
#defineﻭ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ ،constﻣﺜﺎﻝ ﺣﻮﻝ ﺍﳌﻮﺟﻪ :#define
>#include
ﻭ ﻫﺬﺍ ﻣﺜﺎﻝ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ :const
>#include
٦,٨,١ ﺍﻟﺴﻼﺳﻞ ﺍﻟﻨﺼﻴﺔ :String literals
ﺍﻟﺴﻼﺳﻞ ﺍﻟﻨﺼﻴﺔ ﺃﻱ ﺍﻟﺜﻮﺍﺑﺖ ﺍﻟﻨﺼﻴﺔ، ﻫﻲ ﺳﻼﺳﻞ ﻣﻦ ﺣﺮﻭﻑ ﳏﺎﻃﺔ ﺑﺎﻗﺘﺒﺎﺳﻴﲔ "
...
٧,٨,١ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ:
ﻻ ﺗﻮﺟﺪ ﺃﺧﻄﺎﺀ ﳏﺘﻤﻠﺔ ﰲ ﻫﺬﺍ ﺍﻟﺪﺭﺱ
...
96
ﻣﺎ ﺩﺭﺳﻨﺎﻩ ﺣﱴ ﺍﻵﻥ ﻫﻮ ﺟﺰﺀ ﺷﺒﻪ ﻛﺒﲑ ﻣﻦ ﻟﻐﺔ ،Cﻭ ﰲ ﻫﺬﺍ ﺍﳌﻠﺨﺺ ﺳﻨﺤﺎﻭﻝ ﺗﻐﻄﻴﺔ ﻭ ﻓﻬﻢ ﺃﻛﺜﺮ ﳌﺎ ﺩﺭﺳﻨﺎﻩ
...
h
)(main
{
;2int num1, num
;)" :printf("the year currently
;)1scanf("%d", &num
1
2
3
4
5
6
7
8
07
;)" :printf("the year of your born
;)2scanf("%d", &num
;)2printf("You have %d years!\n", num1-num
}
ﺍﻟﱪﻧﺎﻣﺞ ١,٩,١: ﻋﻤﺮ ﺍﳌﺴﺘﺨﺪﻡ
9
01
11
21
31
41
ﰎ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺘﻐﲑ ﰲ ﺍﻟﺴﻄﺮ ﺍﳋﺎﻣﺲ، ﻭ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ ﻃﻠﺒﻨﺎ ﻣﻦ ﺍﳌﺴﺘﺨﺪﻡ ﺇﺩﺧﺎﻝ ﺍﻟﺴﻨﺔ ﺍﳊﺎﻟﻴﺔ، ﻭ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﻣﻦ
ﺃﺧﺬﻧﺎ ﺍﻟﺴﻨﺔ ﻋﻠﻰ ﺷﻜﻞ ﻋﺪﺩ ﺣﻘﻴﻘﻲ
...
ﻭ ﺃﺧﲑﺍ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﻟﺚ ﻋﺸﺮ ﻗﻤﻨﺎ ﺑﻄﺒﺎﻋﺔ ﺍﻟﻨﺘﻴﺠﺔ ﻭ ﺍﻟﱵ ﻫﻲ ﻃﺮﺡ ﺍﻟـﺴﻨﺔ
ﺍﳊﺎﻟﻴﺔ ﻋﻠﻰ ﺳﻨﺔ ﺍﳌﺴﺘﺨﺪﻡ
...
h
)(main
{
;2int num1, num
;char Char
;)" :printf("1:(+)\n2:(-)\n3:(/)\n4:(*)\nEnter a choice
;)scanf("%c", &Char
;)" :printf("Enter the first number
;)1scanf ("%d", &num
;)" :printf("Enter the second number
;)2scanf("%d", &num
)'1' == if(Char == '+' || Char
;)2printf("%d + %d = %d\n", num1, num2, num1+num
)'2' == else if(Char == '-' || Char
;)2printf("%d - %d = %d\n", num1, num2, num1-num
)'3' == else if(Char == '/' || Char
;)2printf("%d / %d = %d\n", num1, num2, num1/num
)'4' == else if(Char == '*' || Char
;)2printf("%d * %d = %d\n", num1, num2, num1*num
else
;)"printf("Error in choice!\nExiting
...
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﻣﻦ ﻃﻠﺒﻨﺎ ﻣﻦ ﺍﳌﺴﺘﺨﺪﻡ ﺑﺈﺧﺘﻴﺎﺭ ﺍﻹﺷﺎﺭﺓ
ﺃﻭ ﺍﳌﺆﺛﺮ ﺍﻟﺬﻱ ﻳﺮﻳﺪ ﺍﺳﺘﻌﻤﺎﻟﻪ، ﻭ ﺃﺧﺬﻧﺎ ﺍﳌﺆﺷﺮ ﺍﻟﺬﻱ ﺇﺧﺘﺎﺭﻩ ﺍﳌﺴﺘﺨﺪﻡ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺘﺎﺳﻊ ﻋﻠﻰ ﺷﻜﻞ ﺭﻣﺰ
...
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ ﻋﺸﺮ ﻗﻤﻨﺎ ﺑﺎﺳﺘﻌﻤﺎﻝ
ﺷﺮﻁ ﻭ ﻫﻮ ﺇﺫﺍ ﻛﺎﻥ ﺍﻟﺮﻣﺰ ﺍﻟﺬﻱ ﺃﺩﺧﻠﻪ ﺍﳌﺴﺘﺨﺪﻡ ﰲ ﺍﳌﺘﻐﲑ Charﻳﺴﺎﻭﻱ ﺍﳌﺆﺛﺮ + ﺃﻭ ﺍﻟﺮﻗﻢ ١، ﰲ ﺣﺎﻟـﺔ ﺃﻥ ﺍﻟـﺸﺮﻁ
ﺻﺤﻴﺢ ﻳﺘﻢ ﺗﻄﺒﻴﻖ ﻋﻤﻠﻴﺔ ﺍﳉﻤﻊ، ﻭ ﻫﻜﺬﺍ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻜﻞ ﻣﻦ ﺍﻷﺳﻄﺮ ﺍﻟﻌﺸﺮﻳﻦ، ﺍﻟﺜﺎﻟﺚ ﻭ ﺍﻟﻌﺸﺮﻳﻦ، ﺍﻟﺴﺎﺩﺱ ﻭ ﺍﻟﻌﺸﺮﻳﻦ، ﺃﻣﺎ
ﺍﻟﺴﻄﺮ ﺍﻟﺘﺎﺳﻊ ﻭ ﺍﻟﻌﺸﺮﻳﻦ ﻓﺴﻴﺘﻢ ﺗﻨﻔﻴﺬﻩ ﺇﺫﺍ ﻛﺎﻥ ﺍﻟﺮﻣﺰ ﺍﻟﺬﻱ ﺃﺩﺧﻠﻪ ﺍﳌﺴﺘﺨﺪﻡ ﻏﲑ ﻣﺘﻮﺍﻓﻖ ﻣﻊ ﺍﻟﺮﻣﻮﺯ ﺍﳌﻄﻠﻮﺑﺔ
...
h
)(main
{
;int num, x
;)" :printf("Enter a number
;)scanf ("%d", &num
)0<if(num
;x = -num
else
;x = num
;)printf("|%d|=%d\n", num, x
ﺍﻟﱪﻧﺎﻣﺞ ٣,٩,١: ﺍﺳﺘﺨﺮﺍﺝ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻄﻠﻘﺔ
}
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
61
ﰲ ﺍﻟﺴﻄﺮ ﺍﳋﺎﻣﺲ ﻗﻤﻨﺎ ﺑﺎﻹﻋﻼﻥ ﻋﻦ ﻣﺘﻐﲑﻳﻦ، ﺍﻷﻭﻝ ﻟﻠﻌﺪﺩ ﺍﻟﺬﻱ ﺳﻴﻘﻮﻡ ﺑﺈﺩﺧﺎﻟﻪ ﺍﳌﺴﺘﺨﺪﻡ، ﻭ ﺍﳌﺘﻐﲑ ﺍﻟﺜﺎﱐ ﻫـﻮ ﺍﻟـﺬﻱ
ﺳﻴﺤﻤﻞ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻄﻠﻘﺔ ﻟﻠﻌﺪﺩ ﺍﻟﺬﻱ ﺃﺩﺧﻠﻪ ﺍﳌﺴﺘﺨﺪﻡ
...
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﻌﺎﺷﺮ ﻗﻤﻨﺎ ﺑﺎﺳﺘﻌﻤﺎﻝ ﺷﺮﻁ ﻭ ﻫﻮ ﺇﺫﺍ ﻛـﺎﻥ
ﺍﻟﻌﺪﺩ ﺍﻟﺬﻱ ﺃﺩﺧﻠﻪ ﺍﳌﺴﺘﺨﺪﻡ ﺃﻗﻞ ﻣﻦ ﺍﻟﺼﻔﺮ ﺃﻱ ﺍﻟﻌﺪﺩ ﺳﺎﻟﺐ ﻓﺈﻥ ﺍﳌﺘﻐﲑ xﻳﺴﺎﻭﻱ ﻗﻴﻤﺔ ﺍﳌﺘﻐﲑ numﻣﻊ ﻋﻜﺲ ﺍﻹﺷﺎﺭﺓ، ﻭ
ﰲ ﺣﺎﻟﺔ ﺃﻥ ﺍﻟﺸﺮﻁ ﻛﺎﻥ ﺧﺎﻃﺊ ﻓﻬﺬﺍ ﻳﻌﲏ ﺃﻥ ﺍﻟﻌﺪﺩ ﺍﻟﺬﻱ ﺃﺩﺧﻠﻪ ﺍﳌﺴﺘﺨﺪﻡ ﻋﺪﺩ ﺃﻛﱪ ﻣﻦ ﺍﻟﺼﻔﺮ ﺃﻱ ﻋـﺪﺩ ﻣﻮﺟـﺐ
...
27
٤,١,٩,١ ﺍﻟﱪﻧﺎﻣﺞ ﺍﻟﺮﺍﺑﻊ، ﺃﺧﺬ ﺍﻟﻌﺪﺩ ﺍﻟﻜﺒﲑ:
ﻳﻘﻮﻡ ﻫﺬﺍ ﺍﻟﱪﻧﺎﻣﺞ ﺑﺄﺧﺬ ﺍﻟﻌﺪﺩ ﺍﻷﻛﱪ ﺑﲔ ﻋﺪﺩﻳﻦ ﻳﻘﻮﻡ ﺑﺈﺩﺧﺎﳍﻤﺎ ﺍﳌﺴﺘﺨﺪﻡ، ﺍﳌﺜﺎﻝ:
>#include
ﻣﻦ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ ﺇﱃ ﺍﻟﺴﻄﺮ ﺍﳊﺎﺩﻱ ﻋـﺸﺮ، ﻃﻠﺒﻨـﺎ ﻣـﻦ
ﺍﳌﺴﺘﺨﺪﻡ ﺇﺩﺧﺎﻝ ﻋﺪﺩﻳﻦ
...
ﻭ
ﺃﺧﲑﺍ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﻣﻦ ﻋﺸﺮ ﻭ ﻫﻮ ﻳﻘﻮﻡ ﺑﻄﺒﺎﻋﺔ ﺍﻟﻨﺘﺎﺋﺞ
...
stdio
...
h
)(main
{
;)'putchar('H
1
2
3
4
5
37
;)'putchar('e
;)'putchar('l
;)'putchar('l
;)'putchar('o
;)','(putchar
;)' '(putchar
;)'putchar('w
;)'putchar('o
;)'putchar('r
;)'putchar('l
;)'putchar('d
;)'putchar('\n
ﺍﻟﱪﻧﺎﻣﺞ ٥,٩,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ
}
6
7
8
9
01
11
21
31
41
51
61
71
81
putchar
ﻭ ﻻ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﳍﺎ ﻟﻄﺒﺎﻋﺔ ﺍﻟﻨﺼﻮﺹ، ﻭ ﰲ ﻫﺬﻩ ﺍﳊﺎﻟﺔ ﺳﺘﻔﻀﻞ ﺍﺳﺘﻌﻤﺎﻝ
...
h
)(main
{
;char ch
;)':'(putchar
;)(ch = getchar
;)putchar(ch
ﺍﻟﱪﻧﺎﻣﺞ ٦,٩,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ
}
1
2
3
4
5
6
7
8
9
01
11
21
getchar
ﻭ ﻫﻨﺎ ﻛﺘﺒﻨﺎ )( ch = getcharﻷﻥ ﺍﻟﺪﺍﻟﺔ getcharﻻ ﲢﺘﻮﻱ ﻋﻠﻰ ﻭﺳﺎﺋﻂ، ﻭ ﻫﻨﺎ ﺍﻟﻄﺮﻳﻘـﺔ ﺻـﺤﻴﺤﺔ ﻷﻥ ﺍﻟﺪﺍﻟـﺔ
getcharﺗﻘﻮﻡ ﺑﺈﺭﺟﺎﻉ ﻗﻴﻤﺔ ﻭ ﻫﻲ ﺍﳊﺮﻑ ﺍﻟﺬﻱ ﺃﺩﺧﻠﻪ ﺍﳌﺴﺘﺨﺪﻡ
...
hﻭ ﺍﻷﻭﱃ ﳐﺘﺼﺮﺓ ﻣﻦ put stringﻭ ﺍﻟﺜﺎﻧﻴﺔ
...
٢- ﺍﻟﺪﺍﻟﺔ putsﻻ ﳝﻜﻨﻬﺎ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﻣﺘﻐﲑﺍﺕ ﻣﻦ ﻧﻮﻉ ﺃﺭﻗﺎﻡ ﺃﻭ ﺃﺣﺮﻑ، ﺃﻱ ﺃﺎ ﻻ ﺗﺘﻌﺎﻣﻞ ﻣﻊ ﺭﻣﻮﺯ ﻣﺜﻞ
...
h
)(main
{
;)"!puts("Hello, World
;)"!puts("Goodbay, World
}
ﺍﻟﱪﻧﺎﻣﺞ ٧,٩,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ
1
2
3
4
5
6
7
puts
ﺃﻣﺎ ﻋﻦ ﺍﻟﺪﺍﻟﺔ getsﻓﻬﻲ ﺗﻘﻮﻡ ﺑﺈﺩﺧﺎﻝ ﻧﺼﻮﺹ، ﻭ ﻻ ﳝﻜﻦ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ﺑﺎﻷﺭﻗﺎﻡ ﻭ ﺍﻷﺣﺮﻑ، ﺳﻨﺘﻄﺮﻕ ﺇﻟﻴﻬﺎ ﰲ ﺍﻟﺪﺭﻭﺱ
ﺍﻟﻘﺎﺩﻣﺔ، ﻷﻧﻨﺎ ﱂ ﻧﺘﻌﺎﻣﻞ ﻣﻊ ﺍﻟﻨﺼﻮﺹ ﺑﻌﺪ
...
h
)(main
{
;int num, x
;)" :wprintf(L"Enter a number
;)wscanf(L"%d", &num
)0<if(num
;x = -num
else
;x = num
;)wprintf(L"|%d|=%d\n", num, x
ﺍﻟﱪﻧﺎﻣﺞ ٨,٩,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ wprintﻭ ﺍﻟﺪﺍﻟﺔ
}
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
61
wscanf
ﻭ ﺍﳊﺮﻑ Lﻳﻌﲏ
...
hﺃﻣﺎ ﰲ ﺃﻧﻈﻤﺔ Windowsﻓﺴﺘﺠﺪﻫﺎ ﰲ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ) conio
...
ﺇﺫﺍ ﻛﺎﻧﺖ ﺍﻟﻨﺴﺨﺔ ﺍﻟﱵ ﻟﺪﻳﻚ ﻣﻦ ﻟﻐﺔ Cﻫﻲ ﺍﻟﻨﺴﺨﺔ ﺍﻟﻘﻴﺎﺳﻴﺔ ANSI Cﻓﻴﻤﻜﻨﻚ ﺍﻹﻋﺘﻤﺎﺩ ﻋﻠﻰ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ،stdio
...
getchﺍﻟﺪﺍﻟﺔ putchﻫﻲ ﻧﻔﺲ ﺍﻟﺪﺍﻟﺔ ،putcharﻭ ﺍﻟﺪﺍﻟﺔ getchﻣﺘﺸﺎﺎ ﻟـﺪﺍﻟﺔ
getcharﻣﻊ ﺑﻌﺾ ﺍﻻﺧﺘﻼﻓﺎﺕ:
١- ﺍﻟﺪﺍﻟﺔ getcharﺗﺴﻤﺢ ﻟﻚ ﺑﺮﺅﻳﺔ ﻣﺎ ﻗﻤﺖ ﺑﺈﺩﺧﺎﻟﻪ، ﺃﻣﺎ getchﻓﻼ ﺗﺴﻤﺢ ﻟﻚ ﺑﺬﻟﻚ
...
ﻣﺜﺎﻝ ﺣﻮﻝ putchﻭ :getch
/* /* Just in Windows and DOS OS compilers
>#include
h
)(main
{
;char ch
;)(ch = getch
;)putch(c
;)'putch('\n
ﺍﻟﱪﻧﺎﻣﺞ ٩,٩,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ getchﻭ ﺍﻟﺪﺍﻟﺔ
}
1
2
3
4
5
6
7
8
9
01
11
putch
ﻗﻤﻨﺎ ﺑﻀﻢ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ conio
...
ﻭ ﰲ ﺍﻟﻜﺜﲑ ﻣﻦ ﺍﻟﱪﺍﻣﺞ ﺳﺘﺠﺪ ﺃﻥ ﺍﻟﺪﺍﻟﺔ getchﻣﺴﺘﻌﻤﻠﺔ ﺑﻜﺜﺮﺓ ﻭ ﺧﺎﺻﺔ ﰲ ﺎﻳﺔ ﺍﻟﱪﻧﺎﻣﺞ ﻭ ﺫﻟـﻚ ﻷـﺎ
ﺗﺘﻮﻗﻒ ﺑﺎﻧﺘﻈﺎﺭ ﺍﳌﺴﺘﺨﺪﻡ ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ ﺯﺭ ﻣﻦ ﺍﻷﺯﺭﺍﺭ ﻭ ﻃﺮﻳﻘﺔ ﻫﻲ:
/* /* Just in Windows and DOS OS compilers
>#include
h
)(main
{
;char ch
;)(ch = getch
;)putch(ch
;)'putch('\n
1
2
3
4
5
6
7
8
9
01
67
;)"printf("Press any key to exit\n
/* getch(); /*pause
}
11
21
31
41
ﺍﻟﱪﻧﺎﻣﺞ ٠١,٩,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ getchﻭ ﺍﻟﺪﺍﻟﺔ (٢) putch
ﺣﻴﺚ ﻫﻨﺎ ﻟﻦ ﳜﺮﺝ ﺍﻟﱪﻧﺎﻣﺞ ﻣﺒﺎﺷﺮﺓ، ﺳﻴﻨﺘﻈﺮ ﺃﻥ ﻳﻘﻮﻡ ﺍﳌﺴﺘﺨﺪﻡ ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ ﺃﻱ ﺯﺭ ﻛﻲ ﻳﻘﻮﻡ ﺍﻟﱪﻧﺎﻣﺞ ﺑﺎﳋﺮﻭﺝ
...
h
>#include
h
)(main
{
;'wchar_t wch = 'a
;)printf("%c\n", wch
ﺍﻟﱪﻧﺎﻣﺞ ٢١,٩,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ
}
1
2
3
4
5
6
7
8
wchar_t
٧,٩,١ ﺍﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ mainﻭ :wmain
ﺍﻟﺪﺍﻟﺔ mainﻫﻲ ﺩﺍﻟﺔ ﺭﺋﻴﺴﻴﺔ ﺣﻴﺚ ﻳﺒﺪﺃ ﺍﻟﱪﻧﺎﻣﺞ ﺑﺘﻨﻔﻴﺬ ﺍﻷﻭﺍﻣﺮ ﻣﻨﻬﺎ، ﺑﺎﲡﺎﻩ ﻭﺍﺣﺪ ﻭ ﺑﻄﺮﻳﻘﺔ ﻣﻨﻈﻤﺔ، ﺍﻟﺪﺍﻟـﺔ
)ﻟﻴﺴﺖ ﻣﻦ ﺍﻟﺪﻭﺍﻝ ﺍﻟﻘﻴﺎﺳﻴﺔ ﻟﻠﻐﺔ (Cﻫﻲ ﻧﻔﺴﻬﺎ mainﻭ ﻟﻜﻨﻬﺎ ﻋﺮﻳﻀﺔ، ﻭ ﻛﻞ ﺍﻟﺪﻭﺍﻝ ﻭ ﺍﻟﻜﻠﻤﺎﺕ ﺍﶈﺠـﻮﺯﺓ ﺍﻟﻌﺮﻳـﻀﺔ
ﺗﺴﺘﻌﻤﻞ ﰲ ﺍﻟﻨﻈﺎﻡ ﺍﳊﺮﻭﻑ ﺍﻟﺪﻭﱄ ﺍﳌﻮﺣﺪ ﺃﻭ ﲟﺎ ﻳﺴﻤﻰ ﺑـ
...
h
)(wmain
{
;)"wprintf(L"Hello, World!\n
}
ﺍﻟﱪﻧﺎﻣﺞ ٣١,٩,١: ﺍﻟﺪﺍﻟﺔ
1
2
3
4
5
6
wmain
ﰲ ﺑﻌﺾ ﺍﳌﺘﺮﲨﺎﺕ ﺇﻥ ﻛﺘﺒﺖ ﺍﻟﱪﻧﺎﻣﺞ ﺍﻟﺘﺎﱄ:
>#include
h
ﺍﻟﱪﻧﺎﻣﺞ ٥١,٩,١: ﺇﺭﺟﺎﻉ ﻗﻴﻤﺔ ﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ
)(main
{
;0 return
}
1
2
3
4
5
6
ﻭ ﺳﺒﺐ ﺇﺭﺟﺎﻉ ﻗﻴﻤﺔ ﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻫﻮ ﺍﻟﻮﺿﻊ ﺍﻻﻓﺘﺮﺍﺿﻲ ﳍﺎ ﻭ ﻫﻮ ،intﻭ ﲨﻴﻊ ﺍﻟﺪﻭﺍﻝ ﻣﻦ ﻧﻮﻉ intﳚﺐ ﺇﺭﺟﺎﻉ ﻗﻴﻤﺔ
ﳍﺎ، ﻭ ﻫﺬﺍ ﻳﻌﲏ ﺃﻧﻪ ﳝﻜﻦ ﻛﺘﺎﺑﺔ:
>#include
h
1
2
)(int main
{
;0 return
}
ﺍﻟﱪﻧﺎﻣﺞ ٦١,٩,١: ﺇﺭﺟﺎﻉ ﻗﻴﻤﺔ ﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ )٢(
ﺃﻣﺎ ﺇﺫﺍ ﺃﺭﺩﺕ ﻋﺪﻡ ﺇﺭﺟﺎﻉ ﻗﻴﻤﺔ ﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻓﻴﻤﻜﻦ ﻛﺘﺎﺑﺔ voidﺑﺪﻝ ،intﺣﻴﺚ ﺗﺴﺘﻌﻤﻞ voidﻟﻠﻘﻴﺎﻡ ﺑـﺈﺟﺮﺍﺀﺍﺕ ﻭ
ﻻ ﳝﻜﻦ ﺇﺭﺟﺎﻉ ﳍﺎ ﻗﻴﻤﺔ، ﻭ ﻫﺬﺍ ﻣﺜﺎﻝ:
87
)(void main
{
}
ﺍﻟﱪﻧﺎﻣﺞ ٧١,٩,١: ﺗﻔﺎﺩﻱ ﺇﺭﺟﺎﻉ ﻗﻴﻤﺔ ﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ
٨,٩,١ ﺭﻣﻮﺯ ﺍﻹﺧﺮﺍﺝ ﻭ ﺍﻹﺩﺧﺎﻝ:
ﺭﻣﻮﺯ ﺍﻹﺧﺮﺍﺝ ﺍﳋﺎﺻﺔ ﺑﺎﻟﺪﺍﻟﺔ printfﻣﻮﺿﺤﺔ ﻋﻠﻰ ﺍﳉﺪﻭﻝ ﺍﻟﺘﺎﱄ:
ﺍﻟﺮﻣﺰ
ﺍﻟﺸﺮﺡ
%d, %i
ﻟﻸﻋﺪﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ ﻭ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﳍﻤﺎ ﻟﻜﻞ ﻣﻦ ﺍﻷﻧﻮﺍﻉ
%f, %e, %g
ﻟﻸﻋﺪﺍﺩ ﺍﳊﻘﻴﻘﻴﺔ ﻭ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﳍﻢ ﻟﻜﻞ ﻣﻦ ﺍﻷﻧﻮﺍﻉ
%u
ﻟﻸﻋﺪﺍﺩ ﺑﺪﻭﻥ ﺇﺷﺎﺭﺓ ﻭ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻟﻪ ﻟﻜﻞ ﻣـﻦ ﺍﻷﻧـﻮﺍﻉ
int, short, long
float, double
,unsigned, int
short, long
%c
ﻟﻠﺮﻣﻮﺯ ﻭ ﺍﻷﺣﺮﻑ ﻭ ﻳﺴﺘﻌﻤﻞ ﻣﻊ ﺍﳌﺘﻐﲑﺍﺕ ﺍﳊﺮﻓﻴﺔ
%s
ﻟﻠﻨﺼﻮﺹ ﺃﻭ ﺍﻟﺴﻼﺳﻞ ﺍﳊﺮﻓﻴﺔ ﻭ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻟﻪ ﻣﻊ ][ charﻭ
%o
ﻷﻋﺪﺍﺩ ﺍﻟﻨﻈﺎﻡ ﺍﻟﺜﻤﺎﱐ
%x
ﻷﻋﺪﺍﺩ ﺍﻟﻨﻈﺎﻡ ﺍﻟﺴﺪﺍﺳﻲ
%p
ﻟﻠﻤﺆﺷﺮﺍﺕ
%ld
ﻷﻋﺪﺍﺩ ﺻﺤﻴﺤﺔ ﻃﻮﻳﻠﺔ Long Decimalﻭ ﺗﺴﺘﻌﻤﻞ ﰲ
%lu
ﻷﻋﺪﺍﺩ ﻃﻮﻳﻠﺔ ﺑﺪﻭﻥ ﺇﺷﺎﺭﺓ
char
*char
long int
long unsigned
ﺍﳉﺪﻭﻝ ١,٩,١: ﺭﻣﻮﺯ ﺍﻟﺪﺍﻟﺔ
printf
ﻭ ﺭﻣﻮﺯ ﺍﻹﺩﺧﺎﻝ ﺍﳋﺎﺻﺔ ﺑﺎﻟﺪﺍﻟﺔ scanfﻋﻠﻰ ﺍﳉﺪﻭﻝ ﺍﻟﺘﺎﱄ:
ﺍﻟﺮﻣﺰ
ﺍﻟﺸﺮﺡ
%d, %i
ﻟﻸﻋﺪﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ ﻭ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﳍﻤﺎ ﻟﻜﻞ ﻣﻦ ﺍﻷﻧﻮﺍﻉ
%f, %e, %g
ﻟﻸﻋﺪﺍﺩ ﺍﳊﻘﻴﻘﻴﺔ ﻭ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﳍﻢ ﻟﻜﻞ ﻣﻦ ﺍﻷﻧﻮﺍﻉ
%u
ﻟﻸﻋﺪﺍﺩ ﺑﺪﻭﻥ ﺇﺷﺎﺭﺓ ﻭ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻟﻪ ﻟﻜﻞ ﻣـﻦ ﺍﻷﻧـﻮﺍﻉ
int, short, long
float, double
,unsigned, int
short, long
%c
ﻟﻠﺮﻣﻮﺯ ﻭ ﺍﻷﺣﺮﻑ ﻭ ﻳﺴﺘﻌﻤﻞ ﻣﻊ ﺍﳌﺘﻐﲑﺍﺕ ﺍﳊﺮﻓﻴﺔ
%s
ﻟﻠﻨﺼﻮﺹ ﺃﻭ ﺍﻟﺴﻼﺳﻞ ﺍﳊﺮﻓﻴﺔ ﻭ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻟﻪ ﻣﻊ ][ charﻭ
char
*char
3
4
5
6
97
%o
ﻷﻋﺪﺍﺩ ﺍﻟﻨﻈﺎﻡ ﺍﻟﺜﻤﺎﱐ
%x
ﻷﻋﺪﺍﺩ ﺍﻟﻨﻈﺎﻡ ﺍﻟﺴﺪﺍﺳﻲ
%ld
ﻷﻋﺪﺍﺩ ﺻﺤﻴﺤﺔ ﻃﻮﻳﻠﺔ Long Decimalﻭ ﺗﺴﺘﻌﻤﻞ ﰲ
%lu
ﻷﻋﺪﺍﺩ ﻃﻮﻳﻠﺔ ﺑﺪﻭﻥ ﺇﺷﺎﺭﺓ
long int
long unsigned
ﺍﳉﺪﻭﻝ ٢,٩,١: ﺭﻣﻮﺯ ﺍﻟﺪﺍﻟﺔ
scanf
٩,٩,١ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ:
ﻻ ﺗﻮﺟﺪ ﺃﺧﻄﺎﺀ ﳏﺘﻤﻠﺔ ﰲ ﻫﺬﺍ ﺍﻟﺪﺭﺱ
...
ﺃﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻄﻠﺐ ﻣﻦ ﺍﳌﺴﺘﺨﺪﻡ ﺇﺩﺧﺎﻝ ﻋﺪﺩ، ﰒ ﻳﻘﻮﻡ ﺑﺎﻟﱪﻧﺎﻣﺞ ﺑﺈﺧﺒﺎﺭﻩ ﺇﻥ ﻛﺎﻥ ﺍﻟﻌﺪﺩ ﺍﻟﺬﻱ ﺃﺩﺧﻠﻪ ﻓﺮﺩﻱ ﺃﻭ
ﺯﻭﺟﻲ
...
٣
...
٥
...
h؟
ﻓﻴﻤﺎ ﺗﺴﺘﻌﻤﻞ ﺍﻟﻜﻠﻤﺎﺕ ﺍﶈﺠﻮﺯﺓ ﻭ ﺍﻟﺪﻭﺍﻝ ﺍﻟﻌﺮﻳﻀﺔ؟
ﳌﺎﺫﺍ ﻧﻘﻮﻡ ﺑﺈﺭﺟﺎﻉ ﻗﻴﻤﺔ ﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ﰲ ﺣﺎﻟﺔ ﺃﺎ ﰲ ﺍﻟﻮﺿﻊ ﺍﻻﻓﺘﺮﺍﺿﻲ، ﻭ ﻣﺎﺫﺍ ﺗﻌﲔ ﺗﻠﻚ ﺍﻟﻘﻴﻤـﺔ ﰲ ﺍﻟﺪﺍﻟـﺔ
ﺍﻟﺮﺋﻴﺴﻴﺔ؟
١,٢ ﺍﻟﻘﺮﺍﺭ
...
repeated loops
٣,٢ ﺍﳌﺼﻔﻮﻓﺎﺕ
...
pointers
٥,٢ ﺍﻟﺪﻭﺍﻝ
...
Header files
٧,٢ ﺍﻹﺩﺧﺎﻝ ﻭ ﺍﻹﺧﺮﺍﺝ ﰲ ﺍﳌﻠﻔﺎﺕ
...
structures
٩,٢ ﻣﻠﺨﺺ ﻟﻠﻔﺼﻞ ﺍﻟﺜﺎﱐ، ﻣﻌﺎ ﺇﺿﺎﻓﺎﺕ
...
C
ﺑﺎﻟﺘﻮﻓﻴﻖ ﺇﻥ ﺷﺎﺀ ﺍﷲ
ﻗﺎﻝ ﺍﷲ ﺗﻌﺎﱃ:
﴿ ﻭﻗﺎﻝ ﺍﻟﺬﻳﻦ ﺃﻭﺗﻮﺍ ﺍﻟﻌﻠﻢ ﻭﻳﻠﻜﻢ ﺛﻮﺍﺏ ﺍﷲ ﺧﲑ ﳌﻦ ﺁﻣﻦ ﻭﻋﻤﻞ ﺻﺎﳊﺎ ﴾
ﺻﺪﻕ ﺍﷲ ﺗﻌﺎﱃ
81
ﻹﺧﺘﺒﺎﺭ ﻗﻴﻤﺔ ﻣﺘﻐﲑﺓ ﻣﻊ ﻗﻴﻢ ﺛﺎﺑﺘﺔ ﺻﺤﻴﺤﺔ، ﺣﻴﺚ ﻛﻞ ﻗﻴﻤﺔ ﺛﺎﺑﺘﺔ ﺗﻌﺘﱪ ﻛﺸﺮﻁ ﺃﻭ ﻣﻘﺎﺭﻧﺔ
...
h>
main()
{
int num1, num2;
char Char;
printf("1:(+)\n2:(-)\n3:(/)\n4:(*)\nEnter a choice: ");
scanf("%c", &Char);
printf("Enter the first number: ");
scanf ("%d", &num1);
printf("Enter the second number: ");
scanf("%d", &num2);
if(Char == '+' || Char == '1')
printf("%d + %d = %d\n", num1, num2, num1+num2);
else if(Char == '-' || Char == '2')
printf("%d - %d = %d\n", num1, num2, num1-num2);
else if(Char == '/' || Char == '3')
printf("%d / %d = %d\n", num1, num2, num1/num2);
else if(Char == '*' || Char == '4')
printf("%d * %d = %d\n", num1, num2, num1*num2);
else
}
printf("Error in choice!\nExiting
...
h>
main()
{
int num1, num2;
char Char;
printf("1:(+)\n2:(-)\n3:(/)\n4:(*)\nEnter a choice: ");
scanf("%c", &Char);
28
;)" :printf("Enter the first number
;)1scanf ("%d", &num
;)" :printf("Enter the second number
;)2scanf("%d", &num
)switch(Char
{
:'+' case
:'1' case
;)2printf("%d + %d = %d\n", num1, num2, num1+num
;break
:'-' case
:'2' case
;)2printf("%d - %d = %d\n", num1, num2, num1-num
;break
:'/' case
:'3' case
;)2printf("%d / %d = %d\n", num1, num2, num1/num
;break
:'*' case
:'4' case
;)2printf("%d * %d = %d\n", num1, num2, num1*num
;break
:default
;)"printf("Error in choice!\nExiting
...
ﻟﻠﻘﺮﺍﺭ switchﻭﺳﻴﻂ، ﻭ ﺍﻟﺬﻱ ﻳﻘﻮﻡ ﺑﺘﺘﺒﻊ ﻧﺘﻴﺠﺔ ﺍﳌﺘﻐﲑ ﺍﳌﻮﺟﻮﺩ ﺩﺍﺧﻞ ﺍﻟﻮﺳﻴﻂ، ﰲ ﻣﺜﺎﻟﻨـﺎ ﺍﻟـﺴﺎﺑﻘﺔ
ﺍﺳﺘﻌﻤﺎﻟﻨﺎ ﺍﳌﺘﻐﲑ ،Charﻭ ﻟﻠﻘﺮﺍﺭ switchﺣﺎﻻﺕ، ﻭ ﻳﺘﻢ ﺗﻨﻔﻴﺬﻫﺎ ﺣﺴﺐ ﻧﺘﻴﺠﺔ ﺍﳌﺘﻐﲑ ﺍﳌﻮﺟﻮﺩ ﰲ ﺍﻟﻮﺳﻴﻂ
...
، ﻭ ﰲ ﺍﻟـﺴﻄﺮ
ﺍﻟﺜﺎﻣﻦ ﻭ ﺛﻼﺛﲔ ﲡﺪ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ defaultﻭ ﺳﻴﺘﻢ ﺗﻨﻔﻴﺬ ﻣﺎ ﻫﻮ ﺑﻌﺪﻫﺎ ﺇﻥ ﱂ ﻳﺘﺤﻘﻖ ﺃﻱ ﺷﺮﻁ ﻣﻦ ﺍﻟﺸﺮﻭﻁ ﺍﻟﺴﺎﺑﻘﺔ
...
:'+' case
:'1' case
;)2printf("%d + %d = %d\n", num1, num2, num1+num
;break
ﻫﺬﺍ ﰲ ﺍﻟﻘﺮﺍﺭ ،switchﺃﻣﺎ ﰲ ﺍﻟﻘﺮﺍﺭﺍﺕ
else, else…if
91
02
12
22
, ifﻓﻬﻮ:
)'1' == if(Char == '+' || Char
;)2printf("%d + %d = %d\n", num1, num2, num1+num
71
81
ﻭ ﻫﻨﺎ ﺳﺘﻼﺣﻆ ﺃﻥ ﺍﻟﺴﻄﺮﻳﻦ:
:'+' case
:'1' case
91
02
ﻫﻮ ﻧﻔﺴﻪ:
'1' == Char == '+' || Char
ﺃﻣﺎ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ :default
:default
;)"printf("Error in choice!\nExiting
...
\n
92
03
ﻭ ﰲ ﺍﻟﻘﺮﺍﺭ switchﻻ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻝ ﻣﺘﻐﲑ ﻣﻦ ﻧﻮﻉ ﺃﻋﺪﺍﺩ ﺣﻘﻴﻘﻴﺔ ﻣﺜﻞ floatﻭ )doubleﻫﻨﺎ ﺳﺘﻔﻀﻞ ifﻭ
...
ﻻ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻝ ﻧﺺ ﻟﻠﻤﻘﺎﺭﻧﺔ ﰲ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ ،caseﻷﺎ ﺗﺘﻌﺎﻣﻞ ﻣﻊ ﺍﻷﺭﻗﺎﻡ ﻭ ﺍﻷﺣﺮﻑ ﻓﻘـﻂ، ﺣـﱴ
ﺍﻟﻘﺮﺍﺭ switchﻻ ﳝﻜﻦ ﺇﻋﻄﺎﺋﻪ ﻣﺘﻐﲑ ﻣﻨﺖ ﻧﻮﻉ ﺳﻠﺴﻠﺔ ﺣﺮﻭﻑ، ﻫﻮ ﺃﻳﻀﺎ ﻻ ﻳﻘﺒﻞ ﺇﻻ ﲟﻐﲑﺍﺕ ﺍﻷﺣﺮﻑ ﻭ ﺍﻷﺭﻗﺎﻡ
...
switch
٣,١,٢ ﺍﻟﻜﻠﻤﺔ ﺍﻮﺯﺓ :default
ﺃﻳﻀﺎ ﺗﺴﺘﻌﻤﻞ ﻣﻊ ﺍﻟﻘﺮﺍﺭ switchﻭ ﻫﻲ ﺍﻟﻮﺿﻊ ﺍﻻﻓﺘﺮﺍﺿﻲ، ﺃﻱ ﺃﻧﻪ ﺇﻥ ﱂ ﺗﺘﺤﻘﻖ ﺃﻱ ﺣﺎﻟﺔ ﻣﻦ ﺍﳊﺎﻻﺕ ﺍﻟﺴﺎﺑﻘﺔ ﻓﺴﻴﺘﻢ
ﺗﻨﻔﻴﺬ ﻣﺎ ﻫﻮ ﺑﻌﺪﻫﺎ
...
ﰲ ﺣﺎﻟﺔ ﺃﻧﻚ ﺃﺭﺩﺕ ﺍﺳﺘﻌﻤﺎﻝ ﺍﳊﺎﻟﺔ ﻣﺒﺎﺷﺮﺓ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﺮﻗﻢ ﺑﻌﺪ caseﻓﻴﺠﺐ ﻋﻠﻴﻚ ﺍﺳﺘﻌﻤﺎﻝ ﻣﺘﻐﲑ ﻣﻦ ﻧـﻮﻉ
ﺃﻋﺪﺍﺩ ﺻﺤﻴﺤﺔ، ﻭ ﻟﻴﺲ ﻣﺘﻐﲑ ﺃﺣﺮﻑ ﻭ ﺍﳌﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ ﺳﻴﺼﺒﺢ ﻋﻠﻰ ﻫﺬﺍ ﺍﻟﺸﻜﻞ:
>#include
\n
}
ﺍﻟﱪﻧﺎﻣﺞ ٣,١,٢: ﺍﳋﻄﺄ ١
}
12
22
32
42
52
62
72
82
92
03
13
23
33
43
53
63
73
83
93
٢
...
٥,١,٢ ﲤﺎﺭﻳﻦ:
١- ﺃﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﺑﻪ ﻗﺎﺋﻤﺔ ﺭﺋﻴﺴﻴﺔ ﻟﻠﻌﺒﺔ، ﺣﻴﺚ ﺳﻴﻜﻮﻥ ﳍﺎ ﺃﺭﺑﻊ ﺧﻴﺎﺭﺍﺕ ﻭ ﻫﻲ:
ﺍﳋﻴﺎﺭ ﺍﻷﻭﻝ ﻫﻮ Start Gameﻭ ﻋﻨﺪ ﺍﺳﺘﻌﻤﺎﻝ ﻫﺬﺍ ﺍﳋﻴﺎﺭ ﳐﱪﻩ ﺑﺄﻥ ﺍﻟﻠﻌﺒﺔ ﻗﺪ ﺑﺪﺃ
...
ﺍﳋﻴﺎﺭ ﺍﻟﺜﺎﻟﺚ ﻫﻮ About
Gameﻭ ﺍﻟﱵ ﺳﺘﻀﻊ ﻓﻴﻬﺎ ﻣﻌﻠﻮﻣﺎﺕ ﻋﻨﻚ
...
ﺍﻵﻥ ﺳﺄﻋﻄﻲ ﻣﺜﺎﻝ ﺑﺴﻴﻂ ﺣﻮﻝ ﻃﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﻝ ﺍﻟﺘﻜﺮﺍﺭ ﺑﻮﺍﺳﻄﺔ ﺍﻟﻜﻠﻤﺔ
ﺍﶈﺠﻮﺯﺓ whileﺣﻴﺚ ﻳﻘﻮﻡ ﺑﻄﺒﺎﻋﺔ ﻋﺪ ﺗﺼﺎﻋﺪﻱ ﻣﻦ ١ ﺇﱃ ٣:
>#include
ﺍﳌﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ ﳌﺘﻐﲑ ﻣﻦ ﻧﻮﻉ ﻋﺪﺩ ﺻﺤﻴﺢ، ﺍﻵﻥ ﺳﺄﻋﻄﻲ ﻣﺜﺎﻝ ﺑﺴﻴﻂ ﻟﻄﺮﻳﻘـﺔ
ﺍﺳﺘﻌﻤﺎﻝ ﺍﻟﺘﻜﺮﺍﺭ ﳌﺘﻐﲑ ﺣﺮﰲ:
// Just in Windows and DOS OS compilers
>#include
h
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
61
71
81
>#include
h
1
2
3
4
)(main
{
;char ch
;)" :)printf("Press any key(q=exit
;)(ch = getche
)'while(ch != 'q
{
;)" :)printf("\nPress any key(q=exit
;)(ch = getche
}
;)"printf("\nExiting
...
q
ﳝﻜﻨﻨﺎ ﺍﻻﺳﺘﻐﻨﺎﺀ ﻋﻦ ﺍﻟﺸﺮﻁ ﰲ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ whileﻭ ﻛﺘﺎﺑﺘﻪ ﺩﺍﺧﻞ ﺍﻟـ blockﺍﳋﺎﺹ ﺎ ﺑﺎﺳﺘﻌﻤﺎﻝ ﺍﳌﻘﺎﺭﻧـﺔ ﻋـﱪ
ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ ifﺣﻴﺚ ﺳﻴﻜﻮﻥ ﺩﺍﺧﻞ ﺍﻟـ blockﺍﳋﺎﺹ ﺎ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ breakﻭ ﺍﻟﱵ ﻗﻠﻨﺎ ﻋﻠﻴﻬﺎ ﺳﺎﺑﻘﺎ ﺃﺎ ﺗﻨﻬﻲ
ﺍﳊﻠﻘﺎﺕ، ﻫﺬﺍ ﺍﳌﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ ﺑﻌﺪ ﺍﻟﺘﻌﺪﻳﻞ:
/* /* Just in Windows and DOS OS compilers
)(main
88
{
5
6
7
8
9
01
11
21
31
41
51
61
71
81
91
02
12
>#include
h
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
61
71
81
;char ch
;)" :)printf("Press any key(q=exit
;)(ch = getche
)1(while
{
)'if(ch == 'q
;break
;)" :)printf("\nPress any key(q=exit
;)(ch = getche
}
;)"printf("\nExiting!\n
}
ﺍﻟﱪﻧﺎﻣﺞ ٣,٢,٢: ﺍﻟﺘﻜﺮﺍﺭ ﺑﻮﺍﺳﻄﺔ (٣) while
ﻭ ﻫﻨﺎ ﺍﺳﺘﻌﻤﻠﻨﺎ ﺍﻟﺮﻗﻢ ١)ﻭ ﺍﻟﺬﻱ ﻳﻌﲏ trueﰲ ﻟﻐﺔ (Cﰲ ﻭﺳﻴﻂ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ whileﻛﻲ ﺗﻜﻮﻥ ﺍﳊﻠﻘﺔ ﺑﻼ ﺎﻳﺔ، ﻭ
ﻫﻨﺎ ﺳﺘﻼﺣﻆ ﺃﻥ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ breakﻻ ﺗﺴﺘﻌﻤﻞ ﻓﻘﻂ ﰲ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ
...
٢,٢,٢ ﺍﻟﺘﻜﺮﺍﺭ ﺑﻮﺍﺳﻄﺔ :do…while
98
ﻃﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﳍﺎ ﻣﺜﻞ ﺍﻟﻄﺮﻳﻘﺔ ﺍﻟﺴﺎﺑﻘﺔ ﻟـ whileﻣﻊ ﺑﻌﺾ ﺍﻹﺿﺎﻓﺎﺕ، ﻭ ﺍﻟﻔﺮﻕ ﺑﲔ do…whileﻭ whileﻫـﻮ ﺃﻥ
ﺍﻟﺘﻜﺮﺍﺭ ﺑﺎﺳﺘﺨﺪﺍﻡ whileﻻ ﻳﻘﻮﻡ ﺑﺘﻨﻔﻴﺬ ﺍﻷﻭﺍﻣﺮ ﺍﳌﻮﺟﻮﺩ ﻓﻴﻪ ﻭ ﻻ ﻣﺮﺓ ﻭﺍﺣﺪﺓ ﺇﻻ ﺇﺫﺍ ﻛﺎﻧﺖ ﺍﻟﺸﺮﻁ ﺻﺤﻴﺢ ﻣﺮﺓ ﻭﺍﺣﺪﺓ،
ﺃﻣﺎ ﺍﻟﺘﻜﺮﺍﺭ ﺑﻮﺍﺳﻄﺔ do…whileﻓﺴﻴﺘﻢ ﺗﻨﻔﻴﺬ ﺍﻷﻭﺍﻣﺮ ﺍﳌﻮﺟﻮﺩ ﺑﺎﻟـ blockﺍﳋﺎﺹ ﺑﻪ ﻣﺮﺓ ﻭﺍﺣﺪﺓ ﻋﻠﻰ ﺍﻷﻗﻞ ﺣـﱴ ﻭ ﺇﻥ
ﻛﺎﻥ ﺍﻟﺸﺮﻁ ﺧﺎﻃﺊ
...
h
>#include
h
>#include
\n
}
ﺍﻟﱪﻧﺎﻣﺞ ٦,٢,٢: ﺍﻟﺘﻜﺮﺍﺭ ﺑﻮﺍﺳﻄﺔ (٢) do…while
ﻫﻨﺎ ﺳﺘﺠﺪ ﺃﻥ ﻋﺪﺩ ﺍﻷﺳﻄﺮ ﻗﺪ ﻗﻞ، ﻭ ﻟﻜﻦ ﻻ ﺗﻮﺟﺪ ﻃﺮﻳﻘﺔ ﺃﺣﺴﻦ ﻣﻦ ﺍﻷﺧﺮﻯ ﻷﻥ ﻛﻞ ﻃﺮﻳﻘﺔ ﻭ ﻣﻜﺎﻥ ﺍﺳﺘﻌﻤﺎﳍﺎ
...
ﻟﻠﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ forﺛﻼﺛﺔ ﻭﺳﺎﺋﻂ ﻭ ﻳﺘﻢ ﺍﻟﻔﺼﻞ ﺑﻴﻨﻬﺎ ﺑﻔﺎﺻﻠﺔ ﻣﻨﻘﻮﻃﺔ ﲝﻴﺚ:
١
...
٣
...
h
>#include
ﺃﻣﺎ ﺑﺎﻟﻨﺴﺒﺔ ﳌﺜﺎﻝ ﺍﳌﺘﻐﲑ ﺍﳊﺮﰲ ﻓﺎﻟﻄﺮﻳﻘﺔ ﲣﺘﻠﻒ ﻗﻠﻴﻼ، ﺣﻴﺚ ﺳﻨﻘﻮﻡ ﺑﺎﻻﺳﺘﻐﻨﺎﺀ ﻋﻦ ﺍﻟﻮﺳﻴﻂ ﺍﻷﻭﻝ ﻭ ﺍﻷﺧﲑ، ﻭ ﺳﻨﺴﺘﻌﻤﻞ
ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ ﻟﻮﺿﻊ ﺍﻟﺸﺮﻁ ﺣﻴﺚ ﺇﻥ ﻛﺎﻥ ﺍﻟﺸﺮﻁ ﺧﺎﻃﺊ ﻳﺘﻢ ﺍﳋﺮﻭﺝ ﻣﻦ ﺍﳊﻠﻘﺔ، ﻭ ﺍﻟﺸﺮﻁ ﻫﻨﺎ ﻫﻮ ﺃﻥ ﻻ ﻳﺴﺎﻭﻱ ﺍﳌﺘﻐﲑ
chﺍﳊﺮﻑ ) qﺳﻴﺼﺒﺢ ﺍﻟﺸﺮﻁ ﺧﺎﻃﺊ ﺇﺫﺍ ﻛﺎﻥ ﺍﳌﺘﻐﲑ chﻳﺴﺎﻭﻱ ﺍﳊﺮﻑ ،(qﻭ ﺍﻟﱪﻧﺎﻣﺞ ﺳﻴﻜﻮﻥ ﻋﻠﻰ ﻫﺬﺍ ﺍﻟﺸﻜﻞ:
/* /* Just in Windows and DOS OS compilers
>#include
h
)(main
{
;char ch
;)" :)printf("Press any key(q=exit
;)(ch = getche
);'for(;ch!='q
{
;)" :)printf("\nPress any key(q=exit
;)(ch = getche
}
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
61
29
;)"printf("\nExiting
...
٤,٢,٢ ﺍﻟﺘﻜﺮﺍﺭ ﺑﻮﺍﺳﻄﺔ :goto
ﻫﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ ﺇﺿﺎﻓﻴﺔ، ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ gotoﺗﺴﺘﻌﻤﻞ ﻟـ ﺍﻟﺘﻨﻘﻞ ﻣﻦ ﻣﻜﺎﻥ ﻵﺧﺮ ﰲ ﻣﺼﺪﺭ ﺍﻟﱪﻧﺎﻣﺞ، ﺳﺄﺷـﺮﺡ ﺃﻭﻻ
ﻃﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﳍﺎ ﰒ ﻧﺬﻫﺐ ﺇﱃ ﺍﻟﺘﻜﺮﺍﺭ ﺑﻮﺍﺳﻄﺘﻬﺎ
...
h
)(main
{
;goto fin
;)"printf("Begin!\n
:fin
;)"printf("End!\n
ﺍﻟﱪﻧﺎﻣﺞ ٩,٢,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ
goto
}
1
2
3
4
5
6
7
8
9
01
39
ﻫﻨﺎ ﻋﻨﺪ ﺗﻨﻔﻴﺬ ﺍﻟﱪﻧﺎﻣﺞ ﺳﻴﺘﻢ ﲡﺎﻫﻞ ﻛﻞ ﻣﺎ ﺑﲔ goto the_name_of_placeﻭ ﺍﺳﻢ ﺍﳌﻜﺎﻥ، ﻭ ﻫﻨﺎ ﺍﺳﻢ ﺍﳌﻜﺎﻥ ﺍﻟﺬﻱ
ﻧﺮﻳﺪ ﺍﻻﻧﺘﻘﺎﻝ ﺇﻟﻴﻪ ﻫﻮ finﻭ ﻫﻮ ﻣﻮﺟﻮﺩ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﻣﻦ، ﻭ ﺃﺭﺩﻧﺎ ﺍﻟﺬﻫﺎﺏ ﺇﱃ ﺍﳌﻜﺎﻥ finﰲ ﺑﺪﺍﻳﺔ ﺍﻟﱪﻧﺎﻣﺞ
...
h
1
2
3
4
5
6
7
8
9
01
11
21
>#include
goto
٥,٢,٢ ﺍﳌﻔﻬﻮﻡ ﺍﻟﻌﺎﻡ ﳊﻠﻘﺎﺕ ﺍﻟﺘﻜﺮﺍﺭ:
}
goto
49
ﻟﻜﻲ ﺗﻔﻬﻢ ﺍﻟﺘﻜﺮﺍﺭ ﺑﺼﻔﺔ ﻋﺎﻣﺔ ﻓﻜﻞ ﻣﺎ ﻋﻠﻴﻚ ﻣﻌﺮﻓﺘﻪ ﻫﻮ:
١
...
٢
...
٣
...
ﻣﺜﺎﻟﻨﺎ ﺍﻷﻭﻝ ﰲ ﻫﺬﺍ ﺍﻟﺪﺭﺱ ﻫﻮ:
>#include
ﲨﻴـﻊ
ﺍﻟﻄﺮﻕ ﺍﻟﺴﺎﺑﻘﺔ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﳍﺎ ﺑﻄﺮﻳﻘﺔ ﺃﺧﺮﻯ، ﺣﻴﺚ ﳝﻜﻦ ﺃﻥ ﻧﻘﻮﻡ ﺑﻜﺘﺎﺑﺔ ﻛﻞ ﻣﻦ ﺑﺪﺍﻳﺔ ﺍﻟﻌﺪﺍﺩ ﻭ ﺍﻟﺸﺮﻁ ﻭ ﺍﳌﺆﺛﺮ ﺧﺎﺭﺝ
ﻭﺳﺎﺋﻂ ﻛﻞ ﻣﻦ ،while, do
...
h
1
2
3
4
5
6
7
8
9
01
11
21
31
>#include
٧,٢,٢ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ :continue
ﺗﺴﺘﻌﻤﻞ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ continueﺩﺍﺧﻞ ﺣﻠﻘﺎﺕ ﺍﻟﺘﻜﺮﺍﺭ، ﺣﻴﺚ ﺗﻘﻮﻡ ﺑﺎﻟﺮﺟﻮﻉ ﺇﱃ ﺑﺪﺍﻳﺔ ﺍﳊﻠﻘﺔ ﺑـﺪﻭﻥ ﺇﻛﻤـﺎﻝ
ﻣﺎﻫﻮ ﺑﻌﺪﻫﺎ ﻣﻦ ﺃﻭﺍﻣﺮ، ﻭ ﻛﻲ ﺗﻌﺮﻑ ﺃﳘﻴﺘﻬﺎ ﺟﺮﺏ ﺍﳌﺜﺎﻝ ﺍﻟﺘﺎﱄ:
>#include
h
1
2
3
4
5
6
7
8
9
01
11
21
31
)(main
{
;int i
;1 = i
)1(while
{
)3=<if(i
{
;)printf("\a%d ,", i
;++i
}
;)"printf(" Go!\n
;break
}
}
ﺍﻟﱪﻧﺎﻣﺞ ٥١,٢,٢: ﺍﻟﺘﻜﺮﺍﺭ ﺑﻮﺍﺳﻴﻄﺔ (٦) while
ﻫﺬﺍ ﺍﳌﺜﺎﻝ ﻟﻦ ﻳﻌﻤﻞ ﻛﻤﺎ ﻳﻨﺒﻐﻲ، ﻧﺮﻳﺪ ﻣﻦ ﺍﻟﱪﻧﺎﻣﺞ ﺃﻥ ﻳﻘﻮﻡ ﺑﻌﺪ ﺗﺼﺎﻋﺪﻱ ﻣﻦ ١ ﺇﱃ ٣ ﺃﻣﺎ ﻫﺬﺍ ﺍﻟﱪﻧﺎﻣﺞ ﻟﻦ ﻳﻄﺒﻊ ﺇﱃ ﺍﻟﻌﺪﺩ
١، ﻭ ﻛﻲ ﻳﻌﻤﻞ ﺍﻟﱪﻧﺎﻣﺞ ﺑﻄﺮﻳﻘﺔ ﺻﺤﻴﺤﺔ ﻧﻈﻴﻒ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ continueﺇﱃ ﰲ ﺎﻳﺔ ﺍﳌﻘﺎﺭﻧﺔ ﻭ ﺳﻴـﺼﺒﺢ ﺍﳌﺜـﺎﻝ
ﺍﻟﺴﺎﺑﻖ ﻛﻤﺎ ﻳﻠﻲ:
)(main
{
;int i
;1 = i
)1(while
{
)3=<if(i
{
;)printf("\a%d ,", i
;++i
89
;continue
}
;)"printf(" Go!\n
;break
}
ﺍﻟﱪﻧﺎﻣﺞ ٦١,٢,٢: ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ
}
41
51
61
71
81
91
02
12
continue
ﻭ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻝ ﺍﳌﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ ﻋﻠﻰ ﻛﻞ ﻣﻦ do…whileﻭ
...
h
)(main
{
;int i
)++for(i=0;i<=255;i
;)printf("%d: %c\n", i, i
ﺍﻟﱪﻧﺎﻣﺞ ٧١,٢,٢: ﻃﺒﺎﻋﺔ ﺟﺪﻭﻝ ASCIIﺑﺈﺳﺘﺨﺪﺍﻡ ﺣﻠﻘﺎﺕ ﺍﻟﺘﻜﺮﺍﺭ
}
1
2
3
4
5
6
7
8
9
01
ﻭ ﺳﺘﺠﺪ ﻋﻨﺪ ﺗﺸﻐﻴﻞ ﺍﻟﱪﻧﺎﻣﺞ ﺃﻥ ﺑﻌﺾ ﺍﻟﺮﻣﻮﺯ ﱂ ﺗﻄﺒﻊ ﻣﻨﻬﺎ ﺍﻟﺮﻗﻢ ٠ ﻭ ﺍﻟﺮﻗﻢ ٧، ٨، ٩، ٣١ ﻭ ﺃﺧﺮﻯ، ﻭ ﺳﺒﺐ ﰲ ﺫﻟﻚ
ﺃﺎ ﻻ ﺗﻘﻮﻡ ﺑﺄﻋﻤﺎﻝ ﻇﺎﻫﺮﺓ ﻓﻤﺜﻼ ﺍﻟﺮﻗﻢ ٠ ﻫﻮ ﺍﻟﺮﻣﺰ 0\ ﻭ ﺍﻟﺮﻗﻢ ٣١ ﻫﻮ ﺯﺭ ﺍﻟﺪﺧﻮﻝ ﰲ ﻟﻮﺣﺔ ﺍﳌﻔﺎﺗﻴﺢ)ﺃﻱ ﺳﻄﺮ ﺟﺪﻳﺪ(
...
٢
...
٤
...
ﳚﺐ ﺩﺍﺋﻤﺎ ﺍﻻﻧﺘﺒﺎﻩ ﺇﱃ ﺍﻟﺸﺮﻁ ﻭ ﻃﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﳍﺎ
...
ﺍﺳﺘﻌﻤﺎﻝ ﺣﻠﻘﺔ ﺍﻟﺘﻜﺮﺍﺭ forﻓﺎﺭﻏﺔ ﺍﻟﻮﺳﺎﺋﻂ ﺗﻨﺘﺞ ﺣﻠﻘﺔ ﻏﲑ ﻣﻨﺘﻬﻴﺔ، ﺣﻴﺚ ﺳﺘﻜﻮﻥ ﻋﻠﻰ ﺍﻟﺸﻜﻞ );;(
...
ﺍﺳﺘﻌﻤﺎﻝ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ continueﺑﺪﻭﻥ ﺷﺮﻁ)ﺃﻭ ﺗﻜﺮﺍﺭ ﺑﺪﻭﻥ ﺷﺮﻁ( ﻳﻌﲏ ﺣﻠﻘﺔ ﺑﻼ ﺎﻳﺔ
...
٢
...
ﻓﺎﺋﺪﺓ ﺍﳌﺼﻔﻮﻓﺎﺕ ﻛﺒﲑﺓ، ﻭ ﻃﺮﻕ ﺍﺳﺘﻌﻤﺎﳍﺎ
ﻛﺜﲑﺓ ﻭ ﻣﺘﻨﻮﻋﺔ، ﻭ ﻟﻜﻲ ﺗﺮﻯ ﻓﺎﺋﺪﺎ ﺑﺸﻜﻞ ﻛﺒﲑ ﻓﺘﺨﻴﻞ ﺃﻧﻪ ﻃﻠﺐ ﻣﻨﻚ ﺑﻨﺎﺀ ﺑﺮﻧﺎﻣﺞ ﺑﻪ ﺃﻛﺜﺮ ﻣﻦ ٠٢ ﻣﺘﻐﲑ ﻭ ﻛﻞ ﻣﺘﻐﲑ ﺑﻪ
ﻗﻴﻤﺔ ﺭﲟﺎ ﻧﻘﻮﻡ ﺑﺘﺤﺪﻳﺪﻫﺎ ﳓﻦ ﺃﻭ ﻳﻘﻮﻡ ﺑﺘﺤﺪﻳﺪﻫﺎ ﺍﳌﺴﺘﺨﺪﻡ، ﻭ ﺇﻟﻴﻚ ﺍﳌﺜﺎﻝ:
>#include
,arr
;)" :1printf("Arr
;)1scanf("%d", arr
;)" :2printf("Arr
;)2scanf("%d", arr
;)" :3printf("Arr
;)3scanf("%d", arr
;)" :4printf("Arr
;)4scanf("%d", arr
;)" :5printf("Arr
;)5scanf("%d", arr
...
...
...
...
ﲣﻴﻞ
...
ﻫﻨـﺎ
ﺗﻜﻤﻦ ﻓﺎﺋﺪﺓ ﺍﳌﺼﻔﻮﻓﺎﺕ، ﻃﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﻠﻬﺎ ﻭ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻬﺎ ﻣﺸﺎﺑﻪ ﻟﻄﺮﻳﻘﺔ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﳌﺘﻐﲑﺍﺕ، ﻛﻞ ﻣﺎ ﺳﺘﻔﻌﻠﻪ ﻫﻮ ﻛﺘﺎﺑـﺔ
ﻧﻮﻉ ﺍﳌﺼﻔﻮﻓﺔ ﰒ ﺍﲰﻬﺎ ﰒ ﻳﺄﰐ ﺣﺠﻤﻬﺎ ﻭ ﻫﺬﻩ ﺻﻮﺭﺓ ﺗﻮﺿﻴﺤﻴﺔ:
101
ﺍﻟﺸﻜﻞ ١,٣,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺼﻔﻮﻓﺔ
ﻭ ﺍﻵﻥ ﺳﺄﻛﺘﺐ ﺍﳌﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﳌﺼﻔﻮﻓﺎﺕ:
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
61
71
81
91
02
12
>#include
١,٣,٢ ﺃﺳﺎﺳﻴﺎﺕ ﰲ ﺍﳌﺼﻔﻮﻓﺎﺕ:
ﺇﺫﺍ ﻛﺎﻧﺖ ﻟﺪﻳﻦ ﻣﺼﻔﻮﻑ ﺎ ﺍﻟﻌﺪﺩ ٤ ﺃﻱ ]4[ int arrﻓﻬﺬﺍ ﻳﻌﲏ ﺃﻧﻨﺎ ﻗﻤﻨﺎ ﺑﺄﺧﺬ ﺃﺭﺑﻌﺔ ﺃﻣﺎﻛﻦ ﰲ ﺍﻟﺬﺍﻛﺮ ﻛﻞ ﻭﺍﺣﺪﺓ
ﻣﻬﻨﺎ ﲝﺠﻢ ﺍﳌﺘﻐﲑ ،intﺗﻮﺟﺪ ﻃﺮﻳﻘﺘﲔ ﻹﻋﻄﺎﺀ ﻗﻴﻤﺔ ﻟﻠﻤﺼﻔﻮﻓﺎﺕ، ﺍﻟﻄﺮﻳﻘﺔ ﺍﻷﻭﱃ ﻫﻲ ﻛﺘﺎﺑﺔ ﺍﳌﺼﻔﻮﻓﺔ ﰒ ﺑﻌﺪﻫﺎ ﻣﺒﺎﺷـﺮﺓ
ﺍﻟﻘﻴﻢ ﺍﻟﱵ ﺎ، ﻣﺜﺎﻝ ﺗﻮﺿﻴﺤﻲ:
>#include
ﻻ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻝ ﺍﳌﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ ﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ:
1
2
3
4
5
6
7
8
9
>#include
h
)(main
{
;]4[int arr
;01 = ]0[arr
;21 = ]1[arr
;31 = ]2[arr
;51 = ]3[arr
;)]3[printf("[%d][%d][%d][%d]\n", arr[0], arr[1], arr[2], arr
ﻭ ﻫﻲ ﺍﻟﻄﺮﻳﻘﺔ ﺍﻟﱵ ﺗﺴﺘﻌﻤﻞ ﺑﻜﺜﺮﺓ
...
ﻟﻜﺘﺎﺑﺔ ﻣﺼﻔﻮﻓﺔ ﺫﺍﺕ ﺑﻮﻋﺪﻳﻦ، ﺳـﻨﻜﺘﺐ ﻣـﺼﻔﻮﻓﺔ
ﻃﺒﻴﻌﻴﺔ ﰒ ﻧﻈﻴﻒ ﺇﻟﻴﻬﺎ ﺻﻒ ﺁﺧﺮ ﻭ ﻫﺬﺍ ﻣﺜﺎﻝ ﺳﺄﻗﻮﻡ ﺑﺸﺮﺣﻪ:
>#include
ﻣﺼﻔﻮﻓﺎﺕ ﺛﻨﺎﺋﻴﺔ ﺍﻷﺑﻌـﺎﺩ
ﻫﻲ ﺍﳌﺼﻔﻮﻓﺎﺕ ﺎ ﻣﺼﻔﻮﻓﺎﺕ، ﺃﻱ ﻣﺼﻔﻮﻓﺔ ﺭﺋﻴﺴﻴﺔ ﻭ ﻣﺼﻔﻮﻓﺔ ﺛﺎﻧﻮﻳﺔ، ﻓﺈﺫﺍ ﻛﺎﻧﺖ ﻟﺪﻳﻨﺎ ﻣﺼﻔﻮﻓﺔ ﺭﺋﻴﺴﻴﺔ ﲝﺠـﻢ ٢ ﻣـﻦ
ﻧﻮﻉ ﺃﻋﺪﺍﺩ ﺻﺤﻴﺤﺔ ﻭ ﻣﺼﻔﻮﻓﺔ ﺛﺎﻧﻮﻳﺔ ﲝﺠﻢ ٢ ﻓﻬﺬﺍ ﻳﻌﲏ ﺃﻥ ﺍﳌﺼﻔﻮﻓﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ﺍﻷﻭﱃ ﺗﻨﻘﺼﻢ ﺇﱃ ﻣﺼﻔﻮﻓﺘﲔ ﺛﺎﻧﻮﻳﺘﲔ، ﻭ
ﺍﳌﺼﻔﻮﻓﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ﺍﻟﺜﺎﻧﻴﺔ ﺃﻳﻀﺎ ﺗﻨﻘﺴﻢ ﺇﱃ ﻣﺼﻔﻮﻓﺘﲔ ﺛﺎﻧﻮﻳﺘﲔ
...
h
)(main
{
;}}04 ,03{ ,}02 ,01{{ = ]2[]2[int arr2d
;int i,j
)++for(i=0;i<=1;i
{
)++for(j=0;j<=1;j
{
;)]printf("arr2d[%d][%d] = %d\n", i, j, arr2d[i][j
}
}
ﺍﻟﱪﻧﺎﻣﺞ ٧,٣,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺼﻔﻮﻓﺎﺕ ﺛﻨﺎﺋﻴﺔ ﺍﻷﺑﻌﺎﺩ )٢(
ﻭ ﻫﻲ ﻣﺸﺎﺎ ﻟﻄﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﳍﺎ ﰲ ﺍﳌﺼﻔﻮﻓﺎﺕ ﺫﺍﺕ ﺑﻮﻋﺪ ﻭﺍﺣﺪ
...
h
)(main
{
;}}}08 ,07{,}06 ,05{{ ,}}04 ,03{,}02 ,01{{{ = ]2[]2[]2[int arr3d
;int i, j, k
)++for(i=0;i<=1;i
{
)++for(j=0;j<=1;j
{
)++for(k=0;k<=1;k
{
,printf("arr3d[%d][%d][%d] = %d\n", i, j, k
;)]arr3d[i][j][k
}
}
}
ﺍﻟﱪﻧﺎﻣﺞ ٨,٣,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺼﻔﻮﻓﺎﺕ ﺛﻼﺛﻴﺔ ﺍﻷﺑﻌﺎﺩ
}
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
61
71
81
91
ﻭ ﰲ ﺣﺎﻟﺔ ﺗﺮﻙ ﺍﳌﺴﺘﺨﺪﻡ ﻳﻘﻮﻡ ﺑﺈﺩﺧﺎﻝ ﺍﻟﻘﻴﻢ ﻧﻜﺘﺐ:
>#include
ﺳﺄﻋﻄﻲ ﺃﻣﺜﻠﺔ ﺣﻮﻝ ﺍﳌﺼﻔﻮﻓﺎﺕ ﺫﺍﺕ ﺣﺠﻢ ﻏﲑ ﻣﻌﺮﻭﻑ، ﰒ ﻧﻨﺎﻗﺸﻬﺎ:
>#include
ﻭ ﺗﺴﻤﻰ ﺑﺴﻼﺳﻞ
ﺣﺮﻓﻴﺔ ﻷﺎ ﰲ ﺍﳊﻘﻴﻘﺔ ﻫﻲ ﻋﺒﺎﺭﺓ ﻋﻦ ﺳﻼﺳﻞ ﺎ ﺃﻣﺎﻛﻦ ﻭ ﻛﻞ ﻣﻜﺎﻥ ﺑﻪ ﺣﺮﻑ، ﺭﻣﺰ، ﺃﻭ ﺭﻗﻢ، ﺗﻮﺟﺪ ﻃﺮﻕ ﻛﺜﲑﺓ ﻟﺘﻌﺎﻣﻞ
ﻣﻊ ﺍﻟﺴﻼﺳﻞ ﺍﳊﺮﻓﻴﺔ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﳌﺼﻔﻮﻓﺎﺕ ﻣﻨﻬﺎ:
ﺇﻋﻄﺎﺀ ﺣﺠﻢ ﳌﺼﻔﻮﻓﺔ ﻣﻦ ﻧﻮﻉ charﺣﻴﺚ ﻳﻜﻮﻥ ﺣﺠﻤﻬﺎ ﻫﻮ ﺍﳊﺪ ﺍﻷﻗﺼﻰ ﻟﻌﺪﺩ ﺍﳊﺮﻭﻑ ﺍﻟﱵ ﳝﻜﻦ ﺇﺩﺧﺎﳍـﺎ، ﻣﺜـﺎﻝ
ﺗﻮﺿﻴﺤﻲ:
>#include
h
)(main
{
;]41[char text
;'text[0] = 'H
;'text[1] = 'e
;'text[2] = 'l
;'text[3] = 'l
;'text[4] = 'o
;',' = ]5[text
;' ' = ]6[text
;'text[7] = 'w
;'text[8] = 'o
;'text[9] = 'r
;'text[10] = 'l
;'text[11] = 'd
;'!' = ]21[text
;'0\' = ]31[text
;)printf("%s\n", text
}
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
61
71
81
91
02
12
22
32
701
ﺍﻟﱪﻧﺎﻣﺞ ٢١,٣,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺳﻠﺴﻠﺔ ﺣﺮﻓﻴﺔ )٢(
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﻌﺸﺮﻳﻦ ﻗﻤﻨﺎ ﺑﺈﺿﺎﻓﺔ ﺍﻟﺮﻣﺰ 0\ ﻭ ﺍﻟﺬﻱ ﻳﻌﲏ ﺎﻳﺔ ﺍﻟﺴﻠﺴﻠﺔ، ﻭ ﻋﺪﻡ ﻭﺟﻮﺩﻩ ﺳﻴﻌﻄﻲ ﻧﺘﺎﺋﺞ ﻏﲑ ﻣﺮﻏﻮﺏ ﻓﻴﻬﺎ، ﺃﻣﺎ
ﰲ ﺍﻟﻄﺮﻳﻘﺔ ﺍﻷﻭﱃ ﻓﻴﻜﻔﻲ ﺃﻥ ﻧﻌﻄﻴﻪ ﻣﻜﺎﻥ ﺇﺿﺎﰲ ﻭ ﺳﻴﺘﻢ ﺇﺿﺎﻓﺘﻪ ﺗﻠﻘﺎﺋﻴﺎ، ﻭ ﺇﺫﺍ ﺍﻧﺘﺒﻬﺖ ﺇﱃ ﺍﳌﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ ﰲ:
;"!char text[14] = "Hello, World
5
ﻓﺴﺘﻼﺣﻆ ﺃﻥ ﻋﺪﺩ ﺍﻷﺣﺮﻑ ﻫﻮ ٣١ )ﺍﻟﻔﺮﺍﻍ ﻳﻌﺘﱪ ﺣﺮﻑ( ﻭ ﳓﻦ ﻗﻤﻨﺎ ﲝﺠﺰ ٤١ ﻣﻜﺎﻥ، ﺍﳌﻜﺎﻥ ﺍﻟﺮﺍﺑﻊ ﻋﺸﺮ ﺳﻴﻜﻮﻥ ﻟﺮﻣﺰ
0\ ﺣﻴﺚ ﺳﻴﺘﻢ ﺇﺿﺎﻓﺘﻪ ﺗﻠﻘﺎﺋﻴﺎ
...
h
)(main
{
;]552[char usr_name
;int i
;0 = i
;)" :printf("Your name
;)scanf("%s", &usr_name
)'0\' =! ]while(usr_name[i
{
;++i
}
;)printf("%s = %d characters\n", usr_name, i
ﺍﻟﱪﻧﺎﻣﺞ ٣١,٣,٢: ﺣﺴﺎﺏ ﻋﺪﺩ ﺃﺣﺮﻑ ﺇﺳﻢ ﻣﺴﺘﺨﺪﻡ
}
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
61
71
81
ﰲ ﺍﻟﺴﻄﺮ ﺍﳋﺎﻣﺲ ﻗﻤﻦ ﺑﺎﻹﻋﻼﻥ ﻋﻦ ﺳﻠﺴﻠﺔ ﺣﺮﻓﻴﺔ ﺑﺎﺳﻢ ،usr_nameﲝﺠﻢ ٥٥٢ ﻣﻜﺎﻥ ﻭ ﻫﻮ ﺃﻗﺼﻰ ﺍﺣﺘﻤﺎﻝ ﳝﻜـﻦ
ﺍﻟﻮﺻﻮﻝ ﺇﻟﻴﻪ، ﺣﻴﺚ ﺳﺘﻜﻮﻥ ﺗﻠﻚ ﺍﻟﺴﻠﺴﻠﺔ ﻫﻲ ﺍﳌﻜﺎﻥ ﺍﻟﺬﻱ ﺳﻨﻀﻊ ﻓﻴﻪ ﺍﺳﻢ ﺍﳌﺴﺘﺨﺪﻡ، ﻭ ﰲ ﺍﻟـﺴﻄﺮ ﺍﻟـﺴﺎﺩﺱ ﻗﻤـﻦ
ﺑﺎﻹﻋﻼﻥ ﻋﻦ ﻣﺘﻐﲑ ﻭ ﺍﻟﺬﻱ ﺳﻴﻜﻮﻥ ﺍﻟﻌﺪﺍﺩ ﻻﺳﻢ ﺍﳌﺴﺘﺨﺪﻡ، ﰒ ﺃﻋﻄﻴﻨﺎﻩ ﺍﻟﻘﻴﻤﺔ ﺻﻔﺮ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟـﺴﺎﺑﻊ، ﰒ ﻃﻠﺒﻨـﺎ ﻣـﻦ
ﺍﳌﺴﺘﺨﺪﻡ ﺇﺩﺧﺎﻝ ﺍﲰﻪ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺘﺎﺳﻊ، ﻭ ﺧﺬﻧﺎ ﺍﺳﻢ ﺍﳌﺴﺘﺨﺪﻡ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﻌﺎﺷﺮ ﺣﻴﺚ ﺳﺘﺠﺪ ﺍﻟﺮﻣﺰ %sﻭ ﺍﳊـﺮﻑ s
ﳐﺘﺼﺮ ﻣﻦ stringﻭ ﻫﻮ ﺍﻟﺮﻣﺰ ﺍﳋﺎﺹ ﺑﺎﻟﺴﻼﺳﻞ ﺍﳊﺮﻓﻴﺔ، ﻭ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﱐ ﻋﺸﺮ ﻗﻤﻨﺎ ﺑﺈﻧﺸﺎﺀ ﺣﻠﻘﺔ ﻻ ﺗﻨﺘﻬﻲ ﺇﻻ ﺑﺎﻧﺘـﻬﺎﺀ
ﺍﺳﻢ ﺍﳌﺴﺘﺨﺪﻡ، ﻭ ﻛﻲ ﺗﻔﻬﻢ ﻫﺬﻩ ﺍﻷﺧﲑﺓ ﺇﻟﻴﻚ ﺍﻟﺼﻮﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ:
801
ﺍﻟﺸﻜﻞ ٢,٣,٢: ﻃﺮﻳﻘﺔ ﻭﺿﻊ ﺍﻟﺒﻴﺎﻧﺎﺕ ﰲ ﺍﳌﺼﻔﻮﻓﺎﺕ
ﻭ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ ﻋﺸﺮ ﻳﻘﻮﻡ ﺍﻟﱪﻧﺎﻣﺞ ﺑﻄﺒﺎﻋﺔ ﺍﺳﻢ ﺍﳌﺴﺘﺨﺪﻡ ﻭ ﻋﺪﺩ ﺃﺣﺮﻓﻪ
...
h
)(main
{
;]552[char usr_name
;int i
;0 = i
;)" :printf("Your Fullname
;)scanf("%s", &usr_name
)'0\'=!]while(usr_name[i
{
;)]printf("%i: %c\n", i+1, usr_name[i
;++i
}
;)printf("%s = %d characters\n", usr_name, i
ﺍﻟﱪﻧﺎﻣﺞ ٤١,٣,٢: ﺣﺴﺎﺏ ﻋﺪﺩ ﺃﺣﺮﻑ ﺇﺳﻢ ﻣﺴﺘﺨﺪﻡ )٢(
}
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
61
71
81
91
901
١,٤,٣,٢ ﺍﻟﺪﺍﻟﺔ :gets
ﲢﺪﺛﻨﺎ ﻋﻦ ﺍﻟﺪﺍﻟﺔ getsﰲ ﺍﻟﻔﺼﻞ ﺍﻷﻭﻝ، ﻭ ﻟﻜﻨﻨﺎ ﱂ ﻧﺘﺤﺪﺙ ﻋﻦ ﻃﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﳍﺎ
...
h
)(main
{
;]552[char usr_name
;)":puts("Your name
;)gets(usr_name
;)"puts("nice to meet you
;)puts(usr_name
ﺍﻟﱪﻧﺎﻣﺞ ٥١,٣,٢: ﺍﻟﺪﺍﻟﺔ
}
1
2
3
4
5
6
7
8
9
01
11
21
gets
ﻭ ﺍﻟﻔﺮﻕ ﺑﲔ ﺍﻟﺪﺍﻟﺔ scanfﻭ ﺍﻟﺪﺍﻟﺔ getsﻫﻮ ﻋﻨﺪ ﺇﺩﺧﺎﻝ ﺍﻷﲰﺎﺀ، ﰲ ﺍﻟﺪﺍﻟﺔ getsﺇﻥ ﻛﺘﺒﺖ ﺍﲰﲔ ﻭ ﻓـﺼﻠﺖ ﺑﻴﻨـﻬﻤﺎ
ﺑﻔﺮﺍﻍ ﻓﺴﻴﻘﻮﻡ ﺑﻄﺒﺎﻋﺔ ﻛﻼﳘﺎ، ﺃﻣﺎ ﰲ ﺍﻟﺪﺍﻟﺔ scanfﻓﺈﻧﻪ ﺳﺘﺘﻮﻗﻒ ﻋﻨﺪ ﺍﻟﻔﺮﺍﻍ ﺍﻷﻭﻝ ﻭ ﺗﻘﻮﻡ ﺑﻄﺒﻊ ﻣﺎ ﻫﻮ ﻗﺒﻞ ﺍﻟﻔـﺮﺍﻍ ﻻ
ﺃﻛﺜﺮ
...
hﺣﻴﺚ ﺑﻪ ﳎﻤﻮﻋﺔ ﻣﻦ ﺍﻟﺪﻭﺍﻝ ﺍﳋﺎﺻﺔ ﺑﺎﻟﺘﻌﺎﻣـﻞ ﻣـﻊ ﺍﻟـﺴﻼﺳﻞ
ﺍﳊﺮﻓﻴﺔ، ﻭ ﺍﺳﻢ ﺍﻟﺪﺍﻟﺔ ﳐﺘﺼﺮ ﻣﻦ ،string copyﻭ ﻫﻲ ﺗﻘﻮﻡ ﺑﻨﺴﺦ ﻭ ﻟﺼﻖ ﺍﳊﺮﻭﻑ ﻣﻦ ﺳﻠﺴﻠﺔ ﺇﱃ ﺃﺧﺮﻯ، ﻣﺜﺎﻝ:
>#include
h
)(main
{
;"!char String[] = "String
;]02[char Empty_String
;)strcpy(Empty_String, String
;)printf("Empty_String = %s\n", Empty_String
ﺍﻟﱪﻧﺎﻣﺞ ٦١,٣,٢: ﺍﻟﺪﺍﻟﺔ
strcpy
}
1
2
3
4
5
6
7
8
9
01
11
21
011
ﺍﻟﻮﺳﻴﻂ ﺍﻷﻭﻝ ﻣﻦ ﺍﻟﺪﺍﻟﺔ ﻧﻘﻮﻡ ﺑﺎﻟﻜﺘﺎﺑﺔ ﻓﻴﻪ ﺍﺳﻢ ﺍﻟﺴﻠﺴﻠﺔ ﺍﳊﺮﻓﻴﺔ ﺍﻟﱵ ﻧﺮﻳﺪ ﺃﻥ ﻧﻨﺴﺦ ﺎ ﺍﻟﻨﺺ، ﻭ ﰲ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ ﻧﻜﺘﺐ
ﺍﻟﺴﻠﺴﻠﺔ ﺍﻟﱵ ﻧﺮﻳﺪ ﻧﺴﺨﻬﺎ
...
hﻭ ﻫﻲ ﻣﺜـﻞ ﺍﻟﺪﺍﻟـﺔ ﺍﻟـﺴﺎﺑﻘﺔ
strcpyﻣﻊ ﺇﺿﺎﻓﺔ ﺑﺴﻴﻄﺔ ﻭ ﻫﻲ ﲢﺪﻳﺪ ﻋﺪﺩ ﺍﻷﺣﺮﻑ ﺍﻟﱵ ﻧﺮﻳﺪ ﻧﺴﺨﻬﺎ، ﻣﺜﺎﻝ:
>#include
h
)(main
{
;"!char String[] = "String
;]02[char Empty_String
;)3 ,strncpy(Empty_String, String
;)printf("Empty_String = %s\n", Empty_String
ﺍﻟﱪﻧﺎﻣﺞ ٧١,٣,٢: ﺍﻟﺪﺍﻟﺔ
}
1
2
3
4
5
6
7
8
9
01
11
21
strncpy
ﰲ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﻟﺚ ﻣﻦ ﺍﻟﺪﺍﻟﺔ strncpyﻧﻘﻮﻡ ﺑﺘﺤﺪﻳﺪ ﻋﺪﺩ ﺍﻷﺣﺮﻑ ﺍﻟﱵ ﻧﺮﻳﺪ ﻧﺴﺨﻬﺎ
...
h
>#include
hﻭ ﻫﻲ ﳐﺘﺼﺮﺓ ﻣﻦ
ﻭ ﺇﺿﺎﻓﺘﻪ ﰲ ﺎﻳﺔ ﺳﻠﺴﻠﺔ ﺣﺮﻓﻴﺔ، ﻣﺜﺎﻝ:
concatenate
،stringﻭ ﻫﻲ ﺗﻘﻮﻡ ﻧﺴﺦ ﻧﺺ
>#include
h
)(main
{
;"!char String[20] = "String
;)"2strcat(String, ", String
1
2
3
4
5
6
7
8
111
;)printf("String = %s\n", String
ﺍﻟﱪﻧﺎﻣﺞ ٩١,٣,٢: ﺍﻟﺪﺍﻟﺔ
}
9
01
11
strcat
ﰲ ﺍﻟﻮﺳﻴﻂ ﺍﻷﻭﻝ ﻣﻦ ﺍﻟﺪﺍﻟﺔ strcatﻧﻘﻮﻡ ﺑﻜﺘﺎﺑﺔ ﺍﺳﻢ ﺍﻟﺴﻠﺴﻠﺔ ﺍﻟﱵ ﺳﻨﻀﻴﻒ ﺇﻟﻴﻬﺎ ﺍﻟﻨﺺ، ﻭ ﰲ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜـﺎﱐ ﻧﻘـﻮﻡ
ﺑﻜﺘﺎﺑﺔ ﺍﻟﻨﺺ
...
h
>#include
٥,٣,٢ ﻃﺮﻕ ﺃﺧﺮﻯ ﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﳌﺼﻔﻮﻓﺎﺕ:
ﳝﻜﻨﻨﺎ ﻛﺘﺎﺑﺔ
01 =
)0+ *(arrﰲ ﻣﻜﺎﻥ
01 =
]0[ ،arrﺣﻴﺚ ﺃﺎ ﻣﻜﺎﻓﺌﺔ ﻟﻠﺴﺎﺑﻘﺔ، ﻭ ﻫﺬﺍ ﻣﺜﺎﻝ ﻃﺒﻴﻌﻲ:
>#include
h
)(main
{
;]1[int arr
1
2
3
4
5
211
;01 = )0+*(arr
;))0+printf("%d\n", *(arr
}
6
7
8
9
ﺍﻟﱪﻧﺎﻣﺞ ٢٢,٣,٢: ﻃﺮﻕ ﺃﺧﺮﻯ ﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﳌﺼﻔﻮﻓﺎﺕ )٢(
ﺍﻟﺸﻔﺮﺓ ]0[ arrﻫﻲ ﻧﻔﺴﻬﺎ ﺍﻟﺸﻔﺮﺓ )0+
...
h
)(main
{
;]2[int arr
;01 = ]0+0[arr
/* ;)]0[printf("%d\n", arr[0+0]); /* or printf("%d\n", arr
;02 = ]0-0[arr
/* ;)]0[printf("%d\n", arr[0-0]); /* or printf("%d\n", arr
;03 = ]1*1[arr
/* ;)]1[printf("%d\n", arr[1*1]); /* or printf("%d\n", arr
;04 = ]1/1[arr
/* ;)]1[printf("%d\n", arr[1/1]); /* or printf("%d\n", arr
٦,٣,٢ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ:
ﺍﻟﱪﻧﺎﻣﺞ ٣٢,٣,٢: ﻃﺮﻕ ﺃﺧﺮﻯ ﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﳌﺼﻔﻮﻓﺎﺕ )٣(
}
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
61
71
81
١
...
ﻭ ﺍﻟﻄﺮﻗﺔ ﺍﻟﺼﺤﻴﺤﺔ ﻟﻠﻤﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ
ﻫﻲ:
; ]2[int arr
; 01 = ]0[arr
; 02 = ]1[arr
311
٢
...
0\
٣
...
٧,٣,٢ ﲤﺎﺭﻳﻦ:
١
...
(gets
٢
...
٣
...
puts
411
ﻛﻠﻤﺔ ﻣﺆﺷﺮ ﺗﻌﲏ ﺍﻹﺷﺎﺭﺓ ﺇﱃ ﺷﻲﺀ، ﻭ ﰲ ﻟﻐﺔ Cﺍﳌﺆﺷﺮﺍﺕ ﺗﺸﲑ ﺇﱃ ﻋﻨﺎﻭﻳﻦ ﰲ ﺍﻟﺬﺍﻛﺮﺓ
...
ﻭ ﺗﻮﺟﺪ ﻣﻼﺣﻈﺔ ﻫﻨﺎ ﻭ ﻫﻲ ﺃﻥ ﺍﳌﺆﺷﺮﺍﺕ ﰲ ﺍﻷﻧﻈﻤﺔ ﺍﳊﺪﻳﺚ ﻻ ﳝﻜﻦ ﺇﻋﻄﺎﺋﻬﺎ ﻋﻨﺎﻭﻳﻦ ﻋﺸﻮﺍﺋﻴﺔ )ﺇﻻ
ﰲ ﺣﺎﻻﺕ ﺧﺎﺻﺔ( ﻭ ﺫﻟﻚ ﻟﺘﺸﺪﺩ ﺍﳊﻤﺎﻳﺔ ﻓﻴﻬﺎ
...
١,٤,٢ ﻧﻮﻉ ﺍﳌﺆﺷﺮ :Pointer Type
ﻧﻮﻉ ﺍﳌﺆﺷﺮ ﻳﻜﻮﻥ ﺣﺴﺐ ﺭﻏﺒﻨﺎ، ﻣﺜﻼ ﻟﻮ ﺃﺭﺩﻧﺎ ﺍﻹﺷﺎﺭﺓ ﺇﱃ ﻣﺘﻐﲑ ﺣﺠﻤﻪ ٢ ﺑﺎﻳﺖ ﻓﻴﺠﺐ ﻋﻠﻴﻨﺎ ﺍﻹﻋﻼﻥ ﻋـﻦ ﻣﺆﺷـﺮ
ﳝﻜﻨﻪ ﺍﻟﻮﺻﻮﻝ ﺇﱃ ٢ ﺑﺎﻳﺖ ﻣﻦ ﺍﻟﺬﺍﻛﺮﺓ
...
long, short, unsigned, signed, char
٢,٤,٢ ﺍﺳﻢ ﺍﳌﺆﺷﺮ :Pointer Name
ﻻﺳﻢ ﺍﳌﺆﺷﺮ ﺷﺮﻭﻁ ﻫﻲ ﻧﻔﺴﻬﺎ ﺷﺮﻭﻁ ﺍﳌﺘﻐﲑﺍﺕ ﻭ ﻫﻲ:
§ ﺃﻥ ﻻ ﻳﺘﺠﺎﻭﺯ ﺍﺳﻢ ﺍﳌﺆﺷﺮ ﺃﻛﺜﺮ ﻣﻦ ١٣ ﺣﺮﻑ
...
§ ﺃﻥ ﻻ ﻳﻜﻮﻥ ﺍﺳﻢ ﺍﳌﺆﺷﺮ ﳛﺘﻮﻱ ﻋﻠﻰ ﻣﺆﺛﺮﺍﺕ ﻣﺜﻞ ﺍﳉﻤﻊ ﻭ ﺍﻟﻄﺮﺡ ﻭ
...
)ﺑﺎﺳﺘﺜﻨﺎﺀ ﺍﻟﺮﻣﺰ _(
...
§ ﺃﻥ ﻻ ﻳﻜﻮﻥ ﺍﺳﻢ ﺍﳌﺆﺷﺮ ﻣﻦ ﺃﲰﺎﺀ ﺍﻟﻜﻠﻤﺎﺕ ﺍﶈﺠﻮﺯﺓ
...
h
)(main
{
;int *ptr, i
;01 = i
;ptr = &i
;)printf("*ptr = %d\n", *ptr
}
ﺍﻟﱪﻧﺎﻣﺞ ١,٤,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺆﺷﺮ
1
2
3
4
5
6
7
8
9
01
ﺍﳌﺆﺷﺮ ﻣﻮﺟﻮﺩ ﰲ ﺍﻟﺴﻄﺮ ﺍﳋﺎﻣﺲ ﻣﻊ ﻣﺘﻐﲑ، ﺍﺳﻢ ﺍﳌﺆﺷﺮ ﻫﻮ ptrﻭ ﺍﺳﻢ ﺍﳌﺘﻐﲑ ﻫﻮ ،iﺃﻋﻄﻴﻨﺎ ﻟﻠﻤﺘﻐﲑ iﺍﻟﻘﻴﻤـﺔ ٠١ ﰲ
ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺩﺱ، ﻭ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ ﺃﻋﻄﻴﻨﺎ ﻟﻠﻤﺆﺷﺮ ptrﻋﻨﻮﺍﻥ ﺍﳌﺘﻐﲑ iﺃﻱ ﺃﻧﻪ ﻋﻨﺪ ﻛﺘﺎﺑﺔ &Variable_Nameﻓﻬـﺬﺍ
ﻳﻌﲏ ﻋﻨﻮﺍﻥ ﻣﺘﻐﲑ، ﻭ ﺃﺧﲑﺍ ﺍﻟﺴﻄﺮ ﺍﻟﺘﺎﺳﻊ ﺣﻴﺚ ﻛﺘﺒﺘﺎ *ptrﻭ ﺍﻟﺬﻱ ﻳﻌﲏ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻮﺟﻮﺩ ﰲ ﻋﻨﻮﺍﻥ ﺍﳌﺆﺷـﺮ ،ptrﻭ ﰲ
ﺣﺎﻟﺔ ﺃﻧﻨﺎ ﻛﺘﺒﻨﺎ ﺍﺳﻢ ﺍﳌﺆﺷﺮ ﺑﺪﻭﻥ ﻣﺆﺛﺮ ﺍﻟﻀﺮﺏ ﻓﺴﻴﺘﻢ ﻃﺒﺎﻋﺔ ﻋﻨﻮﺍﻥ ﺍﳌﺆﺷﺮ
...
h
)(main
{
;int *ptr, i
;01 = i
;ptr = &i
;001 = *ptr
;)printf("*ptr = %d\n", *ptr
ﺍﻟﱪﻧﺎﻣﺞ ٢,٤,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﻣﺆﺷﺮ
}
1
2
3
4
5
6
7
8
9
01
11
ﻫﻨﺎ ﳝﻜﻨﻨﺎ ﺇﻋﻄﺎﺀ ﻗﻴﻤﺔ ﻟﻠﻤﺆﺷﺮ ptrﻷﻧﻪ ﻟﺪﻳﻪ ﻋﻨﻮﺍﻥ ﻭ ﻫﻮ ﻋﻨﻮﺍﻥ ﺍﳌﺘﻐﲑ ،iﻭ ﺳﻴﻘﻮﻡ ﲝﺬﻑ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺴﺎﺑﻘﺔ ﺍﳌﻮﺟـﻮﺩ ﰲ
ﻋﻨﻮﺍﻥ iﻭ ﻳﻘﻮﻡ ﺑﺘﺤﺪﻳﺜﻬﺎ ﺇﱃ ﺍﻟﻌﺪﺩ ٠٠١
...
h
)(main
{
;int *ptr, i
;01 = i
;ptr = &i
;)printf("i = %d\n", i
;)printf("*ptr = %d\n", *ptr
;)printf("&i = %p\n", &i
;)printf("ptr = %p\n", ptr
}
1
2
3
4
5
6
7
8
9
01
11
21
31
ﺍﻟﱪﻧﺎﻣﺞ ٣,٤,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﻣﺆﺷﺮ )٢(
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺘﺎﺳﻊ ﻭ ﺍﻟﻌﺎﺷﺮ ﻗﻤﻨﺎ ﺑﻄﺒﺎﻋﺔ ﻛﻞ ﻣﻦ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻮﺟﻮﺩﺓ ﰲ ﺍﳌﺘﻐﲑ iﻭ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻮﺟﻮﺩ ﰲ ﻋﻨﻮﺍﻥ ﺍﳌﺆﺷـﺮ ptrﻭ
ﻟﻜﻲ ﻧﺮﻯ ﻗﻴﻤﺔ ﻣﻮﺟﻮﺩﺓ ﺩﺍﺧﻞ ﻣﺆﺷﺮ ﻧﻜﺘﺐ ﻣﺆﺛﺮ ﺍﻟﻀﺮﺏ ﻗﺒﻞ ﺍﲰﻪ ﻭ ﺃﻳﻀﺎ ﳝﻜﻨﻨﺎ ﻭﺿﻊ ﻗﻴﻤﺔ ﻟﻪ ﺑﻨﻔﺲ ﺍﻟﻄﺮﻳﻘﺔ )ﳚﺐ ﺃﻥ
ﻳﻜﻮﻥ ﻟﺪﻳﻪ ﻋﻨﻮﺍﻥ ﻛﻲ ﻧﺴﺘﻄﻴﻊ ﻭﺿﻊ ﻟﻪ ﻗﻴﻤﺔ(، ﻭ ﰲ ﺍﻟﺴﻄﺮ ﺍﳊﺎﺩﻱ ﻋﺸﺮ ﻭ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﱐ ﻋﺸﺮ ﻗﻤﻨﺎ ﺑﻄﺒﺎﻋﺔ ﻛـﻞ ﻣـﻦ
ﻋﻨﻮﺍﻥ ﺍﳌﺘﻐﲑ iﻭ ﻋﻨﻮﺍﻥ ﺍﳌﺆﺷﺮ ،ptrﻭ ﺗﻼﺣﻆ ﺃﻧﻪ ﻭﺿﻌﻨﺎ ﺍﻟﺮﻣﺰ %pﻭ ﻫﻮ ﳐﺘﺼﺮ ﻣﻦ pointerﻭ ﳝﻜﻦ ﺍﺳـﺘﻌﻤﺎﻟﻪ ﻣـﻊ
ﺍﳌﺆﺷﺮﺍﺕ ﺃﻭ ﻋﻨﻮﺍﻥ ﳌﺘﻐﲑ ﺣﻴﺚ ﻗﻤﻨﺎ ﺑﺎﺳﺘﻌﻤﺎﻟﻪ ﻛﻲ ﻳﺘﻢ ﻃﺒﺎﻋﺔ ﺍﻟﻌﻨﺎﻭﻳﻦ ﺑﺸﻜﻞ ﺻﺤﻴﺢ
...
ﻭ ﻫﻨﺎ ﻣﺜﺎﻝ ﻳﻮﺿﺢ ﺍﻟﺸﺒﻪ ﺑﲔ ﺍﳌﺆﺷﺮﺍﺕ ﻭ ﺍﳌﺼﻔﻮﻓﺎﺕ:
711
>#include
ptrﻭ ﳝﻜﻨﻨﺎ ﻛﺘﺎﺑﺔ ﺍﳌﺜﺎﻝ ﺍﻟﺴﺒﺎﻕ ﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ:
>#include
h
)(main
{
;]2[int arr
;int *ptr
;01 = ]0[arr
;02 = ]1[arr
1
2
3
4
5
6
7
8
9
811
;]0[ptr = &arr
;)printf("%d\n", *ptr
;)printf("%d\n", *++ptr
}
ﺍﻟﱪﻧﺎﻣﺞ ٦,٤,٢: ﻃﺮﻳﻘﺔ ﺃﺧﺮﻯ ﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﳌﺆﺷﺮﺍﺕ )٢(
ﻭ ﻫﺬﺍ ﻣﺜﺎﻝ ﻻ ﳝﻜﻦ ﺗﻄﺒﻴﻘﻪ ﻋﻠﻰ ﺍﳌﺼﻔﻮﻓﺎﺕ:
>#include
h
)(main
{
;"!char *str = "Hello, World
;)printf("%s\n", str
ﺍﻟﱪﻧﺎﻣﺞ ٨,٤,٢: ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﻟﻨﺼﻮﺹ ﺑﺈﺳﺘﺨﺪﺍﻡ ﺍﳌﺆﺷﺮﺍﺕ
}
1
2
3
4
5
6
7
8
ﺃﻣﺎ ﺇﺫﺍ ﺃﺭﺩﻧﺎ ﺍﺳﺘﺨﺪﺍﻡ ﺍﳌﺆﺷﺮﺍﺕ ﰲ ﺍﻹﺩﺧﺎﻝ ﻓﻴﻮﺟﺪ ﺷﺮﻭﻁ ﳚﺐ ﺍﻟﺘﻘﻴﺪ ﺎ ﻭ ﺇﻻ ﺳﺘﺤﺪﺙ ﺃﺧﻄﺎﺀ ﺭﲟﺎ ﰲ ﺍﳌﺼﺪﺭ ﺍﻟﱪﻧﺎﻣﺞ
ﺃﻭ ﺃﺛﻨﺎﺀ ﺗﺸﻐﻴﻞ ﺍﻟﱪﻧﺎﻣﺞ، ﻓﻤﺜﻼ ﻻ ﳝﻜﻨﻨﺎ ﺍﺳﺘﻌﻤﺎﻝ ﻣﺜﻞ ﻣﺎ ﻫﻮ ﰲ ﺍﳌﺜﺎﻝ ﺍﻟﺘﺎﱄ:
>#include
h
)(main
{
;char *str
;char adr_str
;str = &adr_str
;)" :printf("Enter a string
;)scanf("%s", str
;)printf("%s\n", str
ﺍﻟﱪﻧﺎﻣﺞ ٠١,٤,٢: ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﻟﻨﺼﻮﺹ ﺑﺈﺳﺘﺨﺪﺍﻡ ﺍﳌﺆﺷﺮﺍﺕ )٣(
}
1
2
3
4
5
6
7
8
9
01
11
21
31
41
ﻭ ﺳﺘﻼﺣﻆ ﰲ ﺍﻟﺴﻄﺮ ﺍﳊﺎﺩﻱ ﻋﺸﺮ ﻗﻤﻨﺎ ﺑﻜﺘﺎﺑﺔ strﺑﺪﻭﻥ ﺍﻟﺮﻣﺰ &، ﺫﻟﻚ ﻷﻧﻨﺎ ﺍﺳﺘﻌﻤﻠﻨﺎ ﻣﺆﺷﺮ ﻭ ﺍﻟﻮﺿـﻊ ﺍﻻﻓﺘﺮﺍﺿـﻲ
ﻟﻠﻤﺆﺷﺮﺍﺕ ﻫﻲ ﻋﻨﻮﺍﺎ
...
h
1
2
3
4
5
6
7
8
9
01
11
>#include
arr = ptr
3
4
5
6
7
8
9
01
11
21
31
٥,٤,٢ ﺍﳌﺮﺟﻊ :reference
ﺍﳌﺮﺟﻊ ﻫﻮ ﺃﺧﺬ ﻋﻨﻮﺍﻥ ﻣﺘﻐﲑ، ﻋﻨﺪ ﻛﺘﺎﺑﺔ:
>#include
ﻛﺘﺎﺑﺔ ﺍﳌﺆﺛﺮ & ﰒ ﺍﺳﻢ ﻣﺘﻐﲑ ﻳﻌﲏ ﺃﺧﺬ ﻋﻨﻮﺍﻥ ﺫﻟﻚ ﺍﳌﺘﻐﲑ، ﻭ ﺗـﺴﻤﻰ
ﻫﺬﻩ ﺍﻟﻌﻤﻠﻴﺔ ﺑﺎﳌﺮﺟﻊ
...
h
)(main
{
;void *p_void
/* ;/* can't use void v_void
;01 = (int)p_void
;)printf("(int)p_void = %d\n", p_void
1
2
3
4
5
6
7
8
9
01
121
;'(char)p_void = 'H
;)printf("(char)p_void = %c\n", p_void
;"(char *)p_void = "Hello
;)printf("(char *)p_void = %s\n", p_void
ﺍﻟﱪﻧﺎﻣﺞ ٤١,٤,٢: ﻣﺆﺷﺮ ﻟـ
}
11
21
31
41
51
61
void
ﻋﻨﺪﻣﺎ ﻧﺮﻳﺪ ﻭﺿﻊ ﻗﻴﻢ ﳌﺆﺷﺮ voidﻧﻜﺘﺐ ،(Type)Pointer_Nameﰲ ﻣﻜﺎﻥ Typeﻧﻜﺘﺐ ﻧﻮﻉ ﺍﻟﻘﻴﻤﺔ ﺍﻟﱵ ﺳـﻨﻘﻮﻡ
ﺑﺈﺩﺧﺎﳍﺎ، ﰒ ﺍﺳﻢ ﺍﳌﺆﺷﺮ ﰒ ﻧﻌﻄﻴﻪ ﺍﻟﻘﻴﻤﺔ
...
h
)(main
{
;]2[int *arr
;02 = int a = 10, b
;)printf("A = %d, ", a
;)printf("B = %d\n", b
;arr[0] = &a
;5 = ]0[*arr
;arr[1] = &b
;01 = ]1[*arr
;)printf("A = %d, ", a
;)printf("B = %d\n", b
}
ﺍﻟﱪﻧﺎﻣﺞ ٥١,٤,٢: ﻣﺆﺷﺮ ﳌﺼﻔﻮﻓﺔ
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
61
71
81
91
ﻭ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻝ ﻣﺆﺷﺮ ﳌﺼﻔﻮﻓﺔ ﺛﻨﺎﺋﻴﺔ ﺃﻭ ﺛﻼﺛﻴﺔ ﺍﻷﺑﻌﺎﺩ
...
h
{)(main
;}"3 char *arr[] = {"Text 1", "Text 2", "Text
;)]0[printf("arr[0] = %s\n", arr
;)]1[printf("arr[1] = %s\n", arr
;)]2[printf("arr[2] = %s\n", arr
}
1
2
3
4
5
6
7
8
9
221
٨,٤,٢ ﻣﺆﺷﺮ ﳌﺆﺷﺮ:
ﺍﻟﱪﻧﺎﻣﺞ ٦١,٤,٢: ﻣﺆﺷﺮ ﳌﺼﻔﻮﻓﺔ )٢(
ﻣﺆﺷﺮ ﳌﺆﺷﺮ ﻗﻠﻴﻠﺔ ﺍﻻﺳﺘﻌﻤﺎﻝ
...
h
)(main
{
;int p
;int *pt
;int **ptr
;01 = p
;)printf("p = %d\n", p
;pt = &p
;ptr = &pt
;5 = **ptr
;)printf("p = %d\n", p
}
ﺍﻟﱪﻧﺎﻣﺞ ٧١,٤,٢: ﻣﺆﺷﺮ ﳌﺆﺷﺮ
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
61
71
ﰎ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺆﺷﺮ ﳌﺆﺷﺮ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ
...
h
{)(main
;char *AdrPtr
;char **ptr = &AdrPtr
;"1 ptr[0] = "Text
;"2 ptr[1] = "Text
;"3 ptr[2] = "Text
;)]0[printf("ptr[0] = %s\n", ptr
;)]1[printf("ptr[1] = %s\n", ptr
;)]2[printf("ptr[2] = %s\n", ptr
ﺍﻟﱪﻧﺎﻣﺞ ٨١,٤,٢: ﻣﺆﺷﺮ ﳌﺆﺷﺮ )٢(
ﻭ ﳝﻜﻦ ﻋﻤﻞ ﺃﻛﺜﺮ ﻣﻦ ﻣﺆﺷﺮ ﳌﺆﺷﺮ، ﺃﻱ ﳝﻜﻦ ﺍﻹﻋﻼﻥ ﻋﻦ ،int *****ptrﺃﻭ ﺃﻛﺜﺮ
...
ﰲ ﺍﳌﺘﺮﲨﺎﺕ ﺍﳉﺪﻳﺪ ﻻ ﻳﺴﻤﺢ ﺑﺈﻋﻄﺎﺀ ﻗﻴﻤﺔ ﳌﺆﺷﺮ ﺑﺪﻭﻥ ﻋﻨﻮﺍﻥ، ﺃﻱ ﻻ ﳝﻜﻦ ﻛﺘﺎﺑﺔ ﻛﻤﺎ ﰲ ﺍﳌﺜﺎﻝ ﺍﻟﺘﺎﱄ:
>#include
h
)(main
{
;int *ptr
;int i
;*ptr = i
ﺍﻟﱪﻧﺎﻣﺞ ٠٢,٤,٢: ﺍﳋﻄﺄ ٢
}
1
2
3
4
5
6
7
8
9
٢
...
h
)(main
{
;int *ptr
;int i
;i = ptr
ﺍﻟﱪﻧﺎﻣﺞ ١٢,٤,٢: ﺍﳋﻄﺄ ٣
}
1
2
3
4
5
6
7
8
9
٠١,٤,٢ ﲤﺎﺭﻳﻦ:
١
...
h
)(main
1
2
3
124
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
{
char usr_name[255];
int i;
i = 0;
printf("Your Fullname: ");
scanf("%s", &usr_name);
while(usr_name[i]!='\0')
{
printf("%i: %c\n", i+1, usr_name[i]);
++i;
}
}
printf("%s = %d characters\n", usr_name, i);
١ ﺍﻟﱪﻧﺎﻣﺞ ٢٢,٤,٢: ﺍﻟﺘﻤﺮﻳﻦ
521
ﺍﻟﺪﻭﺍﻝ ﻫﻲ ﳎﻤﻮﻋﺔ ﻣﻦ ﺍﻷﻭﺍﻣﺮ ﻭ ﺍﻟﺒﻴﺎﻧﺎﺕ ﲢﺖ ﺍﺳﻢ ﻭﺍﺣﺪ ﺣﻴﺚ ﳝﻜﻦ ﺍﺳﺘﺪﻋﺎﺀﻫﺎ ﻣﻦ ﺃﻣﺎﻛﻦ ﳐﺘﻠﻔﺔ ﰲ ﺍﻟﱪﻧﺎﻣﺞ
...
ﺍﻟﺼﻮﺭﺓ ﺍﻟﺘﺎﻟﻴﺔ ﺗﻮﺿﺢ ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺩﺍﻟﺔ:
ﺍﻟﺸﻜﻞ ١,٥,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺩﺍﻟﺔ
ﻭ ﳝﻜﻦ ﺃﻥ ﻻ ﲢﺘﻮﻱ ﺍﻟﺪﺍﻟﺔ ﻋﻠﻰ ﻭﺳﺎﺋﻂ
...
h
)(void Func_HelloWorld
{
;)"printf("Hello, World!\n
}
)(main
{
;)(Func_HelloWorld
}
ﺍﻟﱪﻧﺎﻣﺞ ١,٥,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺩﺍﻟﺔ
1
2
3
4
5
6
7
8
9
01
11
ﻫﺬﻩ ﻃﺮﻳﻘﺔ، ﺃﻣﺎ ﺍﻟﻄﺮﻳﻘﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻓﻬﻲ ﺍﻹﻋﻼﻥ ﻋﻦ ﺍﻟﺪﺍﻟﺔ )ﻳﺴﻤﻰ ﺑﺎﻟﻨﻤﻮﺫﺝ (prototypeﰒ ﻧﻘﻮﻡ ﺑﺈﻋﻄﺎﺋﻬﺎ ﺍﻷﻭﺍﻣﺮ ﺑﻌﺪ ﺍﻟﺪﺍﻟﺔ
ﺍﻟﺮﺋﻴﺴﻴﺔ ﻭ ﺳﻴﺼﺒﺢ ﺍﳌﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ ﻛﺎﻟﺘﺎﱄ:
>#include
ﻭ ﺗﻮﺟﺪ ﻃﺮﻳﻘﺔ ﺃﺧﺮﻯ ﻭ ﻟﻜﻦ ﻻ ﻳﻔﻀﻞ ﺍﺳﺘﻌﻤﺎﳍﺎ ﻣﻦ ﻧﺎﺣﻴﺔ ﺍﻟﺘﻨﻈﻴﻒ ﻭ ﺃﻳـﻀﺎ
ﺑﻌﺾ ﺍﳌﺘﺮﲨﺎﺕ ﻻ ﺗﻘﺒﻠﻬﺎ ﻭ ﻫﻲ:
>#include
h
1
2
3
4
5
6
7
8
9
01
11
21
31
41
)(main
{
;)(Func_HelloWorld
}
)(void Func_HelloWorld
{
;)"printf("Hello, World!\n
}
ﺍﻟﱪﻧﺎﻣﺞ ٣,٥,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺩﺍﻟﺔ )٣(
ﻭ ﺇﻥ ﻛﺎﻥ ﻣﺘﺮﲨﻚ ﻗﺪ ﻧﺒﻬﻚ ﻋﻦ ﻭﺟﻮﺩ ﺧﻄﺄ ﻓﺴﻴﻜﻮﻥ ﻋﻦ ﺍﳋﻄﺄ ﻋﻦ ﳕﻮﺫﺝ prototypeﺍﻟﺪﺍﻟﺔ ،Func_HelloWorldﻭ
ﺫﻟﻚ ﰲ ﺍﻷﺻﻞ ﻫﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ ﻫﻲ ﻣﻦ ﻃﺮﻕ ﻟﻐﺔ ،Cﻳﻌﲏ ﺃﺎ ﻃﺮﻳﻘﺔ ﺻﺤﻴﺤﺔ ﻓﻘﻂ ﺑﻌﺾ ﺍﳌﺘﺮﲨﺎﺕ ﻻ ﺗـﺪﻋﻤﻬﺎ
...
ﺳﻨﻘﻮﻡ ﺑﻜﺘﺎﺑﺔ ﺩﺍﻟﺔ ﺎ ﻭﺳﻴﻂ
ﻋﺒﺎﺭﺓ ﻋﻦ ﺳﻠﺴﻠﺔ ﺣﺮﻭﻑ ﺛﺎﺑﺘﺔ، ﺣﻴﺚ ﺳﺘﻘﻮﻡ ﺗﻠﻚ ﺍﻟﺪﺍﻟﺔ ﺑﻄﺒﺎﻋﺔ ﻣﺎ ﻫﻮ ﺩﺍﺧﻞ ﺍﻟﻮﺳﻴﻂ ﺍﳋﺎﺹ ﺎ:
;)void Func_Print(const char *str
)(main
{
;)"Func_Print("Func_Print:\n
;)"Func_Print("Hello, World!\n
}
)void Func_Print(const char *str
{
;)printf("%s", str
}
ﺍﻟﱪﻧﺎﻣﺞ ٤,٥,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺩﺍﻟﺔ ﺫﺍﺕ ﻭﺳﻴﻂ
127
ﻫﺬﻩ ﻟﻴﺴﺖ ﺇﻻ ﺃﻣﺜﻠﺔ ﺑﺴﻴﻄﺔ ﺣﻮﻝ ﻃﺮﻳﻘﺔ ﻋﻤﻞ ﺍﻟﺪﻭﺍﻝ، ﳝﻜﻦ ﺃﻥ ﻧﻘﻮﻡ ﺑﻌﻤﻞ ﺩﺍﻟﺔ ﺗﻘﻮﻡ ﺑـﺎﳉﻤﻊ، ﺍﻟﻄـﺮﺡ، ﺍﻟﻘـﺴﻤﺔ ﻭ
:ﺍﻟﻀﺮﺏ، ﺳﻴﻜﻮﻥ ﺍﳌﺜﺎﻝ ﻋﻠﻰ ﺍﻟﺸﻜﻞ ﺍﻟﺘﺎﱄ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include
h>
void Func_(const int num1, const char sign, const int num2);
main()
{
Func_(30, '+', 10);
Func_(30, '-', 10);
Func_(30, '*', 10);
821
;)01 ,'/' ,03(_Func
}
)2sign, const int num
;)2num1, sign, num2, num1+num
;)2num1, sign, num2, num1-num
;)2num1, sign, num2, num1*num
;)2num1, sign, num2, num1/num
void Func_(const int num1, const char
{
)switch(sign
{
:'+' case
,"printf("%d %c %d = %d\n
;break
:'-' case
,"printf("%d %c %d = %d\n
;break
:'*' case
,"printf("%d %c %d = %d\n
;break
:'/' case
,"printf("%d %c %d = %d\n
;break
:default
;)"printf("ERROR!\n
;break
}
ﺍﻟﱪﻧﺎﻣﺞ ٦,٥,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺩﺍﻟﺔ ﺫﺍﺕ ﺃﻛﺜﺮ ﻣﻦ ﻭﺳﻴﻄﲔ
}
01
11
21
31
41
51
61
71
81
91
02
12
22
32
42
52
62
72
82
92
03
13
23
33
43
١,٥,٢ ﻧﻮﻉ ﺍﻟﺪﺍﻟﺔ :Function Type
ﻟـ ﺍﻟﺪﻭﺍﻝ ﺃﻧﻮﺍﻉ ﻭ ﻫﻲ ﻧﻔﺴﻬﺎ ﺃﻧﻮﺍﻉ ﺍﳌﺘﻐﲑ، ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻝ ﺩﺍﻟﺔ ﻣﻦ ﻧﻮﻉ ﺃﻋﺪﺍﺩ ﺻﺤﻴﺤﺔ intﺃﻭ ﺃﻋـﺪﺍﺩ ﺣﻘﻴﻘﻴـﺔ
...
h
;)int Int_Func(const int num
)(main
{
;))5(printf("%d\n", Int_Func
}
)int Int_Func(const int num
{
;return num
}
ﺍﻟﱪﻧﺎﻣﺞ ٧,٥,٢: ﺇﻋﻼﻥ ﻋﻦ ﺩﺍﻟﺔ ﻣﻦ ﻧﻮﻉ ﻋﺪﺩ ﺻﺤﻴﺢ
ﻫﻨﺎ ﻗﻤﻨﺎ ﺑﺈﺭﺟﺎﻉ ﻗﻴﻤﺔ ﺍﻟﻮﺳﻴﻂ
num
1
2
3
4
5
6
7
8
9
01
11
21
31
intﺇﱃ ﺍﻟﺪﺍﻟﺔ ،Int_Funcﻭ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ، ﰲ ﺍﻟﺪﺍﻟﺔ printfﳝﻜﻨﻨﺎ ﻛﺘﺎﺑـﺔ
ﺩﻭﺍﻝ ﺍﻟﱵ ﺗﻘﻮﻡ ﺑﺈﺭﺟﺎﻉ ﻗﻴﻢ ﻛﻤﺎ ﰲ ﻫﺬﺍ ﺍﳌﺜﺎﻝ، ﻭ ﻻ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻝ ﻫﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ ﻣﻊ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ voidﻷﺎ ﺑﺪﻭﻥ
921
ﺣﺠﻢ ﻭ ﻻ ﳝﻜﻨﻬﺎ ﲪﻞ ﻗﻴﻢ
...
h
;)Int_Func(const int num
)(main
{
;))5(printf("%d\n", Int_Func
}
)Int_Func(const int num
{
;return num
}
ﺍﻟﱪﻧﺎﻣﺞ ٨,٥,٢: ﺍﻟﻮﺿﻊ ﺍﻹﻓﺘﺮﺍﺿﻲ ﻟﺪﺍﻟﺔ ﺑﺪﻭﻥ ﲢﺪﻳﺪ ﻧﻮﻋﻬﺎ
1
2
3
4
5
6
7
8
9
01
11
21
31
ﻭ ﳝﻜﻦ ﺃﻳﻀﺎ ﻛﺘﺎﺑﺔ ﺍﺳﻢ ﻣﺘﻐﲑ ﺑﺪﻭﻥ ﻧﻮﻉ، ﰒ ﻧﻘﻮﻡ ﺑﻜﺘﺎﺑﺔ ﻧﻮﻋﻪ ﺃﺳﻔﻞ ﺍﺳﻢ ﺍﻟﺪﺍﻟﺔ ﺍﻟﱵ ﻫﻲ ﺑﻌﺪ ﺍﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ، ﻣﺜﺎﻝ:
>#include
h
;)int Int_Func(const int num
)(main
{
;))5(printf("%d\n", Int_Func
}
)int Int_Func(const int num
{
;return num
1
2
3
4
5
6
7
8
9
01
11
21
130
13
1
2
3
4
5
6
7
8
9
10
11
12
13
}
ﺍﻟﱪﻧﺎﻣﺞ ٠١,٥,٢: ﺍﻟﻄﺮﻳﻘﺔ ﺍﻹﻓﺘﺮﺍﺿﻴﺔ ﻟﻺﻋﻼﻥ ﻋﻦ ﻭﺳﻴﻂ ﻟﺪﺍﻟﺔ
:short ﺑﺎﺳﺘﺨﺪﺍﻡ
#include
h>
char Char_Func(const char ch);
main()
{
printf("%c\n", Char_Func('C'));
}
char Char_Func(const char ch)
{
return ch;
}
char
ﺍﻟﱪﻧﺎﻣﺞ ٢١,٥,٢: ﺇﻋﻼﻥ ﻋﻦ ﺩﺍﻟﺔ ﻣﻦ ﻧﻮﻉ
:ﻭ ﺍﻟﺪﻭﺍﻝ ﺍﻟﱵ ﺗﺮﺟﻊ ﻗﻴﻢ ﳝﻜﻦ ﺇﻋﻄﺎﺀﻫﺎ ﳌﺘﻐﲑ ﻃﺒﻴﻌﻲ ﻣﺒﺎﺷﺮﺓ ﻣﺜﻞ
1
2
3
4
5
6
7
8
9
10
#include
h
{)char *string(char *str
;return str
}
)(main
{
;))"!printf("%s\n", string("Hello, World
}
ﺍﻟﱪﻧﺎﻣﺞ ٤١,٥,٢: ﺇﻋﻼﻥ ﻋﻦ ﺩﺍﻟﺔ ﻣﻦ ﻧﻮﻉ
1
2
3
4
5
6
7
8
9
01
*char
٢,٥,٢ ﺍﺳﻢ ﺍﻟﺪﺍﻟﺔ :Function Name
ﻻﺳﻢ ﺍﻟﺪﺍﻟﺔ ﺣﺪﻭﺩ ﻭ ﻫﻲ ﻣﺜﻞ ﺍﺳﻢ ﺍﳌﺘﻐﲑ:
§ ﺃﻥ ﻻ ﻳﺘﺠﺎﻭﺯ ﺍﺳﻢ ﺍﻟﺪﺍﻟﺔ ١٣ ﺣﺮﻑ
...
§ ﺃﻥ ﻻ ﻳﻜﻮﻥ ﺍﺳﻢ ﺍﻟﺪﺍﻟﺔ ﳛﺘﻮﻱ ﻋﻠﻰ ﻣﺆﺛﺮﺍﺕ ﻣﺜﻞ ﺍﳉﻤﻊ ﻭ ﺍﻟﻄﺮﺡ ﻭ
...
)ﺑﺎﺳﺘﺜﻨﺎﺀ ﺍﻟﺮﻣﺰ _(
...
§ ﺃﻥ ﻻ ﻳﻜﻮﻥ ﺍﺳﻢ ﺍﻟﺪﺍﻟﺔ ﻣﻦ ﺃﺣﺪ ﺃﲰﺎﺀ ﺍﻟﻜﻠﻤﺎﺕ ﺍﶈﺠﻮﺯﺓ
...
long, int, float, double, char, char*, charﻭ ﳝﻜﻦ ﺃﻳﻀﺎ ﺃﻥ ﺗﻜﻮﻥ ﺍﻟﻮﺳﺎﺋﻂ ﻋﺒﺎﺭﺓ ﻋﻦ ﻣـﺼﻔﻮﻓﺎﺕ ﺃﻭ
ﻣﺆﺷﺮﺍﺕ ﻣﻦ ﻛﻞ ﺍﻷﻧﻮﺍﻉ
...
main
unsigned
231
٥,٥,٢ ﺍﳌﺨﺘﺼﺮﺍﺕ :macros
ﻻ ﺗﺴﻤﻰ ﺑﺪﻭﺍﻝ ﻭ ﻟﻜﻨﻬﺎ ﺷﺒﻴﻬﺎ ﳍﺎ، ﺗﺴﻤﻰ ﺑﺎﻟـ macrosﺃﻱ ﺍﳌﺨﺘﺼﺮﺍﺕ، ﻭ ﻫﺬﺍ ﻣﺜﺎﻝ ﻟﻄﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻨﻬﺎ:
>#include
#defineﻣﺜﺎﻝ
ﺁﺧﺮ:
>#include
\n
}
ﺍﻟﱪﻧﺎﻣﺞ ٦١,٥,٢: ﺇﺳﺘﺪﻋﺎﺀ ﺩﺍﻟﺔ ﻣﻦ ﳐﺘﺼﺮ
1
2
3
4
5
6
7
8
٦,٥,٢ ﺍﻟﻔﺮﻕ ﺑﲔ ﺍﻹﺟﺮﺍﺀ ﻭ ﺍﻟﺪﺍﻟﺔ:
ﰲ ﻟﻐﺔ Cﺍﻹﺟﺮﺍﺀﺍﺕ ﳝﻜﻦ ﺍﻟﻘﻮﻝ ﻋﻠﻴﻬﺎ ﻫﻲ ﻧﻔﺴﻬﺎ ﺍﻟﺪﻭﺍﻝ ﻷﺎ ﻣﺪﻣﺞ ﻣﻌﻬﺎ، ﻭ ﺍﻹﺟﺮﺍﺀ Procedureﻫﻮ ﺩﺍﻟﺔ ﻻ ﺗﻘـﻮﻡ
ﺑﺈﺭﺟﺎﻉ ﻗﻴﻤﺔ ﻭ ﳝﻜﻦ ﺍﻟﻘﻮﻝ ﺃﻥ ﺩﻭﺍﻝ ﻣﻦ ﻧﻮﻉ voidﺗﺴﻤﻰ ﺇﺟﺮﺍﺀ ﻷﺎ ﻻ ﺗﺮﺟﻊ ﻗﻴﻢ ﻣﺜﻞ ﺍﻟـﺪﻭﺍﻝ ﻣـﻦ ﻧـﻮﻉ intﺃﻭ
floatﺃﻭ ﻏﲑﻫﺎ، ﺣﻴﺚ ﺗﻘﻮﻡ ﺍﻹﺟﺮﺍﺀﺍﺕ ﺑﺘﻨﻔﻴﺬ ﺃﻭﺍﻣﺮ ﺃﻣﺎ ﺍﻟﺪﻭﺍﻝ ﻓﻬﻲ ﺗﻘﻮﻡ ﺑﻌﻤﻠﻴﺎﺕ ﻭ ﺗﻌﻄﻲ ﻧﺘﻴﺠﺔ
...
h
;))void CallFunc(void Func_Name(void
1
2
3
133
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void Function();
main(){
CallFunc(Function);
}
void CallFunc(void Func_Name(void)){
printf("Call Function:\n");
Func_Name();
}
void Function(){
printf("This is a function!\n");
}
ﺍﻟﱪﻧﺎﻣﺞ ٧١,٥,٢: ﺩﺍﻟﺔ ﺫﺍﺕ ﻭﺳﻴﻂ ﻟﺪﺍﻟﺔ ﺃﺧﺮﻯ
ﺎ ﻭﺳﺎﺋﻂ ﺃﺧﺮﻯ، ﺃﻭ ﺍﺳﺘﺪﻋﺎﺀ ﺩﻭﺍﻝ ﺃﺧﺮﻯ ﰲ ﻭﺳـﺎﺋﻂ ﻭ ﳝﻜﻦ ﺃﻥ ﺗﻜﻮﻥ ﺍﻟﻮﺳﺎﺋﻂ ﻋﺒﺎﺭﺓ ﻋﻦ ﺩﻭﺍﻝ ﺗﺮﺟﻊ ﻗﻴﻢ، ﺃﻭ ﺩﻭﺍﻝ
:ﺍﻟﺪﻭﺍﻝ، ﻭ ﺃﻛﺜﺮ ﻣﻦ ﺫﻟﻚ
...
h>
void CallFunc(void Func_Name(int a, int b));
void Function(int a, int b);
main(){
CallFunc(Function);
}
void CallFunc(void Func_Name(int a, int b)){
printf("Call Function:\n");
Func_Name(10, 20);
}
void Function(int a, int b){
printf("%d + %d = %d\n", a, b, a+b);
}
ﺍﻟﱪﻧﺎﻣﺞ ٨١,٥,٢: ﺩﺍﻟﺔ ﺫﺍﺕ ﻭﺳﻴﻂ ﻟﺪﺍﻟﺔ ﺃﺧﺮﻯ ﺫﺍﺕ ﻭﺳﺎﺋﻂ
:٨,٥,٢ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ
:ﺎﻳﺔ ﺩﻭﺍﻝ ﻧﻘﻮﻡ ﺑﺈﻋﻄﺎﺋﻬﺎ ﺃﻭﺍﻣﺮ، ﻣﺜﺎﻝ ١
...
h>
void Function();
main()
{
}
Function();
void Function();
431
{
/*;/*Empty Funtion
ﺍﻟﱪﻧﺎﻣﺞ ٩١,٥,٢: ﺍﳋﻄﺄ ١
}
11
21
31
ﻭ ﺍﳋﻄﺄ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﻌﺎﺷﺮ، ﻋﻨﺪ ﺍﻹﻋﻼﻥ ﻋﻦ ﺩﺍﻟﺔ ﺑﺪﻭﻥ ﺃﻭﺍﻣﺮ ﳚﺐ ﻛﺘﺎﺑﺔ ﺍﻟﻔﺎﺻﻠﺔ ﺍﳌﻨﻘﻮﻃﺔ ﰲ ﺎﻳﺔ ﺍﻟﺪﺍﻟﺔ، ﺃﻣﺎ
ﻋﻨﺪ ﺍﻹﻋﻼﻥ ﻋﻦ ﺩﻭﺍﻝ ﻟﻜﻲ ﻧﻌﻄﻲ ﳍﺎ ﺃﻭﺍﻣﺮ ﻓﻼ ﳚﺐ ﺃﻥ ﻧﻜﺘﺐ ﻓﺎﺻﻠﺔ ﻣﻨﻘﻮﻃﺔ ﰲ ﺎﻳﺔ ﺍﻟﺪﺍﻟﺔ
...
٩,٥,٢ ﲤﺎﺭﻳﻦ:
١
...
*str
٢
...
value
char
const
int
531
ﻛﻞ ﻣﻦ stdio
...
hﻋﺒﺎﺭﺓ ﻋﻦ ﻣﻠﻔﺎﺕ ﺭﺃﺳﻴﺔ، ﺣﻴﺚ ﺗﻮﺟﺪ ﺎ ﺛﻮﺍﺑﺖ، ﳕﺎﺫﺝ ﺩﻭﺍﻝ ﻭ ﺑﻨﻴﺎﺕ ﺗﺴﺎﻋﺪﻧﺎ
ﰲ ﺑﺮﺍﳎﻨﺎ، ﺳﻨﺘﺤﺪﺙ ﰲ ﻫﺬﺍ ﺍﻟﺪﺭﺱ ﻋﻦ ﻃﺮﻳﻘﺔ ﺇﻧﺸﺎﺀ ﻣﻠﻔﺎﺕ ﺭﺃﺳﻴﺔ ﻭ ﻃﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﳍﺎ
...
hﻭ ﻳﻜﻮﻥ ﺍﺳـﻢ
ﻣﻠﻔﻨﺎ ﺍﻟﺮﺃﺳﻲ functions
...
hﻭ ﻗـﻢ
ﺑﺎﻟﻜﺘﺎﺑﺔ ﻓﻴﻪ ﻣﺎ ﻳﻠﻲ:
>#include
h
)(main
{
;01 = 2int num1 = 30, num
;))2num
;))2num
;))2num
;))2num
,1Add(num
,1Sub(num
,1Mul(num
,1Div(num
,2num
,2num
,2num
,2num
,1num
,1num
,1num
,1num
,"%d\n
,"%d\n
,"%d\n
,"%d\n
ﺍﻟﱪﻧﺎﻣﺞ ٢,٦,٢: ﺿﻢ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ
=
=
=
=
%d
%d
%d
%d
+
*
/
printf("%d
printf("%d
printf("%d
printf("%d
}
1
2
3
4
5
6
7
8
9
01
11
21
631
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﱐ ﻗﻤﻨﺎ ﺑﺈﺿﺎﻓﺔ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ functions
...
hﻣﻮﺟﻮﺩ ﰲ ﻧﻔﺲ ﺍﳌﻜﺎﻥ ﺍﻟﺬﻱ ﻣﻮﺟﻮﺩ ﺑﻪ ﺍﳌﻠﻒ ﺍﻟﻨﺼﻲ ﺍﻟﺮﺋﻴﺴﻲ ،main
...
h
>#include
hﰲ ﻧﻔﺲ ﺍﳌﻜﺎﻥ ﺍﻟﺬﻱ ﻣﻮﺟﻮﺩ ﺑﻪ ﺍﳌﻠـﻒ ﺍﻟﺮﺃﺳـﻲ )stdio
...
١,٦,٢ ﺍﺳﻢ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ:
ﳝﻜﻦ ﻛﺘﺎﺑﺔ ﺃﺭﻗﺎﻡ ﰲ ﺑﺪﺍﻳﺔ ﺍﺳﻢ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ﻭ ﺃﻳﻀﺎ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻝ ﻣﺆﺛﺮﺍﺕ ﺍﳉﻤﻊ ﻭ ﺍﻟﻄﺮﺡ، ﻭ ﺍﻟﺮﻣﻮﺯ ﺍﻟﱵ ﻻ ﳝﻜﻦ
ﺍﺳﺘﻌﻤﺎﳍﺎ ﰲ ﺍﺳﻢ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ﻫﻲ: % # | > < " * \ & : ? /، ﻭ ﺃﻗﺼﻰ ﺣﺪ ﳝﻜﻦ ﺇﻋﻄﺎﺀﻩ ﻻﺳﻢ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ﻫﻮ ٦٥٢
ﺭﻣﺰ
...
hﺣﻴﺚ ﺗﻀﻊ ﺑﻪ ﲨﻴﻊ ﺍﻟﺪﻭﺍﻝ ﺍﻟﱵ ﺗﺮﻳﺪ ﺍﺳﺘﻌﻤﺎﳍﺎ ﰲ ﺍﳌـﺴﺘﻘﺒﻞ، ﻭ ﺇﺫﺍ ﻛﻨـﺖ
ﺗﺴﺘﻌﻤﻞ ﺩﻭﺍﻝ ﺍﻟﺮﺳﻢ ﺃﻳﻀﺎ ﻗﻢ ﺑﺈﻧﺸﺎﺀ ﻣﻠﻒ ﺭﺃﺳﻲ ﳍﺎ ﺑﺎﺳﻢ design
...
hﺣﻴﺚ ﺗﻜﻮﻥ ﺑﻪ ﺃﻏﻠـﺐ ﺩﻭﺍﻝ
ﺍﻟﺮﺳﻢ، ﻭ ﻫﻜﺬﺍ ﺣﱴ ﺗﻜﻮﻥ ﻟﺪﻳﻚ ﻣﻜﺘﺒﺔ ﻛﺒﲑﺓ ﺧﺎﺻﺔ ﺑﻚ
...
731
٤,٦,٢ ﲤﺎﺭﻳﻦ:
١
...
hﺣﻴﺚ ﺑﻪ ﺍﻟﺪﺍﻟﺔ absﻭ ﺍﻟﱵ ﺗﻘﻮﻡ ﺑﺈﺧﺮﺍﺝ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻄﻠﻘﺔ ﻟﻠﻌﺪﺩ ﺍﳌﺪﺧﻞ، ﰒ ﻗﻢ
ﺑﺎﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ absﰲ ﺑﺮﻧﺎﳎﻚ
...
١,٧,٢ ﺍﻹﺧﺮﺍﺝ ﰲ ﺍﳌﻠﻔﺎﺕ:
ﺍﻹﺧﺮﺍﺝ ﻳﻌﲏ ﺑﻨﺎﺀ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮﻡ ﺑﺈﺧﺮﺍﺝ )ﺇﻧﺸﺎﺀ( ﻣﻠﻔﺎﺕ ﺫﺍﺕ ﺍﻣﺘﺪﺍﺩ ﻳﻘﻮﻡ ﺑﺘﺤﺪﻳﺪﻩ ﺍﳌﱪﻣﺞ، ﺣﻴﺚ ﲢﺘﻮﻱ ﺗﻠﻚ ﺍﳌﻠﻔﺎﺕ
ﻋﻠﻰ ﺑﻴﺎﻧﺎﺕ
...
h
)(main
{
;FILE *File
;]552[char FileName
;]552[char String
;)" :]552 printf("Enter the name of file(with type)\n[MAX Character
;)gets(FileName
;)"printf("Creating File
...
\n
;)"printf("TEXT:\n
;)gets(String
;)printf("Save Text to the file %s
...
FILE
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺩﺱ ﻗﻤﻨﺎ ﺑﺎﻹﻋﻼﻥ ﺳﻠﺴﻠﺔ ﺣﺮﻓﻴﺔ ﻭ ﺍﻟﱵ ﺳﺘﻜﻮﻥ ﺍﺳﻢ ﺍﳌﻠﻒ
...
ﻭ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﻌﺎﺷﺮ ﻃﻠﺒﻨﺎ ﻣﻦ ﺍﳌﺴﺘﺨﺪﻡ ﺇﺩﺧﺎﻝ ﺍﺳﻢ ﺍﳌﻠﻒ ﻣﻊ ﺍﻣﺘﺪﺍﺩﻩ ﻭ ﺃﻧﻪ ﺃﻗﺼﻰ
ﻋﺪﺩ ﺍﻷﺣﺮﻑ ﺍﻟﱵ ﳝﻜﻦ ﺇﺩﺧﺎﳍﺎ ﻫﻮ ٥٥٢
...
txtﻓﻬﻨﺎ ﺍﻟﺪﺍﻟﺔ scanfﺳﺘﺘﻮﻗﻒ ﻋﻦ ﺍﻟﻔﺮﺍﻍ ﺃﻱ ﺃﻥ ﺍﺳﻢ ﺍﳌﻠﻒ ﺳﻴﻜﻮﻥ testﻭ ﺑﺪﻭﻥ ﺍﻣﺘﺪﺍﺩ، ﻭ ﻫـﺬﺍ ﻫـﻮ ﺳـﺒﺐ
ﺍﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ getsﻷﺎ ﺗﺄﺧﺬ ﺍﻻﺳﻢ ﻛﺎﻣﻞ ﺣﱴ ﻭ ﺇﻥ ﻛﺎﻧﺖ ﻓﺮﺍﻏﺎﺕ
...
ﻭ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ ﻋﺸﺮ ﻳﻨﺘﻈﺮ ﺍﻟﱪﻧﺎﻣﺞ ﻣﻦ ﺍﳌﺴﺘﺨﺪﻡ ﻟﻜﻲ ﻳﻘﻮﻡ ﺑﺈﺩﺧـﺎﻝ ﻧـﺺ ﻭ
ﺍﺳﺘﻌﻤﺎﻟﻨﺎ ﻫﻮ ﺍﻟﺪﺍﻟﺔ getsﻟﻨﻔﺲ ﺍﻟﺴﺒﺐ ﺍﻟﺴﺎﺑﻖ
...
ﺳﻨﻘﻮﻡ ﺍﻵﻥ ﺑﻜﺘﺎﺑﺔ ﺍﳌﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﳌﺆﺷﺮﺍﺕ ﻭ ﺍﻟﺪﻭﺍﻝ ﻭ ﺍﳌﻠﻔﺎﺕ ﺍﻟﺮﺃﺳﻴﺔ )ﻣﻊ ﺟﻌﻞ ﺍﻟﱪﻧـﺎﻣﺞ ﺃﻛﺜـﺮ
ﻣﺮﻭﻧﺔ( ﻛﻲ ﻧﻌﺘﺎﺩ ﻋﻠﻲ ﺍﺳﺘﻌﻤﺎﳍﺎ
...
hﻭ ﻧﻘﻮﻡ ﺑﺎﻟﻜﺘﺎﺑﺔ ﻋﻠﻴﻪ ﺍﻟﺘﺎﱄ:
test
/*fileio
...
h> /*for exit() fonction
/*void CreateFile(const char *FileName, /*for the name of file
)const char *String
/*/*for text of file
{
;FILE *FileOut
)'0\' == if(*FileName
{
;)"printf("Error in the name of file!\n
;)1(exit
}
{)if((FileOut = fopen(FileName, "w"))==NULL
;)"printf("Can't create file!\n
;)1(exit
{}else
;)fprintf(FileOut, "%s", String
}
;)fclose(FileOut
ﺍﻟﱪﻧﺎﻣﺞ ٢,٧,٢: ﻃﺮﻳﻘﺔ ﺇﻧﺸﺎﺀ ﻣﻠﻒ
ﻫﺬﺍ ﺍﳌﻠﻒ ﻫﻮ ﺍﳌﺮﺣﻠﺔ ﺍﻷﻭﱃ ﻣﻦ ﺍﻟﱪﻧﺎﻣﺞ، ﻭ ﺷﺮﺣﻪ ﻫﻮ:
}
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
61
71
81
91
02
12
22
32
041
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﻟﺚ ﺃﺿﻔﻨﺎ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ stdlib
...
ﻗﻤﻨﺎ ﺑﺎﻹﻋﻼﻥ ﻋﻦ ﺍﻟﺪﺍﻟﺔ CreateFileﰲ ﺍﻟﺴﻄﺮ
ﺍﳋﺎﻣﺲ ﻣﻊ ﻭﺳﻴﻄﲔ ﺍﻷﻭﻝ ﻻﺳﻢ ﺍﳌﻠﻒ ﻭ ﺍﻟﺜﺎﱐ ﻟﻨﺺ ﺍﳌﻠﻒ
...
ﻭ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺩﺱ ﻋﺸﺮ ﻗﻤﻨﺎ ﲟﻘﺎﺭﻧﺔ ﺃﺧﺮﻯ ﻭ ﻫـﻲ
ﺑﲔ ﺍﳌﺆﺷﺮ FileOutﻭ NULLﺣﻴﺚ NULLﻫﻲ:
0 #define NULL
ﻭ ﻳﻔﻀﻞ ﻛﺘﺎﺑﺔ NULLﺃﺣﺴﻦ ﻣﻦ ﺍﻟﺼﻔﺮ، ﺍﳌﻘﺎﺭﻧﺔ ﻫﻲ ﺇﻥ ﻛﺎﻧﺖ ﺃﺧﻄﺎﺀ ﻣﺜﻞ ﺇﺩﺧﺎﻝ ﺃﺣﺮﻑ ﻏﲑ ﻣﺘﻔﻖ ﻋﻠﻴﻬﺎ ﻣﺜـﻞ >< ﰲ
ﺍﺳﻢ ﺍﳌﻠﻒ ﻓﻬﻨﺎ ﺃﻳﻀﺎ ﺳﻴﺘﻢ ﺍﳋﺮﻭﺝ ﻣﻦ ﺍﻟﱪﻧﺎﻣﺞ ﺑﺪﻭﻥ ﺇﻛﻤﺎﻝ ﺗﻨﻔﻴﺬ ﺑﺎﻗﻲ ﺍﻷﻭﺍﻣﺮ، ﻭﰲ ﺣﺎﻟﺔ ﺃﻥ ﺍﳌﻘﺎﺭﻧﺔ ﺧﺎﻃﺌـﺔ ﻓـﺴﻴﺘﻢ
ﻛﺘﺎﺑﺔ ﺍﻟﻨﺺ ﺇﱃ ﺍﳌﻠﻒ
...
ﻭ ﺃﺧﲑﺍ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﱐ ﻭ ﺍﻟﻌﺸﺮﻳﻦ ﻭ ﻫﻲ ﺍﻟﺪﺍﻟﺔ fcloseﻭ ﻫﻲ ﳐﺘﺼﺮﺓ ﻣﻦ file closeﻭ ﺍﻟﱵ ﺗﻘﻮﻡ ﺑﺈﻏﻼﻕ ﺍﳌﻠﻒ
ﻋﻨﺪ ﺍﻻﻧﺘﻬﺎﺀ ﻣﻨﻪ ﺣﱴ ﳝﻜﻨﻨﺎ ﺍﺳﺘﻌﻤﺎﻟﻪ ﻣﺮﺓ ﺃﺧﺮﻯ ﺳﺘﻼﺣﻆ ﺫﻟﻚ ﻓﻴﻤﺎ ﺑﻌﺪ
...
hﺍﻵﻥ
ﻧﻘﻮﻡ ﺑﺈﻧﺸﺎﺀ ﺍﳌﻠﻒ ﺍﻟﺮﺋﻴﺴﻲ ﳌﺸﺮﻭﻋﻨﺎ ﺑﺎﺳﻢ :main
...
h
"#include"fileio
...
\n
;)CreateFile(FileName, String
ﺍﻟﱪﻧﺎﻣﺞ ٣,٧,٢: ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ CreateFileﻣﻦ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ
١,١,٧,٢ ﺍﻟﺪﺍﻟﺔ :fopen
}
fileio
...
hﻭ ﻫﻲ ﺧﺎﺻﺔ ﺑﺎﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﳌﻠﻔﺎﺕ ﻭ ﳍﺎ ﻭﺳﻴﻄﲔ، ﺍﻷﻭﻝ ﺑﻪ ﺳﻠﺴﻠﺔ ﺣﺮﻓﻴﺔ ﻭ
ﻫﻲ ﺍﺳﻢ ﺍﳌﻠﻒ، ﻭ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ ﻫﻮ ﺍﻟﻨﻤﻂ ﺃﻭ ﺍﻟﻮﺿﻊ ﺍﻟﺬﻱ ﺗﺮﻳﺪ ﺍﺳﺘﻌﻤﺎﳍﺎ )ﺍﻟﻘﺮﺍﺀﺓ ﺃﻭ ﺍﻟﻜﺘﺎﺑﺔ(، ﺻﻮﺭﺓ ﺗﻮﺿﻴﺤﻴﺔ:
٢,١,٧,٢ ﺍﻟﺪﺍﻟﺔ :fclose
ﺍﻟﺸﻜﻞ ١,٧,٢: ﻃﺮﻳﻘﺔ ﻓﺘﺢ ﻣﻠﻒ
ﻭ ﻫﻲ ﺃﻳﻀﺎ ﻣﻦ ﺩﻭﺍﻝ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ،stdio
...
٣,١,٧,٢ ﺍﻟﺪﺍﻟﺔ :exit
ﻣﻦ ﺩﻭﺍﻝ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ،stdlib
...
٢,٧,٢ ﺇﺿﺎﻓﺔ ﻧﺺ ﰲ ﺎﻳﺔ ﺍﳌﻠﻒ:
١
ﺍﻷﻣﺜﻞ ﺍﻟﺴﺎﺑﻘﺔ ﰲ ﻫﺬﺍ ﺍﻟﺪﺭﺱ ﻋﻨﺪﻣﺎ ﺗﻘﻮﻡ ﺑﻜﺘﺎﺑﺔ ﺍﺳﻢ ﻣﻠﻒ ﻣﻮﺟﻮﺩ ﺳﺎﺑﻘﺎ ﻓﺴﻴﺘﻢ ﻓﻘﺪﻩ، ﻭ ﻫﻨﺎ ﺳﻨﻌﺮﻑ ﻛﻴﻔﻴﺔ ﻧﻘـﻮﻡ
ﺑﺈﺿﺎﻓﺔ ﻧﺺ ﰲ ﺃﺧﺮ ﺍﳌﻠﻒ ﺑﺪﻭﻥ ﻓﻘﺪ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﻟﺴﺎﺑﻘﺔ
...
appending
٣,٧,٢ ﺍﻹﺩﺧﺎﻝ ﰲ ﺍﳌﻠﻔﺎﺕ:
ﺍﻹﺩﺧﺎﻝ ﺗﻌﲏ ﺍﻟﻘﺮﺍﺀﺓ، ﻭ ﰲ ﺍﳌﻠﻔﺎﺕ ﻫﻲ ﻗﺮﺍﺀﺓ ﳏﺘﻮﻯ ﻣﻠﻒ ﻭ ﺍﺳﺘﻌﻤﺎﻟﻪ ﰲ ﺍﻟﱪﻧﺎﻣﺞ
...
hﻗﻢ ﺑﺈﺿﺎﻓﺔ ﺍﻟﺘﺎﱄ:
)void DisplayFile(const char *FileName
{
;FILE *FileIn
;]4201[char String
)'0\' == if(*FileName
{
;)"printf("Error in name of file!\n
;)1(exit
}
{)if((FileIn = fopen(FileName, "r"))==NULL
;)"printf("Can't Open file!\n
;)1(exit
{}else
;)fgets(String, 1024, FileIn
;)printf("%s", String
}
;)fclose(FileIn
ﺍﻟﱪﻧﺎﻣﺞ ٤,٧,٢: ﺇﻧﺸﺎﺀ ﺩﺍﻟﺔ ﺗﻘﻮﻡ ﺑﻌﺮﺽ ﳏﺘﻮﻯ ﻣﻠﻒ
}
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
61
71
81
91
02
ﻫﻨﺎ ﻧﻜﻮﻥ ﻗﺪ ﺃﻋﻠﻨﺎ ﻋﻦ ﺍﻟﺪﺍﻟﺔ ﺍﻟﱵ ﺳﺘﻘﻮﻡ ﺑﻘﺮﺍﺀﺓ ﺍﳌﻠﻔﺎﺕ، ﻭ ﻫﻲ ﻣﺸﺎﺑﻪ ﺑﺪﺍﻟﺔ ﺇﻧﺸﺎﺀ ﺍﳌﻠﻔﺎﺕ
...
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺮﺍﺑﻊ ﻗﻤﻨﺎ ﺑﺎﻹﻋﻼﻥ ﻋﻦ ﻣﺼﻔﻮﻓﺔ ﻭ ﻫﻨﺎﻙ ﻧﻘﻮﻡ ﺑﻮﺿﻊ ﻧﺺ
ﺍﳌﻠﻒ
...
readﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺩﺱ ﻋﺸﺮ
ﺍﺳﺘﻌﻤﻠﻨﺎ ﺍﻟﺪﺍﻟﺔ ،fgetsﻭ ﻫﻲ ﻣﻦ ﺩﻭﺍﻝ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ stdio
...
FILE *FileInﺗﻘﻮﻡ ﺍﻟﺪﺍﻟﺔ fgets
ﺑﻮﺿﻊ ﺳﻠﺴﻠﺔ ﺣﺮﻭﻑ ﺍﳌﻠﻒ )ﲝﺠﻢ ﺍﻟﻮﺳﺎﺋﻂ ﺍﻟﺜﺎﱐ( ﰲ ﺍﻟﻮﺳﺎﺋﻂ ﺍﻷﻭﻝ ﻭ ﺍﻟﺬﻱ ﻫﻮ ﻋﺒﺎﺭﺓ ﻋﻦ ﺳﻠﺴﻠﺔ ﺣﺮﻭﻑ، ﰒ ﻃﺒـﻊ
ﺳﻠﺴﻠﺔ ﺣﺮﻭﻑ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ ﻋﺸﺮ
...
c
;)"printf("/////////Reading\\\\\\\\\n
;)DisplayFile(FileName
1
2
341
ﻭ ﻫﻨﺎ ﺍﺳﺘﻌﻤﻠﻨﺎ ﺍﻟﺪﺍﻟﺔ ﻻﺳﺘﻌﺮﺍﺽ ﳏﺘﻮﻯ ﺍﳌﻠﻒ
...
٢,٤,٧,٢ ﺍﻟﻨﻤﻂ +:a
ﻫﻨﺎ ﻳﺘﻢ ﺇﺿﺎﻓﺔ ﻧﺺ ﰲ ﺎﻳﺔ ﺍﳌﻠﻒ ﺇﺫﺍ ﻛﺎﻥ ﻣﻮﺟﻮﺩ ﻭ ﺇﻥ ﱂ ﻳﻜﻮﻥ ﻣﻮﺟﻮﺩ ﻳﺘﻢ ﺇﻧﺸﺎﺀﻩ، ﻭ ﺃﻳﻀﺎ ﻳﺴﺘﻌﻤﻞ ﻫﺬﺍ ﺍﻟـﻨﻤﻂ
ﻟﻠﻘﺮﺍﺀﺓ
...
ﻭ ﺗﻮﺟﺪ ﺃﳕﻂ ﺃﺧﺮﻯ ﻭ ﻫﻲ t ،r ،s ،bﻭ ،dﻭ ﻟﻜﻬﺎﻥ ﻏﲑ ﻣﻬﻤﺔ، ﺍﻷﳕﺎﻁ ﺍﻟﺴﺎﺑﻘﺔ ﻫﻲ ﺍﳌﻬﻤﺔ ﻭ ﺍﻟﱵ ﺗﺴﺘﻌﻤﻞ ﺑﻜﺜﺮﺓ
...
h
ﺍﻟﺪﻭﺍﻝ ﻫﻲ:
١,٥,٧,٢ ﺍﻟﺪﺍﻟﺔ fprintfﻭ ﺍﻟﺪﺍﻟﺔ :fscanf
ﺍﻟﺪﺍﻟﺔ fprintfﺩﺭﺳﻨﻬﺎ ﺳﺎﺑﻘﺎ، ﺃﻣﺎ ﺍﻟﺪﺍﻟﺔ fscanfﻓﻬﻲ ﻣﻜﺎﻓﺌﺔ ﻟﻠﺪﺍﻟﺔ scanfﻭ ﻫﻲ ﳐﺘﺼﺮﺓ ﻣـﻦ ،file scan fileﻭ
ﻟﻜﻨﻬﺎ ﻫﻨﺎ ﻻ ﺗﺄﺧﺬ ﻗﻴﻢ ﻣﻦ ﺍﳌﺴﺘﺨﺪﻡ، ﺑﻞ ﺗﺄﺧﺬﻫﺎ ﻣﻦ ﻗﻴﻢ ﻣﻦ ﻣﻠﻒ، ﺃﻱ ﺃﺎ ﺧﺎﺻﺔ ﺑﺎﻹﺩﺧﺎﻝ ﻟﻠﻤﻠﻔﺎﺕ، ﻣﺜﺎﻝ ﺳﺮﻳﻊ:
>#include
txt", "w
;)552 ,"fprintf(FileOut, "%s %d", "Hello
;)fseek(FileOut, 0, SEEK_SET
;)fscanf(FileOut, "%s", Str
;)fscanf(FileOut, "%d", &Var
;)printf("%s\n", Str
;)printf("%d\n", Var
;)fclose(FileOut
ﺍﻟﱪﻧﺎﻣﺞ ٥,٧,٢: ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ fprintfﻭ ﺍﻟﺪﺍﻟﺔ
}
6
7
8
9
01
11
21
31
41
51
61
71
81
91
02
12
fscanf
ﰲ ﺍﻟﺴﻄﺮ ﺍﳋﺎﻣﺲ ﻗﻤﻨﺎ ﺑﺎﻹﻋﻼﻥ ﻋﻦ ﻣﺆﺷﺮ ﻟﻠﺒﻨﻴﺔ FILEﺑﺎﺳﻢ
...
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺘﺎﺳﻊ
ﻗﻤﻨﺎ ﺑﻮﺿﻊ ﺍﺳﻢ ﺍﳌﻠﻒ ﺍﻟﺬﻱ ﺳﻨﻔﺘﺤﻪ ﻭ ﻧﻘﺮﺃ ﻣﻨﻪ ﺍﻟﺒﻴﺎﻧﺎﺕ ﺍﳌﻮﺟﻮﺩﺓ
...
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﻟﺚ ﻋﺸﺮ ﺗﻮﺟﺪ ﺩﺍﻟﺔ ﻭ ﻫﻲ fseekﻭ ﻫﻲ ﻣﻦ ﺩﻭﺍﻝ ﺍﳌﻠـﻒ ﺍﻟﺮﺃﺳـﻲ
stdio
...
SEEK_SETﻭ ﻫﻮ ﻭﺿﻊ ﻣﺆﺷﺮ ﺍﳌﻠﻒ ﰲ ﺍﻟﺒﺪﺍﻳﺔ
...
SEEK_CURﻭ ﻫﻮ ﺍﳌﻮﻗﻊ ﺍﳊﺎﱄ ﳌﺆﺷﺮ ﺍﳌﻠﻒ
...
SEEK_ENDﻭ ﻫﻮ ﻭﺿﻊ ﻣﺆﺷﺮ ﺍﳌﻠﻒ ﰲ ﺎﻳﺘﻪ
...
ﻭ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺮﺍﺑﻊ ﻋﺸﺮ ﻗﻤﻨﺎ ﺑﻔﺤﺺ ﺳﻠﺴﻠﺔ ﺍﳊﺮﻭﻑ ﺍﳌﻮﺟﻮﺩ ﰲ ﺍﳌﻠﻒ ﻭ ﻧـﺴﺨﻪ ﰲ
ﺍﻟﺴﻠﺴﻠﺔ ﺍﳊﺮﻓﻴﺔ ،Strﻭ ﻫﻮ ﺍﻟﻨﺺ
...
Varﻭ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﻣﻦ ﻋﺸﺮ ﻭ ﺍﻟﺘﺎﺳﻊ ﻋﺸﺮ ﻗﻤﻨﺎ ﺑﻄﺒﺎﻋﺔ ﺍﻟﻨﺘﺎﺋﺞ
...
h
)(main
{
;FILE *FileOut
;)"FileOut = fopen("fputs
...
٣,٥,٧,٢ ﺍﻟﺪﺍﻟﺔ fgetcﻭ ﺍﻟﺪﺍﻟﺔ :fputc
ﺍﻟﺪﺍﻟﺔ fgetcﺗﺄﺧﺬ ﺣﺮﻑ ﻭﺍﺣﺪ ﻣﻦ ﻣﻠﻒ، ﻭ ﺍﻟﺪﺍﻟﺔ fputcﺗﻘﻮﻡ ﺑﻄﺒﺎﻋﺔ ﺣﺮﻑ ﻭﺍﺣﺪ ﺇﱃ ﻣﻠﻒ ﻣﻌﲔ، ﻣﺜﺎﻝ:
>#include
txt", "w
;)"FileIn = fopen("fputc
...
ﻭ ﳝﻜـﻦ
ﻛﺘﺎﺑﺔ ﺍﳌﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ ﻋﻠﻰ ﻫﺬﻩ ﺍﻟﻄﺮﻳﻘﺔ:
>#include
txt", "w
;)fputc('A', FileInOut
;)fclose(FileInOut
;)"FileInOut = fopen("fputc
...
C
٦,٧,٢ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ:
ﻻ ﺗﻮﺟﺪ ﺃﺧﻄﺎﺀ ﳏﺘﻤﻠﺔ ﰲ ﻫﺬﺍ ﺍﻟﺪﺭﺱ
...
ﺃﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻳﻘﻮﻡ ﺑﻌﻤﻠﻴﺎﺕ ﺍﳉﻤﻊ ﻭ ﺍﻟﻄﺮﺡ ﺍﻟﻀﺮﺏ ﻭ ﺍﻟﻘﺴﻤﺔ، ﻭ ﻳﺘﻢ ﺣﻔﻆ ﺍﻟﻨﺘـﺎﺋﺞ ﰲ ﻣﻠـﻒ results
...
741
ﺍﻟﺘﺮﺍﻛﻴﺐ )ﺍﻟﺒﻨﻴﺎﺕ( ﻫﻲ ﳎﻤﻮﻋﺔ ﻣﻦ ﻣﺘﻐﲑ ﻭﺍﺣﺪ ﺃﻭ ﺃﻛﺜﺮ ﲡﻤﻊ ﲢﺖ ﺍﺳﻢ ﻭﺍﺣﺪ ﻳﺴﻬﻞ ﺍﺳﺘﻌﻤﺎﳍﺎ، ﻭ ﺍﳌـﺘﻐﲑﺍﺕ ﰲ
ﺍﻟﺘﺮﺍﻛﻴﺐ ﻟﻴﺲ ﻣﺜﻞ ﺍﳌﺘﻐﲑﺍﺕ ﰲ ﺍﳌﺼﻔﻮﻓﺎﺕ، ﳝﻜﻦ ﺃﻥ ﺗﻜﻮﻥ ﺑﻪ ﻣﺘﻐﲑﺍﺕ ﳐﺘﻠﻔﺔ ﺍﻷﻧﻮﺍﻉ، ﻭ ﺍﻟﺘﺮﺍﻛﻴﺐ ﳝﻜﻦ ﺃﻥ ﲢﻤﻞ ﺃﻱ
ﻧﻮﻉ ﻣﻦ ﻣﺘﻐﲑﺍﺕ ﻟﻐﺔ Cﺣﱴ ﻣﺼﻔﻮﻓﺎﺕ ﺃﻭ ﻣﺆﺷﺮﺍﺕ ﺃﻭ ﺗﺮﺍﻛﻴﺐ ﺩﺍﺧﻞ ﺗﺮﺍﻛﻴﺐ ﺃﺧﺮﻯ، ﻭ ﲨﻴﻊ ﺍﳌﺘﻐﲑﺍﺕ ﺍﳌﻮﺟﻮﺩ ﺩﺍﺧﻞ
ﺍﻟﺘﺮﺍﻛﻴﺐ ﺗﺴﻤﻰ ﺑﺄﻋﻀﺎﺀ ﻟﺘﺮﺍﻛﻴﺐ
...
§ ﺃﻥ ﻻ ﻳﺒﺪﺃ ﺍﺳﻢ ﺍﻟﺒﻨﻴﺔ ﺑﺄﺭﻗﺎﻡ
...
§ ﺃﻥ ﻻ ﻳﻜﻮﻥ ﺍﺳﻢ ﺍﻟﺒﻨﻴﺔ ﳛﺘﻮﻱ ﻋﻠﻰ ﺭﻣﻮﺯ ﻣﺜﻞ % ﻭ # ﻭ { ﻭ
...
§ ﺃﻥ ﻻ ﻳﻜﻮﻥ ﺍﺳﻢ ﺍﻟﺒﻨﻴﺔ ﻣﺴﺘﻌﻤﻞ ﺳﺎﺑﻘﺎ ﻻﺳﻢ ﺩﺍﻟﺔ ﺃﻭ ﻣﺘﻐﲑ ﺃﻭ ﺑﻨﻴﺔ ﺃﺧﺮﻯ
...
ﻭ ﺍﻹﻋﻼﻥ ﻋﻦ ﺍﻟﺒﻨﻴﺎﺕ ﻳﺴﺘﺤﺴﻦ ﺃﻥ ﻳﻜﻮﻥ ﺩﺍﺋﻤﺎ ﺧﺎﺭﺝ ﺍﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻭ ﻗﺒﻠﻬﺎ، ﻣﺜﺎﻝ:
841
>#include
x
;)" :printf("Enter Y
;)scanf("%d", &Struct_2D
...
x;x
{
;)912 ,"printf("%c
)++for(y=0;y
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﻟﺚ ﻗﻤﻨﺎ ﺑﺎﻹﻋﻼﻥ ﻋﻦ ﺍﻟﺒﻨﻴـﺔ
...
_2Dﰲ ﺍﻟـﺴﻄﺮ
ﺍﳊﺎﺩﻱ ﻋﺸﺮ ﻗﻤﻨﺎ ﺑﻜﺘﺎﺑﺔ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ structﻣﻊ ﺍﺳﻢ ﺍﻟﺒﻨﻴﺔ ﺍﻟﺴﺎﺑﻘﺔ _2Dﻭ ﺍﻻﺳﻢ Struct_2Dﻭ ﺍﻟـﺬﻱ ﺳـﻴﺘﻢ
ﺍﻟﻌﻤﻞ ﻋﻠﻴﻪ ﰲ ﻫﺬﺍ ﺍﻟﱪﻧﺎﻣﺞ، ﻭ ﻻ ﳝﻜﻦ ﻛﺘﺎﺑﺔ _2D Struct_2Dﺑﺪﻭﻥ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ ،structﻭ ﻻ ﳝﻜﻦ ﺍﺳـﺘﻌﻤﺎﻝ
ﺍﻟﺒﻨﻴﺔ _2Dﻣﺒﺎﺷﺮﺓ ﻟﺬﺍ ﳚﺐ ﺃﻥ ﻧﻘﻮﻡ ﺑﺈﻋﻼﻥ ﻋﻦ ﻣﺘﻐﲑ ﻟﻠﺒﻨﻴﺔ _2Dﻭ ﺍﻟﱵ ﻫﻲ Struct_2Dﰲ ﺑﺮﻧﺎﳎﻨﺎ ﻫﺬﺍ
...
ﻭ ﳝﻜﻦ ﺍﻹﻋﻼﻥ ﻋﻦ ﺃﻛﺜﺮ ﻣﻦ ﺑﻨﻴﺔ، ﻓﻤﺜﻼ ﺍﳌﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ ﰲ ﺍﻟﺴﻄﺮ ﺍﳊﺎﺩﻱ ﻋﺸﺮ ﳝﻜﻨﻨﺎ ﻛﺘﺎﺑﺔ:
;2_struct _2D Struct_2D_1, Struct_2D
ﻭ ﻫﻨﺎ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻝ ﻛﻞ ﻣﻦ ﺍﻟﺒﻨﻴﺘﲔ 1_ Struct_2Dﻭ ﺍﻟﺒﻨﻴﺔ 2_
...
h>
1
2
3
#include
x);
printf("Enter the position Y: ");
scanf("%d", &Struct_2D
...
x;x++)
{
printf("%c", 219);
for(y=0;y
h>
int x;
float y;
char *Str;
}Value;
main()
{
Value
...
y = 10
...
Str = "Hello, World";
}
printf("%d\n", Value
...
y);
printf("%s\n", Value
...
00, "Hello, World"};
main()
{
printf("%d\n", Value
...
y);
printf("%s\n", Value
...
00;
char *Str = "Hello World";
};
:_ ﻭ ﻻ ﻣﻌﲎ ﻻﺳﺘﻌﻤﺎﻝ ﺍﻟﺒﻨﻴﺔ ﺃﺻﻼ ﻷﻧﻪ ﳝﻜﻦ ﻛﺘﺎﺑﺔValue ﻷﻥ ﰲ ﻫﺬﻩ ﺍﳊﺎﻟﺔ ﻻ ﻣﻌﲎ ﻟﻠﺒﻨﻴﺔ
1
2
#include
01 = float y
;"char *Str = "Hello World
)(main
{
;)printf("%d\n", x
;)printf("%f\n", y
;)printf("%s\n", Str
}
ﺍﻟﱪﻧﺎﻣﺞ ٥,٨,٢: ﺃﻓﻀﻞ ﻣﻦ ﺇﺳﺘﻌﻤﺎﻝ ﺃﻋﻀﺎﺀ ﺍﻟﺒﻨﻴﺔ
3
4
5
6
7
8
9
01
11
21
٢,٨,٢ ﺍﻟﺒﻨﻴﺎﺕ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ :union
ﳝﻜﻨﻨﻨﺎ ﺍﻹﻋﻼﻥ ﻋﻦ ﺍﻟﺒﻨﻴﺎﺕ ﺑﺎﺳﺘﻌﻤﺎﻝ ﺍﻟﻜﻠﻤﺎﺕ ﺍﶈﺠﻮﺯﺓ unionﺑﻨﻔﺲ ﺍﻟﻄﺮﻕ ﺍﻟﺴﺎﺑﻘﺔ، ﻭ ﺍﻟﻔﺮﻕ ﺍﻟﻮﺣﻴﺪ ﺑﲔ ﺍﺳﺘﻌﻤﺎﻝ
ﺍﻟﺒﻨﻴﺔ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ structﻭ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ unionﻫﻮ ﻋﻨﺪ ﺍﺳـﺘﻌﻤﺎﻝ ﺍﻟﺒﻨﻴـﺎﺕ ﺑﺎﺳـﺘﺨﺪﺍﻡ union
ﻓﺎﻟﻨﺘﺎﺋﺞ ﻟﻦ ﺗﻜﻮﻥ ﻣﺜﻞ ﺍﻟﺒﻨﻴﺎﺕ ﺍﻟﱵ ﺑـ structﻣﺜﻼ ﺃﻧﻈﺮ ﺇﱃ ﺍﳌﺜﺎﻝ ﺍﻟﺘﺎﱄ:
>#include
x
;51 = Union
...
x = %d\n", Union
...
z = %d\n", Union
...
h
union _Union
{
;int x
;int y
;}Union
)(main
{
;51 = Union
...
x
1
2
3
4
5
6
7
8
9
01
11
21
31
152
14
15
16
}
printf("Union
...
x);
printf("Union
...
y);
(٢) union ﺍﻟﱪﻧﺎﻣﺞ ٧,٨,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﺨﺪﺍﻡ ﺑﻨﻴﺔ ﻣﻌﺮﻓﺔ ﺑـ
ﻭ ﺍﻟﺒﻨﻴﺎﺕ ﺑﺎﺳـﺘﺨﺪﺍﻡ ﺍﻟﻜﻠﻤـﺔ ﺍﶈﺠـﻮﺯﺓstruct ﳝﻜﻨﻚ ﺍﻵﻥ ﺍﺳﺘﻨﺘﺎﺝ ﺍﻟﻔﺮﻕ ﺑﲔ ﺍﻟﺒﻨﻴﺎﺕ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ
، ﻭ ﺍﻟﺬﻱ ﻫﻮ ﺇﺷﺘﺮﺍﻙ ﲨﻴﻊ ﺍﳌﺘﻐﲑﺍﺕ ﰲ ﻋﻨﻮﺍﻥ ﻭﺍﺣﺪ، ﻭ ﺇﻥ ﻏﲑﻧﺎ ﻗﻴﻤﺔ ﻣﺘﻐﲑ ﻭﺍﺣﺪﺓ ﻓﺴﺘﻜﻮﻥ ﺗﻠﻚ ﺍﻟﻘﻴﻤﺔ ﳉﻤﻴﻊunion
:ﻣﺘﻐﲑﺍﺕ ﺍﻟﺒﻨﻴﺔ، ﻣﺜﺎﻝ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include
h>
union _Union
{
int x1, x2;
int y1, y2;
}Union;
main()
{
Union
...
x1
Union
...
y1
Union
...
x1
Union
...
y1
Union
...
x1);
Union
...
y1);
Union
...
x1);
&Union
...
y1);
&Union
...
x = 10;
Union
...
00;
}
printf("Union
...
x);
printf("Union
...
y);
351
ﺍﻟﱪﻧﺎﻣﺞ ٩,٨,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﺨﺪﺍﻡ ﺑﻨﻴﺔ ﻣﻌﺮﻓﺔ ﺑـ (٤) union
ﺑﺎﻟﻨﺴﺒﺔ ﻟﻨﺘﻴﺠﺔ ﻣﺘﻐﲑ ﺍﻟﻌﺪﺩ ﺍﳊﻘﻴﻘﻲ yﺳﺘﻜﻮﻥ ﺻﺤﻴﺤﺔ، ﺃﻣﺎ ﺍﳌﺘﻐﲑ xﻓﺴﺘﻜﻮﻥ ﻧﺘﻴﺠﺘﻬﺎ ﻏﲑ ﻣﺮﻏﻮﺑﺔ، ﻭ ﳝﻜﻨﻚ ﺍﺳـﺘﻨﺘﺎﺝ
ﺍﻟﺴﺒﺐ
...
h
struct _Arr
{
;int x
;]2[}Arr
)(main
{
;01 = Arr[0]
...
x
;)printf("Arr[0]
...
x
;)printf("Arr[1]
...
x
ﺍﻟﱪﻧﺎﻣﺞ ١١,٨,٢: ﺍﳌﺼﻔﻮﻓﺎﺕ ﻋﻠﻰ ﺍﻟﺒﻨﻴﺎﺕ
}
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
ﻭ ﺃﻳﻀﺎ ﳝﻜﻦ ﻛﺘﺎﺑﺔ:
struct _Arr
{
;int x
;}02 ,01{ = ]2[}Arr
1
2
3
4
ﺑﺪﻝ:
;01 = Arr[0]
...
x
1
2
ﻭ ﳝﻜﻦ ﺃﻳﻀﺎ ﻛﺘﺎﺑﺔ ﻣﺼﻔﻮﻓﺔ ﻟﺒﻨﻴﺔ ﺛﻨﺎﺋﻴﺔ ﺃﻭ ﺛﻼﺛﻴﺔ ﺍﻷﺑﻌﺎﺩ ﺃﻭ ﺃﻛﺜﺮ ﺑﻨﻔﺲ ﺍﻟﻄﺮﻕ ﺍﻟﺴﺎﺑﻘﺔ ﺍﻟﱵ ﺩﺭﺳﻨﻬﺎ ﰲ ﺩﺭﺱ ﺍﳌﺼﻔﻮﻓﺎﺕ،
ﻭ ﳝﻜﻦ ﺃﻳﻀﺎ ﻛﺘﺎﺑﺔ ﻣﺼﻔﻮﻓﺔ ﻟﺒﻨﻴﺔ ﲢﺘﻮﻱ ﻋﻠﻰ ﻣﺘﻐﲑﺍﺕ ﻷﻧﻮﺍﻉ ﻋﺪﻳﺪﺓ ﻣﺜﻞ:
154
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include
00, "Str1"},
{20, 20
...
x = %d\n", Arr[0]
...
y = %f\n", Arr[0]
...
Str = %s\n", Arr[0]
...
x = %d\n", Arr[1]
...
y = %f\n", Arr[1]
...
Str = %s\n", Arr[1]
...
h>
struct _ptr
{
int x;
}Addr_ptr, *ptr;
main()
{
ptr = &Addr_ptr;
ptr->x = 10;
printf("ptr->x = %d\n", ptr->x);
}
/*Or*/
(*ptr)
...
x = %d\n", (*ptr)
...
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﻌﺎﺷﺮ ﺃﻋﻄﻴﻨﺎ ﻟﻠﻤﺆﺷﺮ ptrﻋﻨﻮﺍﻧﺎ ﻭ ﻫﻮ ﻋﻨﻮﺍﻥ ﺍﻟﺒﻨﻴﺔ
...
٤,٨,٢ ﺇﻋﻼﻥ ﺑﻨﻴﺔ ﺩﺍﺧﻞ ﺑﻨﻴﺔ:
ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻝ ﺑﻨﻴﺔ ﺩﺍﺧﻞ ﺑﻨﻴﺔ، ﻣﺜﻼ ﺇﺫﺍ ﺃﺭﺩﻧﺎ ﺃﻥ ﻧﺮﺳﻢ ﺧﻂ ﻣﺴﺘﻘﻴﻢ، ﻫﺬﺍ ﳛﺘﺎﺝ ﺇﱃ ﻧﻘﺘﻄﲔ، ﺍﻷﻭﱃ ﻫﻲ ﺑﺪﺍﻳﺔ ﺍﳌﺴﺘﻘﻴﻢ
ﻭ ﺍﻟﺜﺎﻧﻴﺔ ﻫﻲ ﺎﻳﺔ ﺍﳌﺴﺘﻘﻴﻢ، ﻭ ﳚﺐ ﺃﻥ ﻳﻜﻮﻥ ﻟﻜﻞ ﻧﻘﻄﺔ ﻣﻜﺎﺎ ﻋﻠﻰ ﺷﺎﺷﺔ ﺍﳊﺎﺳﻮﺏ ﰲ ﻛﻞ ﻣﻦ xﻭ ،yﻣﺜﺎﻝ:
>#include
point_1
...
point_1
...
point_2
...
point_2
...
y
٥,٨,٢ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ:
١
...
h
struct Struct
{
;int x, y
;}
1
2
3
4
5
6
7
651
ﺍﻟﱪﻧﺎﻣﺞ ٥١,٨,٢: ﺍﳋﻄﺄ ١
)(main
{
;01 = Struct
...
y
}
8
9
01
11
21
٢
...
ﺃﻛﺘﺐ ﺑﻨﻴﺔ ﺑﺴﻢ timeﺎ ﺛﻼﺛﺔ ﺃﻋﻀﺎﺀ ﻭ ﻫﻲ hh, mm, ssﻭ ﻛﻠﻬﺎ ﻣﻦ ﺍﻟﻨﻮﻉ ،intﻭ ﻧﻄﻠﺐ ﻣﻦ ﺍﳌـﺴﺘﺨﺪﻡ
ﺇﺩﺧﺎﻝ ﺍﻟﺴﺎﻋﺔ ﻭ ﺍﻟﺪﻗﻴﻘﺔ ﻭ ﺍﻟﺜﺎﻧﻴﺔ ﺍﳊﺎﻟﻴﺔ ﻭ ﻧﻌﻄﻲ ﺗﻠﻚ ﺍﻟﻘﻴﻢ ﻟﻠﺒﻨﻴﺔ timeﰒ ﻧﻄﺒـﻊ ﺍﻟـﺴﺎﻋﺔ ﻋﻠـﻰ ﺍﻟﻄﺮﻳﻘـﺔ
...
h
)(main
{
;int i
;)scanf("%d", &i
ﺍﻟﱪﻧﺎﻣﺞ ١,٩,٢: ﺍﻟﺪﺍﻟﺔ
}
1
2
3
4
5
6
7
8
scanf
ﻓﻬﻨﺎ ﺳﻴﺘﻢ ﻭﺿﻊ ﺍﻟﻘﻴﻤﺔ ﺍﳌﺪﺧﻠﺔ ﰲ ﻋﻨﻮﺍﻥ ﺍﳌﺘﻐﲑ ،iﻷﻥ ﺍﻟﺪﺍﻟﺔ scanfﺗﺘﻌﺎﻣﻞ ﻣﻊ ﺍﳌﺆﺷﺮﺍﺕ، ﻭ ﳝﻜﻦ ﻛﺘﺎﺑﺔ ﺍﳌﺘﻐﲑ ﺑـﺪﻭﻥ
ﻣﺆﺛﺮ، ﻭ ﻟﻜﻦ ﺍﻟﻨﺘﺎﺋﺞ ﻟﻦ ﺗﻜﻮﻥ ﺻﺤﻴﺤﺔ
...
h
;)Function(void
)(main
{
}
)Function(void
{
ﺍﻟﱪﻧﺎﻣﺞ ٢,٩,٢: ﻣﻌﲎ ﺩﺍﻟﺔ ﺎ ﻭﺳﻴﻂ
}
1
2
3
4
5
6
7
8
9
01
11
21
31
void
ﺃﻭ ﲡﺪ ﺍﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻧﻔﺴﻬﺎ ﺎ ﻫﺬﺍ ﺍﻟﻮﺳﻴﻂ، ﻣﺜﺎﻝ:
)main(void
{
ﺍﻟﱪﻧﺎﻣﺞ ٣,٩,٢: ﻣﻌﲎ ﺩﺍﻟﺔ ﺎ ﻭﺳﻴﻂ (٢) void
}
1
2
3
4
851
ﻣﺜﻞ ﻫﺬﻩ ﺍﻟﺪﻭﺍﻝ ﺍﻟﻮﺳﻴﻂ ﺍﳋﺎﺹ ﺎ ﻻ ﻳﻌﲏ ﺷﻲﺀ، ﻭ ﻛﻠﻤﺔ voidﺇﳒﻠﻴﺰﻳﺔ ﻭ ﻫﻲ ﺗﻌﲏ ﻓﺮﺍﻍ، ﻭ ﻫﺬﺍ ﻫﻮ ﻣﻌﲎ ﻛﺘﺎﺑﺔ ﺩﻭﺍﻝ
ﺎ ﻭﺳﻴﻂ ﻣﻦ ﻫﺬﺍ ﺍﻟﻨﻮﻉ، ﻳﻌﲏ ﺍﻟﺘﺄﻛﻴﺪ ﻋﻠﻰ ﺃﻥ ﺍﻟﺪﺍﻟﺔ ﻓﺎﺭﻏﺔ ﺍﻟﻮﺳﺎﺋﻂ، ﻭ ﻣﺜﻞ ﺗﻠﻚ ﺍﻟﺪﻭﺍﻝ ﳝﻜﻦ ﲡﺎﻫﻞ ﻛﺘﺎﺑـﺔ ﺍﻟﻜﻠﻤـﺔ
ﺍﶈﺠﻮﺯﺓ ،voidﺣﻴﺚ ﺃﻥ ﻛﻼ ﻣﻦ ﻫﺬﻩ ﺍﻷﻣﺜﻠﺔ:
>#include
}
ﺍﻟﱪﻧﺎﻣﺞ ٥,٩,٢: ﻣﻌﲎ ﺩﺍﻟﺔ ﺎ ﻭﺳﻴﻂ (٣) void
1
2
3
4
5
6
7
8
9
01
11
21
31
1
2
3
4
٢,٩,٢ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ :static
ﻛﻠﻤﺔ staticﺗﻌﲏ ﺳﺎﻛﻦ ﻭ ﻫﻲ ﺗﺴﺘﻌﻤﻞ ﻣﻊ ﺍﳌﺘﻐﲑﺍﺕ ﺣﻴﺚ ﲡﻌﻠﻬﺎ ﺛﺎﺑﺖ ﺑﻄﺮﻗﺔ ﺳﺘﻔﻬﻤﻬﺎ ﻣﻦ ﻫﺬﺍ ﺍﳌﺜﺎﻝ:
>#include
ﺇﺫﺍ ﻗﻤﻨـﺎ ﺑﺈﺯﺍﻟـﺔ
ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ staticﻣﻦ ﺍﳌﺘﻐﲑ Staticﻓﺴﺘﻜﻮﻥ ﺍﻟﻨﺘﺎﺋﺞ ﺛﺎﺑﺘﺔ ﻭ ﻫﻲ ١ ﻋﺸﺮﺓ ﻣﺮﺍﺕ، ﺃﻣﺎ ﻋﻨﺪ ﺍﺳﺘﻌﻤﺎﳍﺎ ﻓﺴﺘﺮﻯ ﺃﻥ
ﺍﻟﻨﺘﻴﺠﺔ ﻏﲑ ﺛﺎﺑﺘﺔ ﻭ ﺗﻌﻤﻞ ﺑﺘﺰﺍﻳﺪ
...
h
;)int Test_static(int a
)(main
{
;int i
)++for(i=0;i<=10;i
;))printf("%d * %d = %d\n", i, i, Test_static(i
}
)int Test_static(int a
{
;0 = static int c
;int a_c = a*c
;++c
;return a_c
}
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
61
71
81
91
02
ﺍﻟﱪﻧﺎﻣﺞ ٧,٩,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ (٢) static
ﻭ ﰲ ﺣﺎﻟﺔ ﺇﺯﺍﻟﺔ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ staticﻓﺴﺘﻜﻮﻥ ﲨﻴﻊ ﺍﻟﻨﺘﺎﺋﺞ ٠
...
٣,٩,٢ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ :typedef
ﺗﺴﺘﻌﻤﻞ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ typedefﻣﻊ ﻛﻞ ﻣﻦ ﺍﳌﺘﻐﲑﺍﺕ ﻭ ﺍﻟﺒﻨﻴﺎﺕ، ﻭ ﻫﻲ ﺗﻌﻄﻲ ﺇﻣﻜﺎﻧﻴﺎﺕ ﺍﻹﻋﻼﻥ ﻋﻨﻬﺎ ﻣﺜﻞ ﺍﻟﺒﻨﻴﺔ،
ﻣﺜﺎﻝ:
>#include
Decimalﰲ ﺍﻟـﺴﻄﺮ
ﺍﻟﺜﺎﻣﻦ ﻭ ﺍﻟﺘﺎﺳﻊ ﺍﺳﺘﻌﻤﻠﻨﺎ ﺍﳌﺘﻐﲑ Decimalﻟﻺﻋﻼﻥ ﻋﻦ ﺍﳌﺘﻐﲑﺍﺕ 1_ Varﻭ 2_ Varﻭ 3_ Varﻭ ﺗﻌﺎﻣﻠﻨـﺎ ﻣﻌـﺎ ﺗﻠـﻚ
ﺍﳌﺘﻐﲑﺍﺕ ﻛﺄﻱ ﻛﺘﻐﲑﺍﺕ ﺃﺧﺮﻯ
...
ﺃﻣﺎ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﺒﻨﻴﺔ ﻓﻬﻲ ﻧﻔﺴﻬﺎ ﻣﺸﺎﺑﻪ ﻣﺜﻼ:
>#include
h
1
2
3
4
5
6
7
8
9
01
11
21
struct _2D
{
;int x, y
;}
)(main
{
;struct _2D A
;struct _2D B
;01 = A
...
y
;)printf("%d\n", A
...
y
ﺍﻟﱪﻧﺎﻣﺞ ٩,٩,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ (٢) typedef
ﻭ ﻟﻜﻨﻬﺎ ﲡﻌﻠﻬﺎ ﺃﻛﺜﺮ ﻣﺮﻭﻧﺔ ﻣﻦ ﺍﻟﺴﺎﺑﻘﺔ، ﻣﺜﺎﻝ:
}
typedef struct _2D
{
;int x, y
;2}Struct1, Struct
)(main
{
;2_1Struct1 S1_1, S
;2_2Struct2 S2_1, S
161
;02 = S1_1
...
x
;04 = S2_1
...
y
}
ﺍﻟﱪﻧﺎﻣﺞ ٠١,٩,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ (٣) typedef
ﻣﻼﺣﻈﺔ: ﻋﻨﺪ ﺍﺳﺘﻌﻤﺎﻝ ﻣﺘﻐﲑﺍﺕ ﺃﻭ ﺩﻭﺍﻝ ﺃﻭ ﺑﻨﻴﺎﺕ ﻣﻊ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ typdefﻓﻼ ﳝﻜﻦ ﺇﻋﻄﺎﺀﻫﺎ ﻗﻴﻢ ﺳﺎﺑﻘﺔ ﻣﺜﻞ:
>#include
01 = PI
;)printf("%f\n", PI
}
ﺍﻟﱪﻧﺎﻣﺞ ١١,٩,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ (٤) typedef
31
41
51
1
2
3
4
5
6
7
8
٤,٩,٢ ﺑﺮﺍﻣﺞ ﺗﺪﺭﻳﺒﻴﺔ:
ﰲ ﻫﺬﺍ ﺍﳉﺰﺀ ﻣﻦ ﺍﻟﺪﺭﺱ ﺳﻨﺮﻯ ﺑﻌﺾ ﺍﻟﱪﺍﻣﺞ ﺍﻟﱵ ﺳﺘﺴﺎﻋﺪﻙ ﻋﻠﻰ ﻓﻬﻢ ﻟﻐﺔ Cﺑﺸﻜﻞ ﻣﺒﺴﻂ، ﻣﻊ ﺷﺮﺡ ﺳﺮﻳﻊ ﻟﻜـﻞ
ﺑﺮﻧﺎﻣﺞ:
١,٤,٩,٢ ﺍﻟﱪﻧﺎﻣﺞ ﺍﻷﻭﻝ، ﺍﻟﻨﺴﺦ:
ﰲ ﻫﺬﺍ ﺍﻟﱪﻧﺎﻣﺞ ﻧﻘﻮﻡ ﺑﻜﺘﺎﺑﺔ ﺩﺍﻟﺔ ﺗﻘﻮﻡ ﺑﻨﺴﺦ ﺳﻠﺴﻠﺔ ﺣﺮﻭﻑ ﺇﱃ ﺳﻠﺴﻠﺔ ﺣﺮﻭﻑ ﺃﺧﺮﻯ ﻓﺎﺭﻏﺔ، ﺍﳌﺜﺎﻝ:
ﺍﳌﻠﻒ :str
...
h
)strcopy(pointers
/*
{)void strcopy(char *From, char *To
)'0\'=!)++while((*To++ = *From
;
}
;)/*strcopy(arrays
{)][void strcopy(char From[], char To
;int i
;0 = i
)'0\'=!)]while((To[i] = From[i
;++i
ﺍﻟﱪﻧﺎﻣﺞ ٢١,٩,٢: ﺍﻟﻨﺴﺦ، ﺍﳌﻠﻒ
/*}
str
...
c
>#include
h
)(main
{
;"char *From = "STRING
;]6[char Empty
;)strcopy(From, Empty
;)printf(Empty
}
ﺍﻟﱪﻧﺎﻣﺞ ٣١,٩,٢: ﺍﻟﻨﺴﺦ، ﺍﳌﻠﻒ ﺍﻟﺮﺋﻴﺴﻲ
1
2
3
4
5
6
7
8
9
01
11
21
31
41
ﻫﻨﺎ ﺍﻟﺪﺍﻟﺔ ﺳﺘﻘﻮﻡ ﺑﻨﺴﺦ ﻣﺎ ﻫﻮ ﻣﻮﺟﻮﺩ ﰲ ﺍﻟﺴﻠﺴﻠﺔ Fromﺇﱃ ﺍﻟﺴﻠﺴﻠﺔ ،Emptyﰒ ﻧﻄﺒﻊ ﳏﺘﻮﻯ ﺍﻟﺴﻠـﺴﻠﺔ Emptyﻛـﻲ
ﻧﺘﺄﻛﺪ ﻣﻦ ﺍﻟﻨﺘﺎﺋﺞ
...
h
)void Change(int *a, int *b
{
;int c
;c = *a
;*a = *b
;*b = c
}
)(main
{
;int a, b
;5 = a
;01 = b
;)printf("a = %d, b = %d\n", a, b
;)Change(&a, &b
;)printf("a = %d, b = %d\n", a, b
}
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
61
71
81
91
02
12
22
361
ﺍﻟﱪﻧﺎﻣﺞ ٤١,٩,٢: ﺗﺒﺎﺩﻝ ﻗﻴﻢ ﺑﲔ ﻭﺳﻴﻄﲔ
ﺇﺫﺍ ﺍﺳﺘﻌﻤﻠﻨﺎ ﻣﺘﻐﲑﺍﺕ ﰲ ﻣﻜﺎﻥ ﺍﳌﺆﺷﺮﻳﻦ
ﻋﻨﺎﻭﻳﻦ ﺍﻟﺬﺍﻛﺮﺓ
...
h
)(main
{
;01 = const int Const
;int *ptr = &Const
;)printf("Const = %d\n", Const
;5 = *ptr
;)printf("Const = %d\n", Const
}
ﺍﻟﱪﻧﺎﻣﺞ ٥١,٩,٢: ﺗﻐﲑ ﻗﻴﻤﺔ ﺛﺎﺑﺖ
1
2
3
4
5
6
7
8
9
01
11
21
٤,٤,٩,٢ ﻋﻜﺲ ﺳﻠﺴﻠﺔ ﻧﺼﻴﺔ:
ﰲ ﻫﺬﺍ ﺍﻟﱪﻧﺎﻣﺞ ﻧﻘﻮﻡ ﺑﺈﻧﺸﺎﺀ ﺩﺍﻟﺔ ﺎ ﻭﺳﻴﻂ ﻟﺴﻠﺴﻠﺔ ﻣﻦ ﺣﺮﻭﻑ، ﺣﻴﺚ ﺗﻘﻮﻡ ﺗﻠﻚ ﺍﻟﺪﺍﻟﺔ ﺑﻌﻜﺲ ﺗﻠـﻚ ﺍﻟﺴﻠـﺴﻠﺔ ﰲ
ﻧﻔﺴﻬﺎ، ﺍﳌﺜﺎﻝ:
>#include
h
;)* void Reverse_Str(char
)(main
{
;"!char *str = "Hello, World
;)printf("%s\n", str
;)Reverse_Str(str
;)printf("%s\n", str
}
{)void Reverse_Str(char *String
;0 = int i = strlen(String)-1, j
;char ch
{)while(j
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
61
71
81
91
02
164
21
22
23
24
25
String[j] = String[i];
String[i] = ch;
j++, i--;
}
}
ﺍﻟﱪﻧﺎﻣﺞ ٦١,٩,٢: ﻋﻜﺲ ﺳﻠﺴﻠﺔ ﻧﺼﻴﺔ
:٥,٤,٩,٢ ﺍﻟﺘﺤﻮﻳﻞ ﻣﻦ ﺍﻟﻨﻈﺎﻡ ﺍﻟﻌﺸﺮﻱ ﺇﱃ ﺍﻟﻨﻈﺎﻡ ﺍﻟﺜﻨﺎﺋﻲ
:ﻣﻦ ﺧﻼﻝ ﻫﺬﺍ ﺍﻟﱪﻧﺎﻣﺞ ﳝﻜﻨﻚ ﺍﺳﺘﻨﺘﺎﺝ ﻛﻴﻔﻴﺔ ﺍﻟﺘﺤﻮﻳﻞ ﺇﱃ ﺑﺎﻗﻲ ﺍﻷﻧﻈﻤﺔ، ﺍﳌﺜﺎﻝ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include
h>
void To_Capital_letter(char ch[]);
main()
{
char *ch = "hello";
printf("Small Letters: %s\n", ch);
To_Capital_letter(ch);
printf("Capital Letters: %s\n", ch);
}
void To_Capital_letter(char ch[])
{
int i=0;
while(ch[i]!='\0'){
if(ch[i]>=97 && ch[i]<=122)
ch[i] = ch[i]-32;
++i;
}
}
ﺍﻟﱪﻧﺎﻣﺞ ٨١,٩,٢: ﺍﻟﺘﺤﻮﻳﻞ ﻣﻦ ﺍﳊﺮﻭﻑ ﺍﻟﺼﻐﲑﺓ ﺇﱃ ﺍﳊﺮﻭﻑ ﺍﻟﻜﺒﲑﺓ
...
h ﻭ ﻫﻲ ﻣﻦ ﺩﻭﺍﻝ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲstrcpy ﻣﻜﺎﻓﺌﺔ ﻟﻠﺪﺍﻟﺔwcscpy ﺍﻟﺪﺍﻟﺔ
: ﻓﻘﻂ ﻫﻲ ﻟﻸﺣﺮﻑ ﺍﻟﻌﺮﻳﻀﺔ، ﻣﺜﺎﻝstrcpy ، ﺗﻘﻮﻡ ﺑﻨﻔﺲ ﻋﻤﻞ ﺍﻟﺪﺍﻟﺔstring copy
#include
h>
main()
{
wchar_t *wStr = L"Hello";
wchar_t Empty[20];
wcscpy(Empty, wStr);
wprintf(L"%s\n", Empty);
}
wcscpy
ﺍﻟﱪﻧﺎﻣﺞ ٩١,٩,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ
:، ﻣﺜﺎﻝstring
...
h>
#include
h>
#include
h ، ﻭ ﻫﻲ ﻣﻦ ﺩﻭﺍﻝ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲgetchar ﻣﻜﺎﻓﺌﺔ ﻟﺪﺍﻟﺔgetwchar ﺍﻟﺪﺍﻟﺔ
:، ﻣﺜﺎﻝput wide character ، ﻭ ﳐﺘﺼﺮﺓ ﻣﻦputchar ﻣﻜﺎﻓﺌﺔ ﻟﺪﺍﻟﺔputwchar ، ﻭ ﺃﻳﻀﺎ ﺍﻟﺪﺍﻟﺔcharacter
#include
h
ﻭ ﻛﻞ ﻣﻦ ﺍﳊﺮﻓﲔ ﺍﻹﺿﺎﻓﻴﲔ wsﳐﺘﺼﺮﻳﻦ ﻣﻦ ،wide stringﻣﺜﺎﻝ:
>#include
h
)(main
{
;)012 ,012 ,"printf("The number %d is the character %c in ASCII code
...
861
٠١,٩,٢ ﻣﻌﻠﻮﻣﺎﺕ ﺃﻛﺜﺮ ﺣﻮﻝ ﺍﳌﺘﻐﲑﺍﺕ:
ﺍﻟﺸﻜﻞ ١,٩,٢: ﺟﺪﻭﻝ ﺃﺳﻜﻲ
ﺗﻮﺟﺪ ﻣﺘﻐﲑﺍﺕ ﺧﺎﺭﺟﻴﺔ ﻭ ﻣﺘﻐﲑﺍﺕ ﳏﻠﻴﺔ، ﺍﻷﻭﱃ ﻫﻲ ﻣﺘﻐﲑﺍﺕ ﻋﺎﻣﺔ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﳍﺎ ﺑﺼﻔﺔ ﻋﺎﻣﺔ، ﺃﻣﺎ ﺍﳌﺘﻐﲑﺍﺕ ﺍﶈﻠﻴـﺔ
ﻓﻬﻲ ﻣﺘﻐﲑﺍﺕ ﳍﺎ ﺣﺪﻭﺩﻫﺎ
...
h
/*/*Local Variable
/*/*Local Variable
ﺍﻟﱪﻧﺎﻣﺞ ٥٢,٩,٢: ﺍﳌﺘﻐﲑﺍﺕ ﺍﶈﻠﻴﺔ
)(void Func
{
;int a
}
)(main
{
;int b
}
1
2
3
4
5
6
7
8
9
01
11
961
ﻫﻨﺎ ﻛﻞ ﻣﻦ ﺍﳌﺘﻐﲑ aﰲ ﺍﻟﺪﺍﻟﺔ Funcﻭ ﺍﳌﺘﻐﲑ bﰲ ﺍﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻳﻌﺘﱪﺍ ﻣﺘﻐﲑﺍﺕ ﳏﻠﻴﺔ ﺣﻴﺚ ﻻ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻝ ﺍﳌـﺘﻐﲑ
ﰲ ﺍﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ﻷﻧﻪ ﺧﺎﺹ ﺑﺎﻟﺪﺍﻟﺔ ،Funcﻭ ﻻ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻝ ﺍﳌﺘﻐﲑ bﰲ ﺍﻟﺪﺍﻟﺔ Funcﻷﻧﻪ ﻣﻌﺮﻑ ﰲ ﺍﻟﺪﺍﻟﺔ ،mainﻭ
ﻫﺬﺍ ﻫﻮ ﻣﻔﻬﻮﻡ ﺍﳌﺘﻐﲑﺍﺕ ﺍﶈﻠﻴﺔ
...
h
/*/*External Variable
/*/*Use The External Variable ab
;int ab
)(void Func
{
;01 = ab
}
)(main
{
;)(Func
/*printf("%d\n", ab); /*print The External Variable ab
}
ﺍﻟﱪﻧﺎﻣﺞ ٦٢,٩,٢: ﺍﳌﺘﻐﲑﺍﺕ ﺍﳋﺎﺭﺟﻴﺔ
1
2
3
4
5
6
7
8
9
01
11
21
31
41
ﺍﳌﺘﻐﲑ abﻫﻮ ﺍﳌﺘﻐﲑ ﺍﻟﻌﺎﻡ ﻟﻠﱪﻧﺎﻣﺞ، ﺣﻴﺚ ﳝﻜﻦ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻌﻪ ﰲ ﲨﻴﻊ ﺍﻟﺪﻭﺍﻝ، ﺃﻋﻄﲔ ﻟﻠﻤﺘﻐﲑ abﻗﻴﻤﺔ ﰲ ﺍﻟﺪﺍﻟـﺔ Funcﰒ
ﻗﻨﺎ ﺑﺘﻨﻔﻴﺬ ﺍﻟﺪﺍﻟﺔ Funcﰲ ﺍﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ ﰒ ﻃﺒﻊ ﳏﺘﻮﻯ ﺍﳌﺘﻐﲑ ﺍﳋﺎﺭﺟﻲ abﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﻟﺚ ﻋﺸﺮ
...
٣,٠١,٩,٢ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ :extern
ﺗﺴﺘﻌﻤﻞ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ externﻣﻊ ﺍﳌﺘﻐﲑﺍﺕ ﺩﺍﺧﻞ ﺩﻭﺍﻝ، ﻭ ﺗﺴﺘﻌﻤﻞ ﳉﻌﻞ ﻣﺘﻐﲑ ﳏﻠﻲ ﻣﺸﺘﺮﻙ ﻣﻊ ﻣﺘﻐﲑ ﺧﺎﺭﺟﻲ،
ﻣﺜﻼ ﳝﻜﻨﻨﺎ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺘﻐﲑ ﳏﻠﻲ ﻭ ﻣﺘﻐﲑ ﺧﺎﺭﺟﻲ ﺑﻨﻔﺲ ﺍﻻﺳﻢ ﻭ ﻟﻜﻦ ﺑﻘﻴﻢ ﳐﺘﻠﻔﺔ، ﻣﺜﺎﻝ:
>#include
h
;int ab
)(void Func
{
;extern int ab
;01 = ab
;)printf("%d\n", ab
}
)(main
{
;5 = ab
;)(Func
;)printf("%d\n", ab
}
ﺍﻟﱪﻧﺎﻣﺞ ٨٢,٩,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ (٢) extern
ﻫﻨﺎ ﺳﺘﻜﻮﻥ ﻗﻴﻤﺔ ﺍﳌﺘﻐﲑ ﺍﳋﺎﺭﺟﻲ abﻫﻲ ﻧﻔﺲ ﻗﻴﻤﺔ ﺍﳌﺘﻐﲑ ﺍﻟﺪﺍﺧﻠﻲ
...
h
)(void Func
{
;0 = static int Static
;0 = auto int Auto
;)++printf("Static = %d\n", Static
printf("Auto
;)++= %d\n", Auto
1
2
3
4
5
6
7
8
9
171
}
)(main
{
;0 = int i
{)3=<while(i
;)(Func
;++i
}
ﺍﻟﱪﻧﺎﻣﺞ ٩٢,٩,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﻜﻠﻤﺔ
ﺍﶈﺠﻮﺯﺓ auto
}
01
11
21
31
41
51
61
71
81
91
02
ﻭ ﳝﻜﻦ ﻛﺘﺎﺑﺔ ﺍﳌﺘﻐﲑ Autoﺑﺪﻭﻥ ﺍﺳﺘﺨﺪﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ
...
h
)(main
{
;4 = register Reg_Var
;)printf("Reg_Var = %d\n", Reg_Var
ﺍﻟﱪﻧﺎﻣﺞ ٠٣,٩,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ
}
1
2
3
4
5
6
7
8
register
ﻭ ﻻ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻝ ﺍﻹﺩﺧﺎﻝ ﳌﺘﻐﲑﺍﺕ ﺍﻟﺴﺠﻞ
...
h
)(main
{
;]008[int SizeOfArray
1
2
3
4
5
6
7
271
printf("short
;))= %d Byte(s)\n", sizeof(short
printf("int
;))= %d Byte(s)\n", sizeof(int
printf("unsigned
;))= %d Byte(s)\n", sizeof(unsigned
printf("signed
;))= %d Byte(s)\n", sizeof(signed
printf("long
;))= %d Byte(s)\n", sizeof(long
printf("float
;))= %d Byte(s)\n", sizeof(float
printf("double
;))= %d Byte(s)\n", sizeof(double
;))printf("SizeOfArray = %d Byte(s)\n", sizeof(SizeOfArray
ﺍﻟﱪﻧﺎﻣﺞ ١٣,٩,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ
}
8
9
01
11
21
31
41
51
61
sizeof
ﻭﻫﻨﺎ ﺳﺘﺘﻌﺮﻑ ﻋﻠﻰ ﺃﺣﺠﺎﻡ ﺃﻧﻮﺍﻉ ﺍﳌﺘﻐﲑﺍﺕ ﺍﻟﱵ ﺗﺮﻳﺪﻫﺎ، ﻭ ﳝﻜﻦ ﺃﻳﻀﺎ ﻣﻌﺮﻓﺔ ﺣﺠﻢ ﻣﺼﻔﻮﻓﺔ ﻛﻤﺎ ﰲ ﺍﳌﺜﺎﻝ
...
h
)void Func(int num
{
;)printf("%d\n", num
;)1+Func(num
}
ﺍﻟﱪﻧﺎﻣﺞ ٢٣,٩,٢: ﺍﺳﺘﺪﻋﺎﺀ ﺩﺍﻟﺔ ﻟﻨﻔﺴﻬﺎ
)(main
{
;)5(Func
}
1
2
3
4
5
6
7
8
9
01
11
21
ﻫﻨﺎ ﺍﺳﺘﺪﻋﻴﻨﺎ ﺍﻟﺪﺍﻟﺔ ﻟﻨﻔﺴﻬﺎ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺩﺱ، ﻭ ﰲ ﻫﺬﺍ ﺍﻟﱪﻧﺎﻣﺞ ﺳﻴﺘﻢ ﺍﻟﺘﻜﺮﺍﺭ ﺇﱃ ﺃﻥ ﻳﺼﻞ ﺇﱃ ﺍﳊﺪ ﺍﻷﻗﺼﻰ ﻣﻦ ﺍﻟﻘـﻴﻢ
ﺍﻟﱵ ﳝﻜﻦ ﺃﻥ ﳛﻤﻠﻬﺎ ﻧﻮﻉ ﺍﳌﺘﻐﲑ، ﻭ ﻫﺎ ﺳﻴﺘﻮﻗﻒ ﺍﻟﱪﻧﺎﻣﺞ ﻋﻨﺪ ﺍﻟﺮﻗﻢ ٥٣٥٥٦ ﻷﻧﻪ ﺍﻟﻌﺪﺩ ﺍﻷﻗﺼﻰ ﺍﻟﺬﻱ ﳝﻜﻦ ﺃﻥ ﳛﻤﻠـﻪ
ﺍﳌﺘﻐﲑ ،int numﻟﻨﺠﻌﻞ ﺍﻟﺪﺍﻟﺔ ﺗﻘﻮﻡ ﺑﺘﻜﺮﺍﺭ ﳏﺪﻭﺩ ﻧﺴﺘﻌﻤﻞ ﺷﺮﻁ ﻣﺜﻞ ﺍﻟﺘﺎﱄ:
>#include
21
31
41
51
٣١,٩,٢ ﺍﻟﺘﺤﻜﻢ ﰲ ﻃﺒﺎﻋﺔ ﺍﻟﻨﺘﺎﺋﺞ:
ﰲ ﺍﻟﺪﺍﻟﺔ ،printfﳝﻜﻨﻨﺎ ﺍﻟﺘﺤﻜﻢ ﰲ ﻃﺮﻳﻘﺔ ﻃﺒﻊ ﺍﻟﻨﺘﺎﺋﺞ، ﺳﻮﺍﺀ ﻛﺎﻧﺖ ﺍﻟﻨﺘﺎﺋﺞ ﻋﺒﺎﺭﺓ ﻋﻦ ﺃﺭﻗﺎﻡ ﺃﻭ ﺣﺮﻭﻑ، ﻓﻤﺜﻼ ﺇﺫﺍ
ﻛﺎﻥ ﻟﺪﻳﻨﺎ ﻋﺪﺩ ﺣﻘﻴﻘﻲ ﻟﻪ ﺃﺭﺑﻌﺔ ﺃﺭﻗﺎﻡ ﻭﺭﺍﺀ ﺍﻟﻔﺎﺻﻠﺔ ﻭ ﻻ ﻧﺮﻳﺪ ﻃﺒﺎﻋﺔ ﺇﻻ ﺇﺛﻨﲔ ﻣﻨﻬﺎ ﻧﺴﺘﻌﻤﻞ ﺍﻟﻄﺮﻕ ﺍﻟﺘﺎﻟﻴﺔ:
>#include
1415F
/*/*String
;)printf("%s\n", str
;)printf("%5s\n", str
;)printf("%-5s\n", str
;)printf("%5
...
5s\n", str
;)"printf("\n
/*/*Float number
;)printf("%10
...
1f\n", flt
;)printf("%
...
3f\n", flt
;)printf("%
...
٤١,٩,٢ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ:
ﻻ ﺗﻮﺟﺪ ﺃﺧﻄﺎﺀ ﳏﺘﻤﻠﺔ ﰲ ﻫﺬﺍ ﺍﻟﺪﺭﺱ
...
١,٣ ﺍﳊﺴﺎﺏ
...
Command-line Arguments
٣,٣ ﺍﻟﺘﻮﺟﻴﻬﺎﺕ )
...
٥,٣ ﺍﳌﻜﺘﺒﺔ ﺍﻟﻘﻴﺎﺳﻴﺔ
...
ﺑﺎﻟﺘﻮﻓﻴﻖ ﺇﻥ ﺷﺎﺀ ﺍﷲ
ﻗﺎﻝ ﺍﷲ ﺗﻌﺎﱃ:
﴿ ﻗﻞ ﻫﻞ ﻳﺴﺘﻮﻱ ﺍﻟﺬﻳﻦ ﻳﻌﻠﻤﻮﻥ ﻭ ﺍﻟﺬﻳﻦ ﻻ ﻳﻌﻠﻤﻮﻥ ﴾
ﺻﺪﻕ ﺍﷲ ﺗﻌﺎﱃ
671
ﺍﳊﺴﺎﺏ ) (Enumerationﻫﻮ ﳎﻤﻮﻋﺔ ﻣﻦ ﺛﻮﺍﺑﺖ ﺃﻋﺪﺍﺩ ﺻﺤﻴﺤﺔ ،intﻭ ﻳﺘﻢ ﺍﻹﻋﻼﻥ ﻋﻨﻬﺎ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ
enumﻭ ﺍﻟﱵ ﻫﻲ ﳐﺘﺼﺮﺓ ﻣﻦ ،enumerationﻭ ﻫﻲ ﻣﺸﺎﺎ ﻟﻠﺒﻨﻴﺔ ﰲ ﺍﻹﻋﻼﻥ ﻋﻨﻬﺎ ﻭ ﻃﺮﻳﻘﺔ ﺍﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ
...
§ ﺃﻥ ﻻ ﻳﺒﺪﺃ ﺍﺳﻢ ﺍﳊﺴﺎﺏ ﺑﺄﺭﻗﺎﻡ
...
§ ﺃﻥ ﻻ ﻳﻜﻮﻥ ﺍﺳﻢ ﺍﳊﺴﺎﺏ ﳛﺘﻮﻱ ﻋﻠﻰ ﺭﻣﻮﺯ ﻣﺜﻞ % ﻭ # ﻭ { ﻭ
...
§ ﺃﻥ ﻻ ﻳﻜﻮﻥ ﺍﺳﻢ ﺍﳊﺴﺎﺏ ﻣﺴﺘﻌﻤﻞ ﺳﺎﺑﻘﺎ ﻻﺳﻢ ﺩﺍﻟﺔ، ﻣﺘﻐﲑ، ﺑﻨﻴﺔ ﺃﻭ ﺣﺴﺎﺏ ﺁﺧﺮ
...
٢,١,٣ ﺛﻮﺍﺑﺖ ﺍﳊﺴﺎﺏ:
177
ﺛﻮﺍﺑﺖ ﺍﳊﺴﺎﺏ ﳝﻜﻦ ﺃﻥ ﲢﻤﻴﻞ ﻗﻴﻢ ﺃﻋﺪﺍﺩ ﺻﺤﻴﺤﺔ ﻓﻘﻂ، ﻭ ﻳﺘﻢ ﺍﻟﻔﺼﻞ ﺑﲔ ﺛﻮﺍﺑﺖ ﻭ ﺁﺧﺮ ﺑﺎﺳﺘﻌﻤﺎﻝ ﺍﻟﻔﺎﺻﻠﺔ
...
ﺳﻨﻘﻮﻡ ﺍﻵﻥ ﺑﻜﺘﺎﺑﺔ ﺃﺑﺴﻂ ﻣﺜﺎﻝ ﻟﻜﻴﻔﻴﺔ ﺍﺳﺘﻌﻤﺎﻝ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include
h>
enum _COLOR
{
RED = 0,
BLUE,
GREEN
}Color;
main()
{
/*Color = RED;*/
Color = BLUE;
/*Color = GREEN;*/
if(Color == RED){
printf("Color = %d\n", Color);
}else if(Color == BLUE){
871
;)printf("Color = %d\n", Color
{)}else if(Color == GREEN
;)printf("Color = %d\n", Color
}else
;)"printf("Error!\n
}
ﺍﻟﱪﻧﺎﻣﺞ ٢,١,٣: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ (٢) enum
91
02
12
22
32
42
ﻭ ﳝﻜﻦ ﺃﻳﻀﺎ ﺇﻋﻄﺎﺀ ﺍﻟﻘﻴﻤﺔ ﺍﳌﺨﺘﺎﺭ ﻣﺒﺎﺷﺮﺓ ﻋﻨﺪ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﻌﺮﻑ ﻟﻠﺤﺴﺎﺏ _COLORﻣﺜﻞ ﻛﺘﺎﺑﺔ:
;enum _COLOR Color = BLUE
ﺃﻭ ﻛﺘﺎﺑﺔ:
enum _COLOR
{
,0 = RED
,BLUE
GREEN
;}Color = BLUE
ﺳﻨﺸﺮﺡ ﺍﻵﻥ ﺍﳌﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ ﻣﻊ ﺍﻟﻘﻠﻴﻞ ﻣﻦ ﺍﻟﺘﻔﺎﺻﻴﻞ
...
ﻭ ﺛﻮﺍﺑـﺖ ﺍﻟﻜﻠﻤـﺔ
ﺍﶈﺠﻮﺯﺓ enumﻧﻘﻮﻡ ﺑﻜﺘﺎﺑﺔ ﺃﲰﺎﺀﻫﺎ ﺑﺪﻭﻥ ﻛﺘﺎﺑﺔ ﻧﻮﻋﻬﺎ، ﺣﻴﺚ ﻗﻠﻨﺎ ﺳﺎﺑﻘﺎ ﺃﻥ ﻧﻮﻋﻬﺎ ﻫﻮ ﺃﻋﺪﺍﺩ ﺻﺤﻴﺤﺔ
...
ﻭ ﳝﻜﻦ ﺃﻥ ﻻ ﻧﻌﻄـﻲ
ﻟﻠﺜﺎﺑﺖ REDﺍﻟﻘﻴﻤﺔ ٠، ﻷﻧﻪ ﻳﺘﻢ ﺇﻋﻄﺎﺀﻩ ﺍﻟﻘﻴﻤﺔ ٠ ﺗﻠﻘﺎﺋﻴﺎ ﺇﻥ ﱂ ﺗﻜﻦ ﻟﺪﻳﻪ ﻗﻴﻤﺔ ﺳﺎﺑﻘﺔ
...
ﻭ ﳝﻜﻦ ﺃﻥ
ﻧﻌﻄﻲ ﺃﻛﺜﺮ ﻣﻦ ﻣﻌﺮﻑ ﻟﻠﺤﺴﺎﺑﺎﺕ ﻣﺜﻞ ﺍﻟﺒﻨﻴﺎﺕ، ﻣﺜﺎﻝ:
>#include
h>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include
h>
enum _COLOR
{
RED = 0,
BLUE,
GREEN
}cRed = RED, cBlue = BLUE, cGreen = GREEN;
main()
{
}
(٤) enum ﺍﻟﱪﻧﺎﻣﺞ ٤,١,٣: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ
:ﻭ ﺗﻮﺟﺪ ﻃﺮﻕ ﺃﺧﺮﻯ ﻛﺜﲑﺓ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﳍﺎ ﻣﻊ ﺍﳊﺴﺎﺑﺎﺕ ﻣﻨﻬﺎ ﺇﻋﻄﺎﺀ ﳌﺘﻐﲑ ﻗﻴﻤﺔ ﺣﺴﺎﺏ ﻣﺜﻞ
enum _NUMBER
{
Num = 10,
Num2 = 20
};
main()
{
enum _NUMBER Number = Num;
int i = 0;
printf("i
i = Number;
= %d\n", i);
printf("Number = %d\n", Number);
printf("i
= %d\n", i);
}
enum _COLOR
(٥) enum ﺍﻟﱪﻧﺎﻣﺞ ٥,١,٣: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ
:ﻭ ﳝﻜﻦ ﺃﻳﻀﺎ ﺍﺳﺘﻌﻤﺎﻝ ﺍﻹﺩﺧﺎﻝ ﻋﻠﻰ ﺍﳊﺴﺎﺏ ﻣﺜﻞ
180
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
{
};
BLACK,
WHITE,
RED,
GREEN,
BLUE
main()
{
enum _COLOR Color;
printf("colors:\n");
printf("0)BLACK\n1)WHITE\n2)RED\n3)GREEN\n4)BLUE\n");
printf("choose a color:");
scanf("%d", &Color);
if(Color == BLACK){
printf("Your choice
}else if(Color == WHITE){
printf("Your choice
}else if(Color == RED){
printf("Your choice
}else if(Color == GREEN){
printf("Your choice
}else if(Color == BLUE){
printf("Your choice
}
}
are Black\n");
are White\n");
are Red\n");
are Green\n");
are Blue\n");
(٦) enum ﺍﻟﱪﻧﺎﻣﺞ ٦,١,٣: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ
:٣,١,٣ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ
:١
...
h>
enum _NUMBER
{
Zero,
One
};
main()
{
enum _NUMBER = ZERO;
}
١ ﺍﻟﱪﻧﺎﻣﺞ ٧,١,٣: ﺍﳋﻄﺄ
...
ﺃﻛﺘﺐ ﺑﺮﻧﺎﻣﺞ ﺑﻪ ﺣﺴﺎﺏ ﺑﺎﺳﻢ _POWERﺑﻪ ﺛﺎﺑﺘﲔ، ﺍﻷﻭﻝ ﺑﺎﺳﻢ Offﻭ ﺍﻟﺜﺎﱐ ﺑﺎﺳﻢ ،Onﰒ ﻗﻢ ﺑﺎﺳﺘﺨﺪﺍﻡ ﻣﻌﺮﻓﺔ
ﻟﻠﺤﺴﺎﺏ _POWERﺑﺎﺳﻢ Powerﻭ ﺍﺳﺘﻌﻤﻠﻬﺎ ﻟﻺﺩﺧﺎﻝ ﻣﺒﺎﺷﺮﺓ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﺪﺍﻟﺔ ،scanfﻓﺈﺫﺍ ﻛﺎﻧﺖ ﺍﻟﻨﺘﻴﺠـﺔ
ﺍﳌﺪﺧﻞ ٠ ﺃﻱ Offﻓﺴﻴﺘﻢ ﺍﳋﺮﻭﺝ ﻣﻦ ﺍﻟﱪﻧﺎﻣﺞ، ﺃﻣﺎ ﺇﺫﺍ ﻛﺎﻧﺖ ﺍﻟﻌﻜﺲ ﺃﻱ ١ ) (Onﻓﺴﻴﺒﻘﻰ ﺍﻟﱪﻧﺎﻣﺞ ﻳﺴﺘﻤﺮ ﺣﱴ
ﺗﺼﺒﺢ ﺍﻟﻘﻴﻤﺔ ﺍﳌﺪﺧﻠﺔ ﻟﻠﺤﺴﺎﺏ Powerﻫﻲ ٠
...
ﻭ ﻣﺜﺎﻝ ﻋﻠﻰ ﺫﻟﻚ
ﺍﻷﻭﺍﻣﺮ ﺍﻟﱵ ﻳﺘﻢ ﺇﺳﺘﺪﻋﺎﺀﻫﺎ ﰲ ﻧﻈﺎﻡ DOSﻣﺜﻼ، ﺑﻌﺾ ﻣﻦ ﻫﺬﻩ ﺍﻷﻭﺍﻣﺮ ﲢﺘﺎﺝ ﺇﱃ ﻭﺳﺎﺋﻂ ﻣﺜﻞ ﺍﻷﻣﺮ delﻭ ﺍﻟـﺬﻱ ﻳﻘـﻮﻡ
ﲝﺬﻑ ﻣﻠﻒ، ﻭ ﻣﻦ ﻭﺳﺎﺋﻄﻪ ﻫﻲ ﺇﺳﻢ ﺍﳌﻠﻒ ﺍﻟﺬﻱ ﺳﻴﺘﻢ ﺣﺬﻓﻪ، ﻭ ﺑﻌﺾ ﺍﻟﻮﺳﺎﺋﻂ ﺧﻴﺎﺭﺍﻳﺔ ﻣﺜﻞ ﺍﳋﻴﺎﺭ /pﻭ /sﻣﺜﻼ
...
ﻭ ﻣﺜﺎﻝ ﻋﻠﻰ ﺫﻟﻚ ﻧﺄﺧﺬ ﺍﳌﺜﺎﻝ ﺍﻟﺴﺎﺑﻖ ﻭ ﺍﻟﺬﻱ ﻫﻮ ﺍﻷﻣﺮ ،delﻭ ﻧﻜﺘﺐ ﻣﺜﻼ ،del filename
...
extﻭ ﺍﻟﻘﻴﻤﺔ ﺍﻟﺜﺎﻟﺜﺔ
ﻟﻠﺨﻴﺎﺭ ،/pﻭ ﻣﻦ ﻫﺬﺍ ﺍﳌﺜﺎﻝ ﻧﺴﺘﻨﺘﺞ ﺃﻥ ﺍﳌﺘﻐﲑ argcﻳﻘﻮﻡ ﲝﺴﺎﺏ ﻭﺳﺎﺋﻂ ﺍﻟﱪﻧﺎﻣﺞ ﺑﺎﻹﻋﺘﻤﺎﺩ ﻋﻠﻰ ﺍﻟﻔﺮﺍﻏﺎﺕ )ﺃﻱ ﺍﻟﻔـﺼﻞ
ﺑﲔ ﺧﻴﺎﺭ ﻭ ﺁﺧﺮ ﲟﺴﺎﺣﺔ(
...
h
)main(int argc
{
;)printf("Program have %d argument(s)
...
cﰒ ﻗﻢ ﺑﺈﻧﺸﺎﺀ ﺍﳌﻠﻒ ﺍﻟﺘﻨﻔﻴﺬﻱ ﻟﻪ ﻭ ﻣﻦ ﻣﻨﻔﺬ ﺍﻷﻭﺍﻣﺮ ﻗﻢ ﺑﺘﻨﻔﻴﺬ ﺍﻟﱪﻧﺎﻣﺞ ﻋﻠﻰ ﺍﻟﺸﻜﻞ:
test this_is_the_first_argument and_this_is_the_second_argument
ﻭ ﻧﺎﺗﺞ ﻫﺬﻩ ﺍﻟﱪﻧﺎﻣﺞ ﻳﻜﻮﻥ ﻋﻠﻰ ﺍﻟﺸﻜﻞ:
...
argcﻭ ﻫﻨﺎ ﺍﳌﺘﻐﲑ argcﳝﻜﻦ ﺇﻋﻄﺎﺀﻩ ﺇﺳﻢ ﺁﺧﺮ، ﻷﻥ ﺍﳌﺘﺮﺟﻢ ﻳﺄﺧﺬﻫﺎ ﻋﻠﻰ ﺷﻜﻞ ﻭﺳﺎﺋﻂ ﻭ ﻟﻴﺲ ﺃﲰـﺎﺀ، ﻭ
ﻟﻜﻦ ﺑﻌﺾ ﺍﳌﺘﺮﲨﺎﺕ ﺗﺄﺧﺬ ﻫﺬﻩ ﺍﻟﻮﺳﺎﺋﻂ ﻋﻠﻰ ﺷﻜﻞ ﺃﲰﺎﺀ، ﺃﻱ ﺃﳕﻪ ﻻ ﳝﻜﻦ ﺍﻟﺘﻐﲑ ﰲ ﺍﻹﺳﻢ
...
h
)][main(int argc, char *argv
{
;int i
;)printf("Program have %d argument(s)
...
\TEST
...
h
>#include
\n\n
;)"printf("Usage: DEL FILENAME\n
}
{else
1
2
3
4
5
6
7
8
9
01
11
481
;)]1[printf("Delete %s file, are you sure? (Y/N): ", argv
{)'if((ch=getche())=='y' || ch=='Y
;)]1[printf("\nDeleting %s
...
\n", argv
}
ﺍﻟﱪﻧﺎﻣﺞ ٣,٢,٣: ﺑﺮﻧﺎﻣﺞ ﺫﺍﺕ ﻭﺳﺎﺋﻂ ﻳﻘﻮﻡ ﲝﺬﻑ ﻣﻠﻔﺎﺕ
}
}
21
31
41
51
61
71
81
91
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ ﻗﻤﻨﺎ ﺑﻌﻤﻞ ﺷﺮﻁ ﻭ ﻫﻮ ﺇﻥ ﻛﺎﻥ ﻋﺪﺩ ﻭﺳﺎﺋﻂ ﺍﻟﱪﻧﺎﻣﺞ ﺃﻗﻞ ﻣﻦ ٢، ﺃﻱ ﺃﻥ ﺍﻟﻮﺳﺎﺋﻂ ﺍﳌﻄﻠﻮﺑﺔ ﻏﲑ ﻣﺘﻮﻓﺮﺓ،
ﰒ ﻧﻈﻬﺮ ﻟﻠﻤﺴﺘﺨﺪﻡ ﻃﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﻝ ﺍﻟﱪﻧﺎﻣﺞ
...
(argv
٣,٢,٣ ﺍﻷﺧﻄﺎﺀ ﺍﶈﺘﻤﻠﺔ:
١
...
٤,٢,٣ ﲤﺎﺭﻳﻦ:
ﻻ ﺗﻮﺟﺪ ﲤﺎﺭﻳﻦ ﰲ ﻫﺬﺍ ﺍﻟﺪﺭﺱ
...
#
١,٣,٣ ﺍﻟﺘﻮﺟﻴﻪ :#include
ﻳﻌﺘﱪ ﻫﺬﺍ ﺍﻟﺘﻮﺟﻴﻪ ﻣﻦ ﺃﻫﻢ ﺍﻟﺘﻮﺟﻬﺎﺕ، ﻭ ﻗﺪ ﻗﻤﻨﺎ ﺑﺎﺳﺘﻌﻤﻠﻪ ﻭ ﺩﺭﺍﺳﺘﻪ ﺳﺎﺑﻘﺎ، ﻭ ﻫﻮ ﻳﻄﻠﺐ ﻣﻦ ﺍﳌﺘﺮﺟﻢ ﺑﻀﻢ ﳏﺘﻮﻳـﺎﺕ
ﻣﻠﻔﺎﺕ ﺭﺃﺳﻴﺔ ﺇﱃ ﻣﺸﺮﻭﻋﻨﺎ، ﺣﻴﺚ ﳝﻜﻦ ﺍﺳﺘﻌﻤﻞ ﺩﻭﺍﻝ ﻭ ﺛﻮﺍﺑﺖ ﺗﻠﻚ ﺍﳌﻠﻔﺎﺕ ﺍﻟﺮﺃﺳﻴﺔ ﻣﻨﻬﺎ ﻣﺒﺎﺷﺮﺓ ﺑﺪﻭﻥ ﺇﻋﺎﺩﺓ ﻛﺘﺎﺑﺘﻬﺎ
...
h
ﻭ ﻫﻨﺎ ﻧﻜﺘﺐ ﺍﺳﻢ ﺍﳌﻠﻒ ﺍﻟﺬﻱ ﻧﺮﻳﺪ ﺿﻤﻪ ﺇﱃ ﻣﺸﺮﻭﻋﻨﺎ ﰲ ﻣﻜﺎﻥ
...
h
ﻭ ﺍﻟﻔﺮﻕ ﺍﻟﻮﺣﻴﺪ ﺑﲔ ﺍﻟﻄﺮﻳﻘﺘﲔ ﻫﻮ ﻛﺘﺎﺑﺔ ﺍﻟﺮﻣﺰﻳﻦ >< ﻋﻨﺪﻣﺎ ﻧﺮﻳﺪ ﺇﺿﺎﻓﺔ ﻣﻠﻒ ﺭﺃﺳﻲ ﻣﻦ ﺍﻠـﺪ ﺍﳌﺘـﺮﺟﻢ ) ،(includeﻭ
ﻛﺘﺎﺑﺔ ﺍﻹﻗﺘﺒﺎﺳﲔ " " ﰲ ﺣﺎﻟﺔ ﺃﻥ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ﻣﻮﺟﻮﺩ ﰲ ﻧﻔﺲ ﺍﻠﺪ ﺍﳌﺸﺮﻭﻉ
...
٢,٣,٣ ﺍﻟﺘﻮﺟﻴﻪ :#define
ﻳﺴﺘﻌﻤﻞ ﺍﻟﺘﻮﺟﻴﻪ #defineﰲ ﺍﻹﻋﻼﻥ ﺍﻟﺜﻮﺍﺑﺖ ﻭ ﺍﻟﱵ ﲢﺪﺛﻨﺎ ﻋﻨﻬﺎ ﺳﺎﺑﻘﺎ، ﻭ ﺃﻳـﻀﺎ ﻳـﺴﺘﻌﻤﻞ ﰲ ﺍﻹﻋـﻼﻥ ﻋـﻦ
ﺍﳌﺨﺘﺼﺮﺍﺕ ،Macrosﺑﺎﻟﻨﺴﺒﺔ ﻟﻺﻋﻼﻥ ﻋﻦ ﺍﻟﺜﻮﺍﺑﺖ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﺘﻮﺟﻴﻪ #defineﻓﻬﻲ ﻛﺘﺎﱄ:
#define Constant_Name Constant_Value
681
ﰲ ﻣﻜﺎﻥ Constant_Nameﻧﻘﻮﻡ ﺑﻜﺘﺎﺑﺔ ﺍﺳﻢ ﺍﻟﺜﺎﺑﺖ، ﻭ ﰲ ﻣﻜﺎﻥ Constant_Valueﻧﻜﺘﺐ ﻗﻴﻤﺔ ﺍﻟﺜﺎﺑﺖ
...
3
01
String
Character
fNumber
iNumber
#define
#define
#define
#define
1
2
3
4
ﺃﻣﺎ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﺨﺘﺼﺮﺍﺕ Macrosﻓﻬﻲ ﻣﺸﺎﺑﻪ ﻟﻠﺪﻭﺍﻝ، ﻭ ﻃﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﻠﻬﺎ ﻛﺘﺎﱄ:
#define Macro_Add(i, j) i+j
ﻫﻨﺎ ﻗﻤﻨﺎ ﺑﺈﻧﺸﺎﺀ ﳐﺘﺼﺮ ﺑﻪ ﻭﺳﻴﻄﲔ، )ﻭ ﺃﻳﻀﺎ ﻫﻨﺎ ﻻ ﻧﻘﻮﻡ ﺑﺘﺤﺪﻳﺪ ﻧﻮﻉ ﺗﻠﻚ ﺍﻟﺜﻮﺍﺑﺖ( ﻭ ﻗﻴﻤﺘﻪ ﻫﻲ ﺍﳉﻤﻊ ﺑﲔ ﺍﻟﺜﺎﺑﺖ iﻭ
ﺍﻟﺜﺎﺑﺖ ،jﻣﺜﺎﻝ ﻛﺎﻣﻞ:
>#include
h
#define Constant
5
#define Macro_Add(i, j) i+j
1
2
3
4
781
#undef Constant
#undef Macro_Add
{)(main
:'printf("%d\n", Constant); /*Error: 'Constant
/*undeclared identifier
;)01 ,5(Macro_Add
/*/*Errors
ﺍﻟﱪﻧﺎﻣﺞ ٢,٣,٣: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺘﻮﺟﻴﻪ
}
5
6
7
8
9
01
11
21
31
41
#undef
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﻟﺚ ﻗﻤﻨﺎ ﺑﺎﻹﻋﻼﻥ ﻋﻦ ﺍﻟﺜﺎﺑﺖ Constantﻭ ﺃﻋﻄﻴﻨﺎﻩ ﺍﻟﻘﻴﻤﺔ ٥، ﻭ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺮﺍﺑﻊ ﻗﻤﻨـﺎ ﺑـﺎﻹﻋﻼﻥ ﻋـﻦ
ﺍﳌﺨﺘﺼﺮ ،Macro_Addﰒ ﻗﻤﻨﺎ ﺑﺈﻟﻐﺎﺀ ﻛﻞ ﻣﻦ ﺍﻟﺜﺎﺑﺖ ﻭ ﺍﳌﺨﺘﺼﺮ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺩﺱ ﻭ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ، ﻭ ﻋﻨﺪ ﺍﺳـﺘﻌﻤﺎﻝ
ﺍﻟﺜﺎﺑﺖ Constantﺃﻭ ﺍﳌﺨﺘﺼﺮ Macro_Addﺑﻌﺪ ﺇﻟﻐﺎﺀﳘﺎ ﻓﺴﻴﻨﺒﻬﻚ ﺍﳌﺘﺮﺟﻢ ﻋﻦ ﻭﺟﻮﺩ ﺃﺧﻄﺎﺀ
...
elseﻭ ﺍﻟﺘﻮﺟﻴﻪ #endifﻳﻌﲏ ﺎﻳﺔ ﺍﻟﺸﺮﻭﻁ، ﻣﺜﺎﻝ:
>#include
h
#define dNum
1
2
3
188
4
5
6
7
8
9
10
11
12
13
#ifdef dNum
#define Result "dNum Defined"
#else
#define Result "dNum Undefined"
#endif
main(){
printf("%s\n", Result);
}
ﺍﻟﱪﻧﺎﻣﺞ ٤,٣,٣: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺘﻮﺟﻴﻪ
#ifdef
ﺳﺎﺑﻘﺎ، ﻭ ﳝﻜﻦ ﻛﺘﺎﺑـﺔ ﺍﳌﺜـﺎﻝdNum ، ﻷﻧﻨﺎ ﻗﻤﻨﺎ ﺑﺎﻹﻋﻼﻥ ﻋﻦ ﺍﻟﺜﺎﺑﺖdNum
1
2
3
4
5
6
7
8
9
10
11
12
13
Defined
ﻫﻨﺎ ﺳﺘﻜﻮﻥ ﻧﺘﻴﺠﺔ ﺍﻟﱪﻧﺎﻣﺞ ﻫﻲ
#include
h>
#define dNum
#ifndef dNum
#define Result "dNum Undefined"
#else
#define Result "dNum Defined"
#endif
main(){
printf("%s\n", Result);
}
#ifndef
ﺍﻟﱪﻧﺎﻣﺞ ٦,٣,٣: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺘﻮﺟﻴﻪ
:ﻭ ﳝﻜﻦ ﺃﻳﻀﺎ ﻛﺘﺎﺑﺔ ﻫﺬﺍ ﻣﺜﺎﻝ ﺑﺎﻟﻄﺮﻳﻘﺔ ﺍﻟﺘﺎﱄ
981
>#include
ﺳﺘﻔﻬﻢ ﻃﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﻝ ﻫﺬﺍ ﺍﻟﺘﻮﺟﻴﻪ ﺃﻛﺜﺮ
ﻋﻨﺪﻣﺎ ﺗﻌﺮﻑ ﺍﳌﺨﺘﺼﺮﺍﺕ ﺍﳌﻌﺮﻓﺔ )ﺳﻨﺪﺭﺳﻬﺎ ﻓﻴﻤﺎ ﺑﻌﺪ(
...
٨,٣,٣ ﺍﻟﺘﻮﺟﻴﻪ :#pragma
ﻳﺴﺘﻌﻤﻞ ﺍﻟﺘﻮﺟﻴﻪ #pragmaﻟﺘﺤﻜﻢ ﰲ ﺍﳌﺘﺮﺟﻢ ﺣﺴﺐ ﺭﻏﺒﺔ ﺍﳌﱪﻣﺞ، ﻭ ﻫﻲ ﲣﺘﻠﻒ ﻣﻦ ﻣﺘﺮﺟﻢ ﻵﺧـﺮ، ﻳﺴﺘﺤـﺴﻦ
ﻣﺮﺍﺟﻌﺔ ﺍﳌﺴﺎﻋﺪ ﺍﳋﺎﺹ ﺑﺎﳌﺘﺮﺟﻢ ﺍﻟﺬﻱ ﺗﺴﺘﻌﻤﻠﻪ
...
C
ﺍﳉﺪﻭﻝ ١,٣,٣: ﺍﻷﲰﺎﺀ ﺍﳌﻌﺮﻓﺔ
ﻣﺜﺎﻝ ﺣﻮﻝ ﻃﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﻝ ﺗﻠﻚ ﺍﻷﲰﺎﺀ:
>#include
1
2
3
4
5
6
7
8
9
191
١١,٣,٣ ﲤﺎﺭﻳﻦ:
ﻻ ﺗﻮﺟﺪ ﲤﺎﺭﻳﻦ ﰲ ﻫﺬﺍ ﺍﻟﺪﺭﺱ
...
h
;)int Add(int a, int b
{)(main
;int a = 10, b = 20, c = 30, d
;)d = Add(a, b, c
;)printf("%d\n", d
}
{)int Add(int a, int b
;return a+b
}
ﺍﻟﱪﻧﺎﻣﺞ ١,٤,٣: ﺗﻮﻓﲑ ﺛﻼﺛﺔ ﻭﺳﺎﺋﻂ ﻟﺪﺍﻟﺔ ﺎ ﻭﺳﻴﻄﲔ
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
ﻫﻨﺎ ﺍﻟﱪﻧﺎﻣﺞ ﻟﻦ ﻳﻌﻤﻞ، ﻭ ﺍﳋﻄﺄ ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﻣﻦ ﻭ ﻫﻮ ﺃﻥ ﺍﻟﺪﺍﻟﺔ Addﲢﺘﻮﻱ ﻋﻠﻰ ﻭﺳﺎﺋﻂ ﻓﻘﻂ، ﺃﻣﺎ ﳓﻦ ﻓﻘﺪ ﻣﺮﺭﻧﺎ ﳍـﺎ
ﺛﻼﺛﺔ ﻭﺳﺎﺋﻂ
...
h
>#include
,* void NewPrintf(char
{)(main
;)3 ,2 ,1 ,"NewPrintf("%d\a, %d\a, %d\a\n
;)"NewPrintf("Hello!\n
}
{)
...
hﻭ ﺍﺳﻢ ﺍﳌﻠﻒ ﳐﺘﺼﺮ ﻣﻦ ،standard argumentﻭ ﻫﻮ ﺍﳌﻠﻒ ﺍﻟﺬﻱ ﺳـﻴﻌﻄﻴﻨﺎ
ﺍﻹﻣﻜﺎﻧﻴﺎﺕ ﳉﻌﻞ ﺍﻟﺪﻭﺍﻝ ﳍﺎ ﻭﺳﺎﺋﻂ ﻏﲑ ﳏﺪﺩﺓ
...
ﻓﻬﻲ ﺗﻌﲏ ﺃﻧﻪ ﺳﺘﺘﻢ ﲤﺮﻳﺮ ﻟﺪﺍﻟﺔ ﻋـﺪﺩ
ﻣﻦ ﺍﻟﻮﺳﺎﺋﻂ ﻏﲑ ﳏﺪﺩﺓ
...
hﺣﻴﺚ ﺳﻴﺤﻤﻞ ﻫﺬﺍ ﺍﳌﺆﺷﺮ ﻋﺪﺩ ﻭﺳﺎﺋﻂ ﺍﻟﺪﺍﻟﺔ
...
formatﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺘﺎﺳـﻊ ﻭ
ﺍﻟﻌﺸﺮﻳﻦ ﻗﻤﻨﺎ ﺑﺎﺳﺘﻌﻤﺎﻝ ﺍﳌﺨﺘﺼﺮ ،va_argﻭ ﻫﻮ ﳐﺘﺼﺮ ﻣﻦ ،variable argumentﻭ ﻟﻪ ﻭﺳﻴﻄﲔ، ﺍﻟﻮﺳﻴﻂ ﺍﻷﻭﻝ ﻣﺆﺷﺮ
ﻟـ ،va_listﻭ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ ﻫﻮ ﻧﻮﻉ ﺍﳌﺘﻐﲑ ﺍﻟﺬﻱ ﺳﻴﺘﻢ ﺃﺧﺬ ﻗﻴﻤﺘﻪ ﻣﻦ ﻣﻜﺎﻥ ﺍﻟﻮﺳﻴﻂ ﺍﻹﺿﺎﰲ ﰒ ﻧﻘﻠـﻪ ﺇﱃ ﺍﳌـﺘﻐﲑ
،Decimalﰒ ﻃﺒﻌﻪ ﻣﺒﺎﺷﺮﺓ
...
h
>#include
,int Add(int NumOfArg
{)(main
;int a = 10, b = 20, c = 30, d
;)d = Add(3, a, b, c
;)printf("%d\n", d
}
{)
...
٢,٤,٣ ﲤﺎﺭﻳﻦ:
ﻻ ﺗﻮﺟﺪ ﲤﺎﺭﻳﻦ ﰲ ﻫﺬﺍ ﺍﻟﺪﺭﺱ
...
١,٥,٣ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ :assert
...
h
>#include
hﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﱐ، ﻭ ﺍﺳﺘﻌﻤﻠﻨﺎ ﺍﻟﺪﺍﻟﺔ assertﰲ ﻛﻞ ﻣﻦ ﺍﻟـﺴﻄﺮ ﺍﳋـﺎﻣﺲ ﻭ
ﺍﻟﺴﺎﺩﺱ
...
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺩﺱ ﺃﻋﻄﻴﻨﺎ ﻟﺪﺍﻟﺔ assertﻣﻘﺎﺭﻧﺔ ﺧﺎﻃﺌﺔ، ﻭ ﻫﻨـﺎ ﺳـﻴﺘﻢ
ﺍﻟﺘﺤﻮﻳﻞ ﺇﱃ ﺍﳌﺨﺘﺼﺮﺓ assertﻭ ﺍﻟﺬﻱ ﺳﻴﻘﻮﻡ ﺑﻄﺒﺎﻋﺔ ﺍﳋﻄﺄ ﺃﺛﻨﺎﺀ ﺗﺸﻐﻴﻞ ﺍﻟﱪﻧﺎﻣﺞ، ﻭ ﺍﳋﻄﺄ ﻫﻮ 01<02 ﰲ ﺍﳌﻠﻒ main
...
٢,٥,٣ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ :ctype
...
hﳛﺘﻮﻱ ﻋﻠﻰ ﳎﻤﻮﻋﺔ ﻣﻦ ﺍﻟﺪﻭﺍﻝ ﺍﳋﺎﺹ ﺃﻧﻮﺍﻉ ﺍﻟﺮﻣﻮﺯ، ﻭ ﺍﲰﻪ ﳐﺘﺼﺮ ﻣﻦ
ﲨﻴﻊ ﺩﻭﺍﻟﻪ ﺫﺍﺕ ﻭﺳﻴﻂ ﻭﺍﺣﺪ ﻭ ﻫﻮ ﳌﺘﻐﲑ ﳛﻤﻞ ﺭﻗﻢ ﺍﻟﺮﻣﺰ
...
h
>#include
ﰲ ﺍﻟـﺴﻄﺮ ﺍﻟﺜـﺎﻣﻦ
ﺳﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ١ ﺃﻱ ﺻﺤﻴﺤﺔ، ﻷﻥ ﺍﻟﺮﻗﻢ ٥٦ ﻫﻮ ﺍﳊﺮﻑ Aﰲ ﺟﺪﻭﻝ ،ASCIIﻭ ﻫﻮ ﻣﻦ ﺍﻟﺮﻣﻮﺯ ﺍﳊﺮﻓﻴﺔ
...
h
>#include
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﻣﻦ ﺳﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ١، ﻷﻥ ﺍﻟﻌﺪﺩ ٥٦ ﻫﻮ ﺍﳊﺮﻑ Aﰲ ﺟﺪﻭﻝ ،ASCIIﻭ ﺍﳊﺮﻑ Aﻣﻦ ﺍﳊﺮﻭﻑ ﺍﻷﲜﺪﻳﺔ
...
h
>#include
ASCII
٤,٢,٥,٣ ﺍﻟﺪﺍﻟﺔ :isdigit
ﺗﻘﻮﻡ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﺑﺈﺧﺘﺒﺎﺭ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻌﻄﺎﺀﺓ ﳍﺎ ﺇﺫﺍ ﻛﺎﻧﺖ ﻣﻦ ﺍﻷﺭﻗﺎﻡ ﺍﻟﻌﺸﺮﻳﺔ ﺣﻴﺚ ﺗﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ﻏﲑ ﺍﻟﺼﻔﺮ ﺇﻥ ﻛﺎﻧـﺖ
ﺍﻟﻘﻴﻤﺔ ﺍﳌﻌﻄﺎﺓ ﺑﲔ ﺍﻟﺮﻗﻢ ٨٤ ﻭ ٧٥، ﻭ ﰲ ﺣﺎﻟﺔ ﺃﻥ ﺍﻟﻨﺘﻴﺠﺔ ﱂ ﺗﻜﻦ ﺑﲔ ﺍﻟﺮﻗﻢ ٨٤ ﻭ ٧٥ ﻣﻦ ﺟـﺪﻭﻝ ASCIIﻓـﺴﺘﻜﻮﻥ
ﺍﻟﻨﺘﻴﺠﺔ ٠ ﺃﻱ ﺧﺎﻃﺌﺔ، ﻣﺜﺎﻝ:
>#include
h
{)(main
;84 = 2int c = 65, c
;)printf("%d = %c\n", isdigit(c), c
;)2printf("%d = %c\n", isdigit(c2), c
ﺍﻟﱪﻧﺎﻣﺞ ٥,٥,٣: ﺍﻟﺪﺍﻟﺔ
}
1
2
3
4
5
6
7
8
9
isdigit
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ ﺳﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ٠ ﺃﻱ ﺧﺎﻃﺌﺔ، ﻷﻥ ﺍﻟﺮﻗﻢ ٥٦ ﻫﻮ ﺍﳊﺮﻑ Aﰲ ﺟﺪﻭﻝ ASCIIﻭ ﺍﳊﺮﻑ Aﻟﻴﺲ ﺭﻗﻤﺎ
...
٥,٢,٥,٣ ﺍﻟﺪﺍﻟﺔ :isgraph
ﺗﻘﻮﻡ ﻫﺬﺍ ﺍﻟﺪﺍﻟﺔ ﺑﺈﺧﺘﺒﺎﺭ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻌﻄﺎﺓ ﳍﺎ ﺇﺫﺍ ﻛﺎﻥ ﺭﻣﻮﺯ ﻏﲑ ﻣﺮﺋﻴﺔ ﺃﻭ ﻣﺮﺋﻴﺔ، ﺇﺫﺍ ﻛﺎﻧﺖ ﻏﲑ ﻣﺮﺋﻴﺔ ﻓﺴﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ﻏﲑ
ﺍﻟﺼﻔﺮ ﺃﻱ ﺻﺤﻴﺤﺔ، ﺃﻣﺎ ﰲ ﺣﺎﻟﺔ ﺍﻟﻌﻜﺲ ﻓﺴﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ٠ ﺃﻱ ﺧﺎﻃﺌﺔ، ﻣﺜﺎﻝ:
>#include
h
1
2
3
891
{)(main
;84 = 2int c = 0, c
;)printf("%d = %c\n", isgraph(c), c
;)2printf("%d = %c\n", isgraph(c2), c
ﺍﻟﱪﻧﺎﻣﺞ ٦,٥,٣: ﺍﻟﺪﺍﻟﺔ
}
4
5
6
7
8
9
isgraph
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ ﺳﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ٠ ﺃﻱ ﺧﺎﻃﺌﺔ، ﻷﻥ ﺍﻟﺮﻗﻢ ٠ ﰲ ﺟﺪﻭﻝ ASCIIﻋﺒﺎﺭﺓ ﻋﻦ ﺭﻣﺰ ﻣﺮﺋﻲ
...
٦,٢,٥,٣ ﺍﻟﺪﺍﻟﺔ :islower
ﺗﻘﻮﻡ ﻫﺬﺍ ﺍﻟﺪﺍﻟﺔ ﺑﺈﺧﺘﺒﺎﺭ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻌﻄﺎﺓ ﳍﺎ، ﺇﺫﺍ ﻛﺎﻧﺖ ﻣﻦ ﺍﻷﺣﺮﻑ ﺍﻟﺼﻐﲑﺓ ﻓﺴﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ﻏﲑ ﺍﻟﺼﻔﺮ ﺃﻱ ﺻﺤﻴﺤﺔ،
ﺃﻣﺎ ﺇﺫﺍ ﻛﺎﻧﺖ ﻏﲑ ﺫﻟﻚ ﻓﺴﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ٠، ﻣﺜﺎﻝ:
>#include
h
{)(main
;79 = 2int c = 65, c
;)printf("%d = %c\n", islower(c), c
;)2printf("%d = %c\n", islower(c2), c
ﺍﻟﱪﻧﺎﻣﺞ ٧,٥,٣: ﺍﻟﺪﺍﻟﺔ
}
1
2
3
4
5
6
7
8
9
islower
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ ﺳﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ٠ ﺃﻱ ﺧﺎﻃﺌﺔ، ﻷﻥ ﺍﻟﺮﻗﻢ ٥٦ ﻫﻮ ﺍﻟﺮﻣﺰ Aﰲ ﺟﺪﻭﻝ ،ASCIIﻭ ﺍﻟﺮﻣـﺰ Aﻟـﻴﺲ ﻣـﻦ
ﺍﳊﺮﻭﻑ ﺍﻟﺼﻐﲑﺓ
...
٧,٢,٥,٣ ﺍﻟﺪﺍﻟﺔ :isprint
ﺗﻘﻮﻡ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﺑﺈﺧﺘﺒﺎﺭ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻌﻄﺎﺓ ﳍﺎ، ﺇﺫﺍ ﱂ ﻛﺎﻧﺖ ﺍﻟﻘﻴﻤﺔ ﺑﲔ ٢٣ ﻭ ٦٢١ ﻣﻦ ﺟﺪﻭﻝ ASCIIﻓﺴﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠـﺔ
ﻏﲑ ﺍﻟﺼﻔﺮ، ﻭ ﻫﻲ ﺍﻟﺮﻣﻮﺯ ﺍﳌﺴﺘﻌﻤﻠﺔ ﰲ ﺍﻟﻄﺒﺎﻋﺔ ﺍﻹﻓﺘﺮﺍﺿﻴﺔ )ﺍﻟﻔﺮﺍﻍ ﻳﻌﺘﱪ ﺭﻣﺰ ﺃﻳﻀﺎ(، ﺃﻣﺎ ﺇﺫﺍ ﻛﺎﻧﺖ ﺍﻟﻘـﻴﻢ ﻏـﲑ ﺫﻟـﻚ
ﻓﺴﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ٠ ﺃﻱ ﺧﺎﻃﺌﺔ، ﻣﺜﺎﻝ:
>#include
h
{)(main
;56 = 2int c = 1, c
1
2
3
4
5
991
;)printf("%d = %c\n", isprint(c), c
;)2printf("%d = %c\n", isprint(c2), c
ﺍﻟﱪﻧﺎﻣﺞ ٨,٥,٣: ﺍﻟﺪﺍﻟﺔ
}
6
7
8
9
isprint
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ ﺳﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ٠، ﻷﻥ ﺍﻟﺮﻗﻢ ١ ﰲ ﺟﺪﻭﻝ ASCIIﻋﺒﺎﺭﺓ ﻋﻦ ﺭﺳﻢ ﻹﺑﺘﺴﺎﻣﺔ، ﻭ ﻻ ﺗﺴﺘﻌﻤﻞ ﺍﻹﺑﺘﺴﺎﻣﺎﺕ
ﰲ ﺍﻟﻨﺼﻮﺹ ﺍﻹﻓﺘﺮﺍﺿﻴﺔ
...
٨,٢,٥,٣ ﺍﻟﺪﺍﻟﺔ :ispunct
ﺍﺳﻢ ﺍﻟﺪﺍﻟﺔ ﳐﺘﺼﺮ ﻣﻦ ،is punctuationﻭ ﻫﻲ ﺗﻘﻮﻡ ﺑﺈﺧﺘﺒﺎﺭ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻌﻄﺎﺓ ﳍﺎ، ﺇﺫﺍ ﻛﺎﻧﺖ ﻣﻦ ﺃﺣـﺪ ﺭﻣـﻮﺯ ﺍﻟﺘـﺮﻗﲔ
ﻓﺴﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ﻏﲑ ﺍﻟﺼﻔﺮ ﺃﻱ ﺻﺤﻴﺤﺔ، ﺃﻣﺎ ﻏﲑ ﺭﻣﻮﺯ ﺍﻟﺘﺮﻗﲔ ﻓﺴﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ٠ ﺃﻱ ﺧﺎﻃﺌﺔ، ﻣﺜﺎﻝ:
>#include
h
{)(main
;56 = 2int c = 44, c
;)printf("%d = %c\n", ispunct(c), c
;)2printf("%d = %c\n", ispunct(c2), c
ﺍﻟﱪﻧﺎﻣﺞ ٩,٥,٣: ﺍﻟﺪﺍﻟﺔ
}
1
2
3
4
5
6
7
8
9
ispunct
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ ﺳﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ﻏﲑ ﺍﻟﺼﻔﺮ ﺃﻱ ﺻﺤﻴﺤﺔ، ﻷﻥ ﺍﻟﺮﻗﻢ ٤٤ ﻫﻮ ﺍﻟﻔﺎﺻﻠﺔ ﰲ ﺟﺪﻭﻝ ،ASCIIﺍﻟﻔﺎﺻـﻠﺔ ﻣـﻦ
ﺭﻣﻮﺯ ﺍﻟﺘﺮﻗﲔ
...
٩,٢,٥,٣ ﺍﻟﺪﺍﻟﺔ :isspace
ﺗﻘﻮﻡ ﺍﻟﺪﺍﻟﺔ ﺑﺈﺧﺘﺒﺎﺭ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻌﻄﺎﺓ ﳍﺎ، ﺇﺫﺍ ﻛﺎﻧﺖ ﻣﻦ ﺭﻣﻮﺯ ﺍﻟﻔﻀﺎﺀ ﺍﻷﺑﻴﺾ ﺃﻣﺎ ﻻ، ﻭ ﺭﻣﻮﺯ ﺍﻟﻔﻀﺎﺀ ﺍﻷﺑﻴﺾ ﺗﺒﺪﺃ ﻣﻦ ٩
ﺇﱃ ٣١، ﻭ ﰲ ﻫﺬﻩ ﺍﳊﺎﻟﺔ ﺳﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ﻏﲑ ﺍﻟﺼﻔﺮ ﺃﻱ ﺻﺤﻴﺢ، ﺃﻣﺎ ﺇﻥ ﱂ ﺗﻜﻮﻥ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻌﻄﺎﺓ ﻣﻦ ﺃﺣﺪ ﺍﻟﺮﻣﻮﺯ ﺍﻟﻔﻀﺎﺀ
ﺍﻷﺑﻴﺾ ﻓﺈﻥ ﺍﻟﻨﺘﻴﺠﺔ ﺳﺘﻜﻮﻥ ٠ ﺃﻱ ﺧﺎﻃﺌﺔ، ﻣﺜﺎﻝ:
>#include
h
{)(main
;79 = 2int c = 9, c
1
2
3
4
5
002
;)printf("%d = %c\n", isspace(c), c
;)2printf("%d = %c\n", isspace(c2), c
ﺍﻟﱪﻧﺎﻣﺞ ٠١,٥,٣:
}
ﺍﻟﺪﺍﻟﺔ isspace
6
7
8
9
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ ﺳﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ﻏﲑ ﺍﻟﺼﻔﺮ ﺃﻱ ﺻﺤﻴﺤﺔ، ﻷﻥ ﺍﻟﺮﻗﻢ ٩ ﰲ ﺟﺪﻭﻝ ASCIIﻫﻮ ﻣﻦ ﺃﺣﺪ ﺭﻣـﻮﺯ ﺍﻟﻔـﻀﺎﺀ
ﺍﻷﺑﻴﺾ
...
٠١,٢,٥,٣ ﺍﻟﺪﺍﻟﺔ :isupper
ﺗﻘﻮﻡ ﻫﺬﺍ ﺍﻟﺪﺍﻟﺔ ﺑﺈﺧﺘﺒﺎﺭ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻌﻄﺎﺓ ﳍﺎ، ﺇﺫﺍ ﻛﺎﻧﺖ ﻣﻦ ﺍﻟﺮﻣﻮﺯ ﺍﻟﻜﺒﲑﺓ ﻓﺴﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ﻏﲑ ﺍﻟﺼﻔﺮ ﺃﻱ ﺻﺤﻴﺤﺔ، ﺃﻣﺎ
ﺇﺫﺍ ﻛﺎﻧﺖ ﻗﻴﻢ ﻷﺣﺮﻑ ﺻﻐﲑﺓ ﻓﺴﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ٠ ﺃﻱ ﺧﺎﻃﺌﺔ، ﻣﺜﺎﻝ:
>#include
h
{)(main
;79 = 2int c = 65, c
;)printf("%d = %c\n", isupper(c), c
;)2printf("%d = %c\n", isupper(c2), c
ﺍﻟﱪﻧﺎﻣﺞ ١١,٥,٣: ﺍﻟﺪﺍﻟﺔ
}
1
2
3
4
5
6
7
8
9
isupper
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ ﺳﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ﻏﲑ ﺍﻟﺼﻔﺮ ﺃﻱ ﺻﺤﻴﺤﺔ، ﻷﻥ ﺍﻟﺮﻗﻢ ٥٦ ﰲ ﺟﺪﻭﻝ ASCIIﻫﻮ ﺍﳊﺮﻑ Aﻭ ﻫـﻮ ﻣـﻦ
ﺍﻷﺣﺮﻑ ﺍﻟﻜﺒﲑﺓ
...
١١,٢,٥,٣ ﺍﻟﺪﺍﻟﺔ :isxdigit
ﺍﺳﻢ ﻫﺬﺍ ﺍﻟﺪﺍﻟﺔ ﳐﺘﺼﺮ ﻣﻦ ،is hexadecimal digitalﻭ ﺗﻘﻮﻡ ﻫﺬﺍ ﺍﻟﺪﺍﻟﺔ ﺑﺈﺧﺘﺒﺎﺭ ﺍﻟﺪﺍﻟﺔ ﺍﳌﻌﻄﺎﺓ ﳍﺎ، ﺇﺫﺍ ﻛﺎﻧﺖ ﺍﻟﻘﻴﻤﺔ ﻣﻦ
ﺃﻋﺪﺍﺩ ﺍﻟﻨﻈﺎﻡ ﺍﻟﺴﺪﺍﺳﻲ ﻋﺸﺮ ﺃﻱ ﻣﻦ A-Fﻭ ﻣﻦ ٠ – ٩ ﻓﺴﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ﻏﲑ ﺍﻟﺼﻔﺮ ﺃﻱ ﺻﺤﻴﺤﺔ، ﺃﻣﺎ ﺇﺫﺍ ﻛﺎﻧﺖ ﻏﲑ ﺗﻠﻚ
ﺍﻟﻘﻴﻢ ﻓﺴﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ٠ ﺃﻱ ﺧﺎﻃﺌﺔ، ﻣﺜﺎﻝ:
>#include
h
{)(main
;17 = 2int c = 70, c
1
2
3
4
5
102
;)printf("%d = %c\n", isxdigit(c), c
;)2printf("%d = %c\n", isxdigit(c2), c
ﺍﻟﱪﻧﺎﻣﺞ ٢١,٥,٣: ﺍﻟﺪﺍﻟﺔ
}
6
7
8
9
isxdigit
ﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ ﺳﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ﻏﲑ ﺍﻟﺼﻔﺮ ﺃﻱ ﺻﺤﻴﺤﺔ، ﻷﻥ ﺍﻟﺮﻗﻢ ٠٧ ﻫﻮ ﺍﳊﺮﻑ Fﰲ ﺟﺪﻭﻝ ،ASCIIﻭ ﺍﳊـﺮﻑ
ﻣﻦ ﺍﻟﻨﻈﺎﻡ ﺍﻟﺴﺪﺍﺳﻲ ﻋﺸﺮ ﻭ ﰲ ﺍﻟﻨﻈﺎﻡ ﺍﻟﻌﺸﺮﻱ ﻫﻮ ﺍﻟﻌﺪﺩ ٥١
...
F
٢١,٢,٥,٣ ﺍﻟﺪﺍﻟﺘﲔ toupperﻭ :tolower
ﺍﻟﺪﺍﻟﺔ toupperﺗﻘﻮﻡ ﺑﺘﺤﻮﻳﻞ ﺍﻷﺣﺮﻑ ﺍﻟﺼﻐﲑ ﺇﱃ ﺍﻷﺣﺮﻑ ﺍﻟﻜﺒﲑﺓ، ﻭ ﺍﻟﺪﺍﻟﺔ tolowerﺗﻘﻮﻡ ﺑﺘﺤﻮﻳـﻞ ﺍﻷﺣـﺮﻑ
ﺍﻟﻜﺒﲑﺓ ﺇﱃ ﺃﺣﺮﻑ ﺻﻐﲑﺓ ﺃﻱ ﻋﻜﺲ ﻣﺎ ﺗﻘﻮﻡ ﺑﻪ ﺍﻟﺪﺍﻟﺔ ،toupperﻣﺜﺎﻝ:
>#include
h
{)(main
;'int c = 'a', c2 = 'B
;))printf("%c = %c\n", c, toupper(c
;))2printf("%c = %c\n", c2, tolower(c
ﺍﻟﱪﻧﺎﻣﺞ ٣١,٥,٣: ﺍﻟﺪﺍﻟﺘﲔ toupperﻭ
}
1
2
3
4
5
6
7
8
9
tolower
ﰲ ﻫﺬﺍ ﺍﻟﱪﻧﺎﻣﺞ ﻳﺘﻢ ﻃﺒﺎﻋﺔ ﺍﳊﺮﻑ aﻭ ﻫﻮ ﻋﻠﻰ ﺷﻜﻞ ﺣﺮﻑ ﺻﻐﲑ، ﰒ ﺇﻋﺎﺩﺓ ﻛﺘﺎﺑﺘﻪ ﺑﻌﺪ ﲤﺮﻳﺮﻩ ﻟﺪﺍﻟﺔ toupperﺣﻴـﺚ
ﺳﻴﺼﺒﺢ ﻣﻦ ﺍﻷﺣﺮﻑ ﺍﻟﻜﺒﲑﺓ، ﻭ ﺳﺘﺘﻢ ﻃﺒﺎﻋﺔ ﺍﳊﺮﻑ Bﻋﻠﻰ ﺷﻜﻞ ﺣﺮﻑ ﻛﺒﲑ، ﰒ ﺇﻋﺎﺩﺓ ﻛﺘﺎﺑﺘﻪ ﺑﻌـﺪ ﲤﺮﻳـﺮﻩ ﻟﺪﺍﻟـﺔ
tolowerﺣﻴﺚ ﲢﻮﻳﻠﻪ ﺇﱃ ﺣﺮﻑ ﺻﻐﲑ
...
h
ﻳﻮﺟﺪ ﰲ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ errno
...
ﺣﻴﺚ ﺗﺴﺘﻌﻤﻞ ﺗﻠﻚ ﺍﳌﺨﺘﺼﺮﺍﺕ ﻣﻊ ﺍﻟﺪﺍﻟﺔ
...
ﻟﺪﺍﻟﺔ ﻭﺳﻴﻂ ﻭﺍﺣﺪ ﻭ ﻫﻮ
ﺳﻠﺴﻠﺔ ﳊﺮﻭﻑ ﺍﻟﱵ ﺳﺘﺘﻢ ﻃﺒﺎﻋﺘﻬﺎ ﻗﺒﻞ ﻃﺒﺎﻋﺔ ﺍﳋﻄﺄ، ﺃﻭ ﳝﻜﻦ ﺗﺮﻙ ﺍﻟﺴﻠﺴﻠﺔ ﻓﺮﺍﻏﻪ ﺇﻥ ﱂ ﻧﺮﻳﺪ ﺇﺿﺎﻓﺔ ﺷـﻲﺀ ﺇﱃ ﺭﺳـﺎﻟﺔ
ﺍﳋﻄﺄ، ﻣﺜﺎﻝ ﺣﻮﻝ ﻃﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ:
>#include
h
>#include
No errorﺍﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ perrorﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺴﺎﺑﻊ ﻋﺸﺮ، ﻓﺈﻥ
ﻛﺎﻥ ﺍﺳﻢ ﺍﳌﻠﻒ ﺍﻟﺬﻱ ﻃﻠﺒﻪ ﺍﳌﺴﺘﺨﺪﻡ ﻏﲑ ﻣﻮﺟﻮﺩ ﻓﺴﻴﺘﻢ ﻃﺒﺎﻋﺔ ﺍﻟﺮﺳﺎﻟﺔ ﻋﺪﻡ ﻭﺟﻮﺩ ﺍﳌﻠﻒ، ﻭ ﺃﻳـﻀﺎ ﻗﻤﻨـﺎ ﺑﺎﺳـﺘﻌﻤﺎﻝ
ﺍﳌﺨﺘﺼﺮ errnoﰲ ﺍﻟﺴﻄﺮ ﺍﻟﺜﺎﻣﻦ ﻋﺸﺮ ﻋﱪ ﺍﻟﺪﺍﻟﺔ ،printfﺣﻴﺚ ﺳﺘﻢ ﻃﺒﺎﻋﺔ ﺭﻗﻢ ﺭﺳﺎﻟﺔ ﺍﳋﻄﺄ ﺍﻟﺬﻱ ﰎ ﺇﳚﺎﺩﻩ، ﺭﺳـﺎﻟﺔ
ﺍﳋﻄﺄ ﻫﻨﺎ ﺭﻗﻤﻬﺎ ٢
...
h>
#include
h ﻭ ﻛﻞ ﺭﻗﻢ ﻣﻨﻬﺎ ﻟﻪ ﺛﺎﺑﺖ ﻣﻌﺮﻑ ﰲ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ
EPERM
ENOENT
ESRCH
EINTR
EIO
ENXIO
E2BIG
ENOEXEC
EBADF
ECHILD
EAGAIN
ENOMEM
EACCES
EFAULT
EBUSY
EEXIST
EXDEV
ENODEV
ENOTDIR
EISDIR
EINVAL
ENFILE
1
2
3
4
5
6
7
8
9
10
11
12
13
14
16
17
18
19
20
21
22
23
204
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
EMFILE
ENOTTY
EFBIG
ENOSPC
ESPIPE
EROFS
EMLINK
EPIPE
EDOM
ERANGE
EDEADLK
ENAMETOOLONG
ENOLCK
ENOSYS
ENOTEMPTY
EILSEQ
24
25
27
28
29
30
31
32
33
34
36
38
39
40
41
42
errno
...
h ٤,٥,٣ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ
:ﺬﺍ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ﳎﻤﻮﻋﺔ ﻣﻦ ﺍﻟﺜﺎﺑﺖ ﺧﺎﺻﺔ ﺑﺎﻷﻋﺪﺍﺩ ﺍﳊﻘﻴﻘﻴﺔ، ﻭ ﺗﻠﻚ ﺍﻟﺜﻮﺍﺑﺖ ﻫﻲ ﻳﻮﺟﺪ
ﻗﻴﻤﺘﻪ
ﺍﺳﻢ ﺍﻟﺜﺎﺑﺖ
2
1
1E+37
128
E
1 +37
1024
6
15
1E-5
1E-9
24
53
1E-37
-125
1E-37
-1021
float
...
h ﺗﻌﺘﱪ ﻫﺬﺍ ﺍﻟﺜﻮﺍﺑﺖ ﻣﻦ ﺃﻫﻢ ﺍﻟﺜﻮﺍﺑﺖ ﺍﳌﻮﺟﻮﺩ ﰲ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ
...
h ﺍﻟﺮﺃﺳﻲ
:limits
...
h
ﻭ ﺗﻮﺟﺪ ﺛﻮﺍﺑﺖ ﺃﺧﺮﻯ ﳝﻜﻦ ﺭﺃﻳﺘﻬﺎ ﰲ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ
...
h
٦,٥,٣ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ :locale
...
h
ﻻ ﻳﻌﺘﱪ ﻫﺬﺍ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ﻣﻬﻢ، ﻫﻮ ﺧﺎﺹ ﺑﺘﺤﺪﻳﺪ ﺍﳌﻨﻄﻘﺔ ﺃﻭ ﺍﻟﺒﻼﺩ ﺍﻟﱵ ﺗﺮﻳﺪ ﺍﺳﺘﻌﻤﺎﻝ ﺃﺻﻨﺎﻓﻬﺎ ﰲ ﺑﺮﻧﺎﳎﻚ، ﻣﻨﻬﺎ ﺍﻟﻠﻐﺔ
...
hﻟﺮﺅﻳﺔ ﺑﺎﻗﻲ ﳏﺘﻮﻳﺎﺗﻪ
...
h
ﳛﻤﻞ ﻫﺬﺍ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ﳎﻤﻮﻋﺔ ﻣﻦ ﺍﻟﺜﻮﺍﺑﺖ ﻭ ﺍﳌﺨﺘﺼﺮﺍﺕ ﻭ ﺍﻟﺪﻭﺍﻝ ﺍﳋﺎﺹ ﺑﺎﻟﺮﻳﺎﺿﻴﺎﺕ
...
71828182845904523536
1
...
434294481903251827651
0
...
30258509299404568402
3
...
57079632679489661923
0
...
318309886183790671538
0
...
12837916709551257390
1
...
707106781186547524401
math
...
math
...
h>
#include
14/2;
printf("sine x = %f\n", sin(x));
}
sin
ﺍﻟﱪﻧﺎﻣﺞ ٩١,٥,٣: ﺍﻟﺪﺍﻟﺔ
:cos ٢,٧,٥,٣ ﺍﻟﺪﺍﻟﺔ
، ﻭ ﻫﻲ ﺗﻘﻮﻡ ﺑﺈﺭﺟﺎﻉ ﺟﻴﺐ ﺍﻟﺘﻤﺎﻡ ﻟﻠﻘﻴﻤـﺔdouble ، ﻭ ﳍﺎ ﻭﺳﻴﻂ ﻭﺍﺣﺪ ﻣﻦ ﻧﻮﻉcosine ﳐﺘﺼﺮ ﻣﻦcos ﺍﺳﻢ ﺍﻟﺪﺍﻟﺔ
:ﺍﻟﱵ ﰎ ﲤﺮﻳﺮﻫﺎ ﺇﻟﻴﻬﺎ، ﻣﺜﺎﻝ
1
2
3
4
5
6
7
8
#include
h>
main(){
double x = 3
...
h
>#include
3 = double x
;))printf("tangent x = %f\n", tan(x
ﺍﻟﱪﻧﺎﻣﺞ ١٢,٥,٣: ﺍﻟﺪﺍﻟﺔ
}
1
2
3
4
5
6
7
8
tan
٤,٧,٥,٣ ﺍﻟﺪﺍﻟﺔ :exp
ﺍﺳﻢ ﺍﻟﺪﺍﻟﺔ expﳐﺘﺼﺮ ﻣﻦ ،exponentialﻭ ﳍﺎ ﻭﺳﻴﻂ ﻭﺍﺣﺪ ﻣﻦ ﻧﻮﻉ ،doubleﺣﻴﺚ ﺗﻜﻮﻥ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻌﻄﺎﺓ ﻟﻪ ﻫـﻲ
ﺃ ،e ﻣﺜﺎﻝ:
ﺱ
>#include
h
{)(main
;0
...
h
>#include
001 = double x
;))printf("logarithm x = %f\n", log(x
ﺍﻟﱪﻧﺎﻣﺞ ٣٢,٥,٣: ﺍﻟﺪﺍﻟﺔ
log
}
1
2
3
4
5
6
7
8
802
٥,٧,٥,٣ ﺍﻟﺪﺍﻟﺔ :pow
ﺍﺳﻢ ﺍﻟﺪﺍﻟﺔ powﳐﺘﺼﺮ ﻣﻦ ،powerﻭ ﺎ ﻭﺳﻴﻄﲔ، ﺍﻟﻮﺳﻴﻂ ﺍﻷﻭﻝ ﻫﻮ ﻣﺘﻐﲑ ﻣﻦ ﻧﻮﻉ ،doubleﻭ ﺍﻟﺜﺎﱐ ﺃﻳﻀﺎ ﻣـﺘﻐﲑ
ﻣﻦ ﻧﻮﻉ ،doubleﺣﻴﺚ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ ﻳﻜﻮﻥ ﻋﺪﺩ ﺃ ﻗﻴﻤﺔ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ، ﻣﺜﺎﻝ:
ﺱ
>#include
h
{)(main
;0
...
0, y
;))printf("%f\n", pow(x, y
٦,٧,٥,٣ ﺍﻟﺪﺍﻟﺔ :sqrt
ﺍﻟﱪﻧﺎﻣﺞ ٤٢,٥,٣: ﺍﻟﺪﺍﻟﺔ
}
1
2
3
4
5
6
7
8
pow
ﺍﺳﻢ ﺍﻟﺪﺍﻟﺔ sqrtﳐﺘﺼﺮ ﻣﻦ ،squareﻭ ﳍﺎ ﻭﺳﻴﻂ ﻭﺍﺣﺪ ﳌﺘﻐﲑ ﻣﻦ ﻧﻮﻉ ،doubleﻭ ﻫﻲ ﺗﻘﻮﻡ ﺑﺈﺭﺟﺎﻉ ﺍﳉﺬﺭ ﺍﻟﺘﺮﺑﻴﻌﻲ
ﻟﻠﻘﻴﻤﺔ ﺍﳌﻌﻄﺎﺓ ﻟﻪ، ﻣﺜﺎﻝ:
>#include
h
{)(main
;0
...
h
>#include
9=double x
;))printf("%f\n", ceil(x
ﺍﻟﱪﻧﺎﻣﺞ ٦٢,٥,٣: ﺍﻟﺪﺍﻟﺔ
ceil
}
1
2
3
4
5
6
7
8
902
٨,٧,٥,٣ ﺍﻟﺪﺍﻟﺔ :floor
ﺍﻟﺪﺍﻟﺔ floorﻫﻲ ﻣﻌﺎﻛﺲ ﻟﺪﺍﻟﺔ ،ceilﻓﺈﺫﺍ ﻛﺎﻧﺖ ﺍﻟﻘﻴﻤﺔ ﺍﳌﻌﻄﺎﺓ ﳍﺎ ١,٣ ﻓﺴﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ٠,٣، ﻣﺜﺎﻝ:
>#include
h
{)(main
;5
...
h
>#include
01=double x=-10
...
h
>#include
4=double x=2
...
23 = printf("%f\n", ldexp(x, y)); /*y = 2*2*2*2, x = 2; x*y
ﺍﻟﱪﻧﺎﻣﺞ ٩٢,٥,٣: ﺍﻟﺪﺍﻟﺔ
١١,٧,٥,٣ ﺍﻟﺪﺍﻟﺔ :fmod
ldexp
}
1
2
3
4
5
6
7
8
012
ﳍﺬﻩ ﺍﻟﺪﺍﻟﺔ ﻭﺳﻴﻄﲔ، ﻛﻼﳘﺎ ﻣﺘﻐﲑﺍﻥ ﻣﻦ ﻧﻮﻉ ،doubleﺣﻴﺚ ﺗﻘﻮﻡ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﺑﻘﺴﻤﺔ ﻗﻴﻤﺔ ﺍﻟﻮﺳﻴﻂ ﺍﻷﻭﻝ ﻋﻠﻰ ﻗﻴﻤﺔ
ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ، ﻣﺜﺎﻝ:
>#include
h
{)(main
;0
...
0, y
;))printf("%f\n", fmod(x, y
ﺍﻟﱪﻧﺎﻣﺞ ٠٣,٥,٣: ﺍﻟﺪﺍﻟﺔ
}
1
2
3
4
5
6
7
8
fmod
٨,٥,٣ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ :setjmp
...
intﺗﺴﺘﻌﻤﻞ ﺍﻟﺪﺍﻟﺔ setjmpﻣﻊ ﺍﻟﺪﺍﻟﺔ ،longjmpﻭ ﺍﳍﺪﻑ ﻣﻨﻬﻤﺎ ﻫﻮ ﺍﻟﻘﻔﺰ
ﺇﱃ ﳐﺘﻠﻒ ﺃﻣﺎﻛﻦ ﺍﻟﱪﻧﺎﻣﺞ، ﻓﻤﺜﻼ ﻧﺴﺘﻌﻤﻞ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ gotoﻟﻠﻘﻔﺰ ﻣﻦ ﻣﻜﺎﻥ ﻵﺧﺮ ﰲ ﺩﺍﻟـﺔ ﻣﻌﻨﻴـﺔ، ﻭ ﻻ ﳝﻜـﻦ
ﺍﺳﺘﻌﻤﺎﳍﺎ ﻟﻠﻘﻔﺰ ﺍﻟﻌﺎﻡ ) ،(Globalﻣﺜﺎﻝ:
>#include
h
>#include
\n
;)(Return
{
}
}
{)void Return(void
1
2
3
4
5
6
7
8
9
01
11
21
31
41
51
61
71
81
91
02
12
22
32
42
52
62
72
112
;)1 ,longjmp(jmp
ﺍﻟﱪﻧﺎﻣﺞ ١٣,٥,٣: ﺍﻟﺪﺍﻟﺔ ،setjmpﻭ ﺍﻟﺒﻨﻴﺔ
}
82
92
jmp_buf
٩,٥,٣ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ :signal
...
raise
١,٩,٥,٣ ﺍﻟﺪﺍﻟﺔ :raise
ﲢﺘﻮﻱ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﻋﻠﻰ ﻭﺳﻴﻂ ﻣﻦ ﻧﻮﻉ ،intﻭ ﻋﻤﻠﻬﺎ ﻫﻮ ﺇﺎﺀ ﺍﻟﱪﻧﺎﻣﺞ ﰲ ﺣﺎﻻﺕ ﻣﺜﻞ ﺣﺪﻭﺙ ﺇﻧﺘﻬﺎﻙ ﰲ ﺫﺍﻛـﺮﺓ
ﺍﳊﺎﺳﻮﺏ، ﻭ ﺗﻮﺟﺪ ﺛﻮﺍﺑﺖ ﺧﺎﺻﺔ ﺎ ﰲ ﻧﻔﺲ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ، ﻭ ﻛﻞ ﺛﺎﺑﺖ ﻭ ﺣﺎﻟﺘﻪ، ﻭ ﻫﺬﺍ ﺟﺪﻭﻝ ﻷﻫﻢ ﺍﻟﺜﻮﺍﺑـﺖ ﺍﻟـﱵ
ﺗﺴﺘﻌﻤﻞ ﻣﻊ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ:
ﺍﺳﻢ ﺍﻟﺜﺎﺑﺖ
ﻗﻴﻤﺘﻪ
ﺍﻟﺸﺮﺡ
SIGABRT
٢٢
ﰲ ﺣﺎﻟﺔ ﺍﻹﻧﺘﻬﺎﺀ ﺍﻟﻐﲑ ﺍﻟﻄﺒﻴﻌﻲ ﻟﻠﱪﻧﺎﻣﺞ، ﻳﺴﺘﺪﻋﻲ ﺍﻟﺪﺍﻟﺔ
SIGFPE
٨
ﰲ ﺣﺎﻟﺔ ﺧﻄﺄ ﺭﻳﺎﺿﻲ
SIGILL
٤
ﰲ ﺣﺎﻟﺔ ﺣﺪﻭﺙ ﺃﻣﺮ ﻏﲑ ﺷﺮﻋﻲ
SIGINT
٢
ﺍﳌﻘﺎﻃﻌﺔ
SIGSEGV
١١
ﰲ ﺣﺎﻟﺔ ﺣﺪﻭﺙ ﺇﻧﺘﻬﺎﻙ ﻟﺬﺍﻛﺮﺓ
SIGTERM
٥١
ﺇﺎﺀ ﺍﻟﱪﻧﺎﻣﺞ
ﺍﳉﺪﻭﻝ ١,٥,٣: ﺃﻫﻢ ﺍﻟﺜﻮﺍﺑﺖ ﺍﻟﱵ ﺗﺴﺘﻌﻤﻞ ﻣﻊ ﺍﻟﺪﺍﻟﺔ
abort
raise
٠١,٥,٣ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ :stdarg
...
ﳛﺘـﻮﻱ
ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ stdarg
...
ﻭ ﺑﻌﺪ
ﺫﻟﻚ ﻧﺴﺘﻌﻤﻞ ﺍﳌﺨﺘﺼﺮ ،va_argﻭ ﺍﻟﺬﻱ ﳛﺘﻮﻱ ﻋﻠﻰ ﻭﺳﻴﻄﲔ، ﺍﻟﻮﺳﻴﻂ ﺍﻷﻭﻝ ﻫﻮ ﻣﺆﺷﺮ ﻟـ val_listﺍﻟﺬﻱ ﺳـﻴﺘﻢ
ﺍﺳﺘﻌﻤﺎﻟﻪ ﰲ ﺍﻟﺪﺍﻟﺔ، ﻭ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ ﻧﻀﻊ ﻓﻴﻪ ﻧﻮﻉ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺬﻱ ﺳﻴﺘﻢ ﺃﺧﺬﻩ، ﻭ ﰲ ﺍﻟﻨﻬﺎﻳﺔ ﻧﻘﻮﻡ ﺑﺈﺎﺀ ﺗـﺸﻐﻴﻞ ﺍﳌﺆﺷـﺮ
va_listﻭ ﺫﻟﻚ ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﳌﺨﺘﺼﺮ ،va_endﻣﺜﺎﻝ:
>#include
h>
void Arg_List(int list,
...
){
va_list pList;
int iArg=0, i;
printf("There are %d argument(s)\n", list);
va_start(pList, list); /*initialize the pList pointer*/
for(i=01;i<=list;i++){
iArg = va_arg(pList, int);
printf("argument %d = %d\n", i, iArg);
}
va_end(pList);
}
va_list
، ﻭ ﺍﳌﺆﺷﺮva_end ﻭ ﺍﻟﺪﺍﻟﺔva_arg ، ﺍﻟﺪﺍﻟﺔva_start ﺍﻟﱪﻧﺎﻣﺞ ٢٣,٥,٣: ﺍﻟﺪﺍﻟﺔ
ﻭ ﻫﻮ ﻣﻌﺮﻑ ﻋﻠﻰ ﺍﻟﺸﻜﻞNULL ، ﻭ ﻫﻮ ﳛﺘﻮﻱ ﻋﻠﻰ ﺍﻟﺜﺎﺑﺖStandard
#define NULL
:stddef
...
h>
#include
h
>#include
h
ﻳﻌﱪ ﻣﻦ ﺃﻫﻢ ﺍﳌﻠﻔﺎﺕ ﺍﻟﺮﺃﺳﻴﺔ ﺍﻟﻘﻴﺎﺳﻴﺔ، ﻭ ﺍﲰﻪ ﳐﺘﺼﺮ ﻣﻦ ،Standard Input Outputﺣﻴﺚ ﳛﺘﻮﻱ ﻋﻠﻰ ﺃﻫﻢ ﺍﻟﺪﻭﺍﻝ ﻭ
ﺍﳌﺨﺘﺼﺮﺍﺕ ﺍﻟﱵ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﳍﺎ ﰲ ﺃﻏﻠﺐ ﺍﻟﱪﺍﻣﺞ، ﻭ ﺩﺭﺍﺳﺔ ﲨﻴﻊ ﺗﻠﻚ ﺍﻟﺪﻭﺍﻝ ﻭ ﺍﳌﺨﺘﺼﺮﺍﺕ ﺑﺄﻣﺜﻞ ﻳﺄﺧﺬ ﺍﻟﻜـﺜﲑ ﻣـﻦ
ﺍﻟﺼﻔﺤﺎﺕ ﻟﺬﺍ ﻧﻜﺘﻔﻲ ﲟﻌﺮﻓﺔ ﺃﲰﺎﺀ ﺗﻠﻚ ﺍﻟﺪﻭﺍﻝ ﻭ ﺍﳌﺨﺘﺼﺮﺍﺕ ﻭ ﺍﳍﺪﻑ ﻣﻨﻬﺎ
...
١,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ :printf
ﲢﺘﻮﻱ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﻋﻠﻰ ﻭﺳﺎﺋﻂ ﻏﲑ ﳏﺪﺩﺓ، ﺗﺘﺰﺍﻳﺪ ﺣﺴﺐ ﺭﻏﺒﺔ ﺍﳌﱪﻣﺞ، ﻭ ﻫﻲ ﺗﻘﻮﻡ ﺑﺎﻟﺘﻌﺎﻣﻞ ﻣﻊ ﻛﻞ ﻣﻦ ﺍﻷﺣـﺮﻑ ﻭ
ﺍﻷﺭﻗﺎﻡ ﻭ ﺍﻟﻨﺼﻮﺹ، ﻣﺜﺎﻝ:
>#include
h>
main(){
char Buffer[255];
sprintf(Buffer, "Number = %d\nCharacter = %c\nString = %s\n",
100, 'A', "Hello, World!");
}
printf(Buffer);
sprintf
ﺍﻟﱪﻧﺎﻣﺞ ٦٣,٥,٣: ﺍﻟﺪﺍﻟﺔ
:vprintf ٣,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ
:، ﻣﺜﺎﻝva_list ﻭ ﻟﻜﻨﻬﺎ ﺗﺄﺧﺬ ﺍﻟﻮﺳﺎﺋﻂ ﻋﻠﻰ ﺷﻜﻞprintf ﻣﺜﻞ ﺍﻟﺪﺍﻟﺔ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include
h>
void ArgLst(char *format,
...
){
va_list Lst;
va_start(Lst, format);
vprintf(format, Lst);
va_end(Lst);
}
215
vprintf
ﺍﻟﱪﻧﺎﻣﺞ ٧٣,٥,٣: ﺍﻟﺪﺍﻟﺔ
:vfprintf ٤,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ
: ﻓﻘﻂ ﻫﻲ ﺧﺎﺻﺔ ﺑﺎﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﳌﻠﻔﺎﺕ، ﻣﺜﺎﻝvprintf ﻫﻲ ﻣﻄﺎﺑﻘﺔ ﻟﺪﺍﻟﺔ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include
h>
void ArgLst(char *format,
...
){
va_list Lst;
FILE *File;
File = fopen("Info
...
h>
#include
);
main(){
int Number = 100;
char Char = 'A';
char String[] = "Hello, World!";
char buffer[255];
ArgLst(buffer, "Number = %d\nChar = %c\nStrin = %s\n",\
Number, Char, String);
}
printf(buffer);
216
17
18
19
20
21
22
23
24
void ArgLst(char *buffer, char *format,
...
h>
main(){
char string[255];
}
printf("Your name, Please: ");
scanf("%s", string);
printf("Nice to meet you %s!\n", string);
scanf
ﺍﻟﱪﻧﺎﻣﺞ ٠٤,٥,٣: ﺍﻟﺪﺍﻟﺔ
:fscanf ٧,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ
:ﺗﻘﻮﻡ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﺑﺄﺧﺬ ﺭﻣﻮﺯ ﻣﻦ ﻣﻠﻒ ﻧﺼﻲ ﺇﻣﺎ ﻋﻠﻰ ﺷﻜﻞ ﺃﺭﻗﺎﻡ ﺃﻭ ﺃﺣﺮﻑ ﺃﻭ ﺳﻠﺴﻠﺔ ﻧﺼﻮﺹ، ﻣﺜﺎﻝ
1
2
3
4
5
6
7
8
9
10
11
12
#include
txt", "r");
fscanf(File, "%s", buffer);
printf("%s\n", buffer);
}
fscanf
ﺍﻟﱪﻧﺎﻣﺞ ١٤,٥,٣: ﺍﻟﺪﺍﻟﺔ
:sscanf ٨,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ
:ﺗﻘﻮﻡ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﺑﻨﺸﺮ ﺳﻠﺴﻠﺔ ﺣﺮﻭﻑ ﻋﻠﻰ ﳎﻤﻮﻋﺔ ﻣﻦ ﺍﳌﺘﻐﲑﺍﺕ ﺑﺸﻜﻞ ﻣﻨﻔﺼﻞ، ﻣﺜﺎﻝ
1
2
3
4
#include
h>
main(){
FILE *File;
char ch;
File = fopen("Info
...
h>
main(){
FILE *File;
char buffer[255];
File = fopen("Info
...
h>
main(){
FILE *File;
File = fopen("Info
...
h>
main(){
FILE *File;
File = fopen("Info
...
h>
main(){
FILE *File;
char ch;
File = fopen("Info
...
h>
main(){
char ch;
printf("Enter a character: ");
ch = getchar();
printf("Your character is: %c\n", ch);
}
getchar
ﺍﻟﱪﻧﺎﻣﺞ ٨٤,٥,٣: ﺍﻟﺪﺍﻟﺔ
:gets ٥١,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ
:ﺗﻘﻮﻡ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﺍﻹﺩﺧﺎﻝ ﺃﻳﻀﺎ، ﻭ ﻫﻲ ﺗﺴﺘﻘﺒﻞ ﺳﻠﺴﻠﺔ ﺣﺮﻓﻴﺔ ﻣﻦ ﺍﳌﺴﺘﺨﺪﻡ، ﻣﺜﺎﻝ
1
2
3
4
5
6
7
8
9
#include
h>
main(){
FILE *File;
File = fopen("Info
...
h>
main(){
char ch = 'A';
printf("ch = ");
putchar(ch);
putchar('\n');
}
putchar
ﺍﻟﱪﻧﺎﻣﺞ ١٥,٥,٣: ﺍﻟﺪﺍﻟﺔ
:puts ٨١,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ
ﺗﻘﻮﻡ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﺑﻄﺒﺎﻋﺔ ﺳﻠﺴﻠﺔ ﺣﺮﻓﻴﺔ ﻋﻠﻰ ﺷﺎﺷﺔ ﺍﳊﺎﺳﻮﺏ،ﺣﻴﺚ ﻳﺘﻢ ﺍﻟﺮﺟﻮﻉ ﺇﱃ ﺳﻄﺮ ﺟﺪﻳـﺪ ﰲ ﻛـﻞ ﺳﻠـﺴﻠﺔ
:ﺣﺮﻓﻴﺔ، ﻣﺜﺎﻝ
1
2
3
4
5
6
7
8
9
#include
h>
main(){
FILE *File;
File = fopen("Info
...
h>
main(){
FILE *File;
File = fopen("FileName
...
Ext", "w");
if(File!=NULL)
printf("File Created!\n");
if(File==NULL)
printf("File does not exist!\n");
else
printf("File exist now!\n");
}
fclose(File);
fopen
ﺍﻟﱪﻧﺎﻣﺞ ٤٥,٥,٣: ﺍﻟﺪﺍﻟﺔ
:freopen ١٢,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ
ﺃﻭstdout ،stdin ﻭ ﺍﻟﺬﻱ ﻳﻜﻮﻥ ﺇﻣـﺎFILE ﻣﻊ ﻭﺳﻴﻂ ﺇﺿﺎﰲ ﳌﺆﺷﺮ ﺑﻴﻨﺔfopen ﺗﺴﺘﻌﻤﻞ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﻣﺜﻞ ﺍﻟﺪﺍﻟﺔ
:، ﻣﺜﺎﻝstderr
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include
txt", "w", stderr);
if(!File)
fprintf(stdout, "Error!\n");
else
fprintf(File, "String!");
fclose(File);
}
freopen
ﺍﻟﱪﻧﺎﻣﺞ ٥٥,٥,٣: ﺍﻟﺪﺍﻟﺔ
222
ﻭ ﻫﻲ ﺗﻘﻮﻡ ﺑﻐﻠﻖ ﲨﻴـﻊ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
:fclose ٢٢,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ
_fcloseall
ﺗﻘﻮﻡ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﺑﻐﻠﻖ ﻣﻠﻒ ﺣﻴﺚ ﳝﻜﻦ ﺍﺳﺘﻌﻤﺎﻟﻪ ﻣﺮﺓ ﺃﺧﺮﻯ، ﻭ ﺗﻮﺟﺪ ﺍﻟﺪﺍﻟﺔ
:ﺍﳌﻠﻔﺎﺕ ﺍﻟﻐﲑ ﻣﻐﻠﻖ ﻭ ﺗﺮﺟﻊ ﻗﻴﻤﺔ ﻟﻌﺪﺩ ﺍﳌﻠﻔﺎﺕ ﺍﻟﱵ ﰎ ﺇﻏﻼﻗﻬﺎ، ﻣﺜﺎﻝ
#include
txt", "w");
File2 = fopen("Info2
...
txt", "w");
fclose(File1);
printf("%d file(s) closed by _fcloseall()\n",\
_fcloseall());
}
fclose
ﺍﻟﱪﻧﺎﻣﺞ ٦٥,٥,٣: ﺍﻟﺪﺍﻟﺔ
:remove ٣٢,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ
:ﺗﻘﻮﻡ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﲝﺬﻑ ﺍﳌﻠﻔﺎﺕ، ﻣﺜﺎﻝ
1
2
3
4
5
6
7
8
9
10
11
12
#include
tmp*/
File = fopen("temporary
...
tmp*/
remove("temporary
...
h>
main(){
printf("Rename Info
...
dat
...
txt", "Data
...
\n");
322
٥٢,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ :tmpfile
ﺗﻘﻮﻡ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﺑﺈﻧﺸﺎﺀ ﻣﻠﻒ ﻣﺆﻗﺖ
ﺍﻟﱪﻧﺎﻣﺞ ﺃﻭ ﺎﻳﺔ ﺍﻟﱪﻧﺎﻣﺞ، ﻣﺜﺎﻝ:
}
ﺍﻟﱪﻧﺎﻣﺞ ٨٥,٥,٣: ﺍﻟﺪﺍﻟﺔ
file
7
rename
temporaryﻟﻠﱪﻧﺎﻣﺞ، ﺣﻴﺚ ﻳﺘﻢ ﺣﺬﻑ ﺍﳌﻠﻒ ﺍﳌﺆﻗﺖ ﻋﻨـﺪ ﺍﳋـﺮﻭﺝ ﻣـﻦ
>#include
\n
;)(File = tmpfile
;)"printf("Temporary File Created
...
\n
ﺍﻟﱪﻧﺎﻣﺞ ٩٥,٥,٣: ﺍﻟﺪﺍﻟﺔ
}
1
2
3
4
5
6
7
8
9
01
11
21
tmpfile
٦٢,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ :fread
ﺗﻘﻮﻡ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﺑﻘﺮﺍﺀﺓ ﳏﺘﻮﻯ ﻣﻠﻒ ﻭ ﻭﺿﻊ ﻧﺴﺨﺔ ﳍﺎ ﰲ ﺳﻠﺴﻠﺔ ﺣﺮﻓﻴﺔ، ﻭ ﲢﺘﻮﻱ ﻋﻠﻰ ﺃﺭﺑﻌﺔ ﻭﺳﺎﺋﻂ، ﺍﻟﻮﺳﻴﻂ ﺍﻷﻭﻝ
ﻫﻮ ﻟﺴﻠﺴﻠﺔ ﺍﳊﺮﻓﻴﺔ ﺍﻟﱵ ﺳﻴﺘﻢ ﻭﺿﻊ ﻓﻴﻬﺎ ﻧﺴﺨﺔ ﻣﻦ ﻧﺺ ﺍﳌﻠﻒ، ﻭ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ ﻫﻮ ﺣﺠﻢ ﺍﶈﺘﻮﻯ ﺍﻟﻮﺍﺣﺪ ﺑﺎﻟﺒﺎﻳﺘـﺎﺕ، ﻭ
ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﻟﺚ ﻫﻮ ﻋﺪﺩ ﺍﻷﺣﺮﻑ ﺍﻟﱵ ﻧﺮﻳﺪ ﻧﺴﺨﻬﺎ، ﻭ ﺍﻟﻮﺳﻴﻂ ﺍﻷﺧﲑ ﻭ ﻣﺆﺷﺮ ﻟﻠﺒﻨﻴﺔ ،FILEﻣﺜﺎﻝ:
>#include
txt", "r
;)fread(buffer, sizeof(char), 255, File
;)printf("%s\n", buffer
ﺍﻟﱪﻧﺎﻣﺞ ٠٦,٥,٣: ﺍﻟﺪﺍﻟﺔ
}
1
2
3
4
5
6
7
8
9
01
11
fread
٧٢,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ :fwrite
ﺗﻘﻮﻡ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﺑﺎﻟﻜﺘﺎﺑﺔ ﻋﻠﻰ ﺍﳌﻠﻔﺎﺕ، ﻭ ﻫﻲ ﺍﻟﺪﺍﻟﺔ ﺍﳌﻌﺎﻛﺴﺔ ﻟﺪﺍﻟﺔ ،freadﻭ ﳍﺎ ﻧﻔﺲ ﻭﺳﺎﺋﻂ ﺍﻟﺪﺍﻟﺔ ،freadﻣﺜﺎﻝ:
>#include
txt", "w");
}
fwrite(buffer, sizeof(char), 7, File);
fclose(File);
fwrite
ﺍﻟﱪﻧﺎﻣﺞ ١٦,٥,٣: ﺍﻟﺪﺍﻟﺔ
:fseek ٨٢,٢١,٥,٣ ﺍﻟﺪﺍﻟﺔ
ﺗﻘﻮﻡ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﺑﺎﻟﺘﺤﻜﻢ ﰲ ﻣﻜﺎﻥ ﻣﺆﺷﺮ ﳌﻠﻒ ﻧﺼﻲ، ﺣﻴﺚ ﲢﺘﻮﻱ ﻋﻠﻰ ﺛﻼﺛﺔ ﻭﺳﺎﺋﻂ، ﺍﻟﻮﺳﻴﻂ ﺍﻷﻭﻝ ﻫـﻮ ﻣﺆﺷـﺮ
ﻭ ﻫﻮ ﻋﺪﺩ ﺍﻟﺒﺎﻳﺘﺎﺕlong ﻭ ﻫﻮ ﺍﳌﻠﻒ ﺍﻟﺬﻱ ﺳﻴﺘﻢ ﲢﺪﻳﺪ ﻣﻜﺎﻥ ﻣﺆﺷﺮﻩ، ﻭ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ ﻫﻮ ﻣﺘﻐﲑ ﻣﻦ ﻧﻮﻉFILE ﻟﻠﺒﻨﻴﺔ
،ﻣﻦ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﻟﺚ، ﻣﺜﻼ ﺇﺫﺍ ﺃﻋﻄﻴﻨﺎﻩ ﺍﻟﻘﻴﻤﺔ ٥ ﻓﺴﻴﺘﻢ ﲡﺎﻫﻞ ﲬﺴﺔ ﺑﺎﻳﺘﺎﺕ ﺑﻌﺪ ﺍﳌﺆﺷﺮ ﺍﻟﺬﻱ ﰎ ﲢﺪﻳﺪﻩ ﰲ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﻟﺚ
، ﻭ ﻣﻦ ﻫﺬﺍ ﺍﻟﻮﺳﻴﻂ ﻧﻘﻮﻡ ﺑﺘﺤﺪﻳﺪ ﺍﳌﺆﺷﺮ ﻟﻨﺺ، ﻭ ﻟﻪ ﺛﻮﺍﺑﺖ ﻭ ﻫـﻲint ﻭ ﺃﺧﲑﺍ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﻟﺚ، ﻭ ﻫﻮ ﻣﺘﻐﲑ ﻣﻦ ﻧﻮﻉ
:، ﻣﺜﺎﻝSEEK_END ﻭSEEK_SET ﻭSEEK_CUR
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include
txt", "r");
/*Beginning of file*/
fseek(File, 0L, SEEK_SET);
printf("SEEK_SET Begin:\n");
while(feof(File)==0){
ch_set = fgetc(File);
printf("%c", ch_set);
}
printf("\nSEEK_SET End
...
\n");
/*End of file*/
fseek(File, 0L, SEEK_END);
printf("SEEK_END Begin:\n");
225
33
34
35
36
37
38
while(feof(File)==0){
ch_end = fgetc(File);
printf("%c", ch_end);
}
printf("\nSEEK_END End
...
h>
main(){
FILE *File;
int Position;
char buff[3];
File = fopen("Info
...
h>
main(){
FILE *File;
char ch;
File = fopen("Info
...
h
{)(main
;FILE *File
;)"File = fopen("Info
...
h
ﺍﻟﱪﻧﺎﻣﺞ ٥٦,٥,٣: ﺍﻟﺪﺍﻟﺔ
}
1
2
3
4
5
6
7
8
9
01
11
21
31
feof
ﺍﻻﺳﻢ stdlibﳐﺘﺼﺮ ﻣﻦ ،Standard Libraryﺣﻴﺚ ﳛﺘﻮﻱ ﻫﺬﺍ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ﻋﻠﻰ ﳎﻤﻮﻋﺔ ﻣﻦ ﺍﻟﺪﻭﺍﻝ ﰲ ﻛـﻞ ﻣـﻦ
ﺩﻭﺍﻝ ﲢﻮﻳﻞ ﺍﻷﺭﻗﺎﻡ، ﺩﻭﺍﻝ ﲣﺼﻴﺺ ﺍﻟﺬﺍﻛﺮﺓ )ﺍﻟﺘﺨﺰﻳﻦ( ﻭ ﺩﻭﺍﻝ ﺃﺧﺮﻯ
...
h
>#include
h
>#include
h
>#include
h
>#include
٥,٣١,٥,٣ ﺍﻟﺪﺍﻟﺔ :srand
ﺗﻘﻮﻡ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﺑﺘﺸﻐﻴﻞ ﻣﻮﻟﺪ ﺍﻷﺭﻗﺎﻡ ﺍﻟﻌﺸﻮﺍﺋﻴﺔ ،randﺣﻴﺚ ﳚﻌﻞ ﺗﻠﻚ ﺍﻟﻘﻴﻢ ﺍﻟﻌﺸﻮﺍﺋﻴﺔ ﻣﺘﻐﲑ ﻣﻦ ﳊﻈـﺔ ﻷﺧـﺮﻯ
ﻋﻨﺪﻣﺎ ﳕﺮﺭ ﻟﻪ ﺍﻟﺪﺍﻟﺔ ،timeﻣﺜﺎﻝ:
>#include
h
>#include
h
>#include
txt", "r
;)"printf("Can't open file\n
;)(abort
1
2
3
4
5
6
7
8
9
922
}
;)fclose(File
}
ﺍﻟﱪﻧﺎﻣﺞ ١٧,٥,٣: ﺍﻟﺪﺍﻟﺔ
01
11
21
31
abort
٧,٣١,٥,٣ ﺍﻟﺪﺍﻟﺔ :exit
ﺗﻘﻮﻡ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﺑﺎﻹﺎﺀ ﺍﻟﱪﻧﺎﻣﺞ ﺇﺫﺍ ﰎ ﺍﻟﺘﻤﺮﻳﺮ ﺇﻟﻴﻬﺎ ﺍﻟﻘﻴﻤﺔ ١، ﺣﻴﺚ ﻳﻮﺟﺪ ﺛﻮﺍﺑﺖ ﺑﺎﺳـﻢ EXIT_FAILUREﻭ ﻫـﻮ
ﻧﻔﺴﻪ ﺍﻟﻘﻴﻤﺔ ١، ﻭ ﺍﻟﺜﺎﺑﺖ EXIT_SUCCESSﻭ ﻫﻮ ﺍﻟﻘﻴﻤﺔ ٠ ﻭ ﺍﻟﺬﻱ ﻳﻌﲏ ﺍﳋﺮﻭﺝ ﺍﻟﺴﻠﻴﻢ ﻟﻠﱪﻧﺎﻣﺞ، ﻣﺜﺎﻝ:
>#include
h
{)(main
;FILE *File
{)))"if(!(File=fopen("FileName
...
h
>#include
h>
#include
h>
#include
h>
#include
h>
#include
h
>#include
h
ﰲ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ string
...
memoryﺳﻨﺪﺭﺱ ﺃﻫﻢ ﺩﻭﺍﻝ ﻫﺬﺍ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ، ﻭ ﺍﻟﱵ ﺃﻏﻠﺒﻬﺎ ﺗﺒـﺪﺃ
ﺑـ
...
ﻭ ﺍﻟﺪﺍﻟﺔ ﺍﻟﺜﺎﻧﻴﺔ strncpyﺎ ﺛﻼﺛـﺔ
ﻭﺳﺎﺋﻂ، ﺍﻟﻮﺳﻴﻂ ﺍﻷﻭﻝ ﻭ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ ﳘﺎ ﻧﻔﺲ ﺍﻟﻮﺳﻴﻂ ﺍﻷﻭﻝ ﻭ ﺍﻟﺜﺎﱐ ﻟﺪﺍﻟﺔ ،strcpyﺃﻣﺎ ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﻟﺚ ﻓﻬﻮ ﻋـﺪﺩ
ﺍﻷﺣﺮﻑ ﺍﻟﱵ ﻧﺮﻳﺪ ﻧﺴﺨﻬﺎ، ﻣﺜﺎﻝ:
>#include
h
{)(main
;"char str[] = "Hello
;]5[char empty
;]5[2char empty
;)strcpy(empty, str
;)3 ,strncpy(empty2, str
1
2
3
4
5
6
7
8
9
01
11
232
12
13
14
}
printf("empty = %s\n", empty);
printf("empty2 = %s\n", empty2);
strncpy
ﻭ ﺍﻟﺪﺍﻟﺔstrcpy ﺍﻟﱪﻧﺎﻣﺞ ٩٧,٥,٣: ﺍﻟﺪﺍﻟﺔ
:ﺎ ﻧﺺ ﺳﺎﺑﻘﺎ، ﻓﺴﻴﺘﻢ ﺣﺬﻓﻪ، ﻣﺜﺎﻝ empty ﺃﻣﺎ ﺇﺫﺍ ﻛﺎﻧﺖ ﺍﻟﺴﻠﺴﻠﺔ
1
2
3
4
5
6
7
8
9
10
11
#include
h>
main(){
char str[] = "Hello";
char empty[5] = "empty";
strcpy(empty, str);
}
printf("empty
= %s\n", empty);
(٢) strcpy ﺍﻟﱪﻧﺎﻣﺞ ٠٨,٥,٣: ﺍﻟﺪﺍﻟﺔ
:strncat ﻭ ﺍﻟﺪﺍﻟﺔstrcat ٢,٤١,٥,٣ ﺍﻟﺪﺍﻟﺔ
ﺗﻘﻮﻡ ﺑﻨﺴﺦ ﻧﺺ ﻭ ﺇﺿﺎﻓﺘﻪ ﺇﱃstrncat ﺑﻨﺴﺦ ﻧﺺ ﻭ ﺇﺿﺎﻓﺘﻪ ﺇﱃ ﺳﻠﺴﻠﺔ ﺣﺮﻓﻴﺔ، ﻭ ﺃﻳﻀﺎ ﺍﻟﺪﺍﻟﺔstrcat ﺗﻘﻮﻡ ﺍﻟﺪﺍﻟﺔ
:strcat ﺳﻠﺴﻠﺔ ﺣﺮﻓﻴﺔ ﻣﻊ ﲢﺪﻳﺪ ﻋﺪﺩ ﺍﻷﺣﺮﻑ ﺍﻟﱵ ﻧﺮﻳﺪ ﺇﺿﺎﻓﺘﻬﺎ، ﻣﺜﺎﻝ ﻟﻄﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ
1
2
3
4
5
6
7
8
9
10
#include
h>
main(){
char str[] = "Hello";
printf("str = %s\n", str);
strcat(str, ", World");
printf("str = %s\n", str);
}
strcat
ﺍﻟﱪﻧﺎﻣﺞ ١٨,٥,٣: ﺍﻟﺪﺍﻟﺔ
:strncat ﻭ ﻫﺬﺍ ﻣﺜﺎﻝ ﻟﻄﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ
1
2
3
4
5
6
7
8
9
10
#include
h>
main(){
char str[] = "Hello";
}
printf("str = %s\n", str);
strncat(str, ", World", 3);
printf("str = %s\n", str);
strncat
ﺍﻟﱪﻧﺎﻣﺞ ٢٨,٥,٣: ﺍﻟﺪﺍﻟﺔ
332
٣,٤١,٥,٣ ﺍﻟﺪﺍﻟﺔ strcmpﻭ ﺍﻟﺪﺍﻟﺔ :strncmp
ﺗﻘﻮﻡ ﺍﻟﺪﺍﻟﺔ strcmpﺑﺎﳌﻘﺎﺭﻧﺔ ﺑﲔ ﺳﻠﺴﻠﺘﲔ، ﺇﺫﺍ ﻛﺎﻧﺖ ﺍﻟﺴﻠﺴﻠﺔ ﺍﳊﺮﻓﻴﺔ ﺍﻷﻭﱃ ﻫﻲ ﺍﻷﻛﱪ ﻓﺴﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ﺃﻛﱪ ﻣـﻦ
٠، ﻭ ﰲ ﺣﺎﻟﺔ ﺃﻥ ﺍﻟﺴﻠﺴﻠﺔ ﺍﳊﺮﻓﻴﺔ ﺍﻟﺜﺎﻧﻴﺔ ﻫﻲ ﺍﻷﻛﱪ ﻓﺴﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ﺃﺻﻐﺮ ﻣﻦ ٠، ﻭ ﺃﻳـﻀﺎ ﺍﻟﺪﺍﻟـﺔ strncmpﺗﻘـﻮﻡ
ﺑﺎﳌﻘﺎﺭﻧﺔ ﺑﲔ ﺳﻠﺴﻠﺘﲔ ﻣﻊ ﲢﺪﻳﺪ ﻋﺪﺩ ﺣﺮﻭﻑ ﺍﻟﺴﻠﺴﻠﺔ ﺍﳊﺮﻓﻴﺔ ﺍﻷﻭﱃ ﺍﻟﱵ ﻧﺮﻳﺪ ﻣﻘﺎﺭﻧﺘﻬﺎ ﻣﻊ ﺍﻟﺴﻠﺴﻠﺔ ﺍﳊﺮﻓﻴﺔ ﺍﻟﺜﺎﻧﻴﺔ، ﻣﺜﺎﻝ
ﺣﻮﻝ ﻃﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ :strcmp
>#include
h
{)(main
;"char str1[] = "Hello
;"2char str2[] = "Hello
;)2int cmp = strcmp(str1, str
)0>if(cmp
;)"printf("str1 > str2\n
else
;)"printf("str1 < str2\n
ﺍﻟﱪﻧﺎﻣﺞ ٣٨,٥,٣: ﺍﻟﺪﺍﻟﺔ
}
1
2
3
4
5
6
7
8
9
01
11
21
31
strcmp
ﻭ ﻫﺬﺍ ﻣﺜﺎﻝ ﻟﻄﺮﻳﻘﺔ ﺍﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ :strncmp
>#include
h
{)(main
;"char str1[] = "Hello
;"2char str2[] = "Hello
;)3 ,2int cmp = strncmp(str1, str
)0>if(cmp
;)"printf("str1 > str2\n
else
;)"printf("str1 < str2\n
ﺍﻟﱪﻧﺎﻣﺞ ٤٨,٥,٣: ﺍﻟﺪﺍﻟﺔ
}
1
2
3
4
5
6
7
8
9
01
11
21
31
strncmp
٤,٤١,٥,٣ ﺍﻟﺪﺍﻟﺔ strchrﻭ ﺍﻟﺪﺍﻟﺔ :strrchr
ﺗﺴﺘﻌﻤﻞ ﺍﻟﺪﺍﻟﺔ strchrﻟﻠﺒﺤﺚ ﻋﻦ ﻣﻜﺎﻥ ﺣﺮﻑ ﰲ ﺳﻠﺴﻠﺔ ﺣﺮﻓﻴﺔ، ﻭ ﺇﺫﺍ ﻛﺎﻥ ﺍﳊﺮﻑ ﺍﻟﺬﻱ ﻧﺮﻳﺪ ﺍﻟﺒﺤﺚ ﻋﻨـﻪ ﰲ
ﺍﻟﺴﻠﺴﻠﺔ ﺍﳊﺮﻓﻴﺔ ﻣﻮﺟﻮﺩ ﻣﺮﺗﲔ ﻓﺴﻴﺘﻢ ﺃﺧﺬ ﻣﻜﺎﻥ ﺃﻭﻝ ﺣﺮﻑ، ﻭ ﺍﻟﺪﺍﻟﺔ strrchrﻣﺜﻞ ﺍﻟﺪﺍﻟﺔ strchrﻭ ﻟﻜﻨـﻬﺎ ﺗﺄﺧـﺬ
ﺍﳊﺮﻑ ﺍﻷﺧﲑ ﺑﺪﻝ ﺍﻷﻭﻝ، ﻣﺜﺎﻝ:
>#include
h>
main(){
char str[] = "Hello", *strdest;
char ch = 'l';
int result;
printf("%s\n", str);
printf("12345\n");
strdest = strchr(str, ch);
result = (int)(strdest-str+1);
printf("First '%c' in position %d\n", ch, result);
strdest = strrchr(str, ch);
result = (int)(strdest-str+1);
printf("Last '%c' in position %d\n", ch, result);
}
strrchr
ﻭ ﺍﻟﺪﺍﻟﺔstrchr ﺍﻟﱪﻧﺎﻣﺞ ٥٨,٥,٣: ﺍﻟﺪﺍﻟﺔ
:strcspn ﻭ ﺍﻟﺪﺍﻟﺔstrspn ٥,٤١,٥,٣ ﺍﻟﺪﺍﻟﺔ
ﳝﻜﻦ ﻣﻌﺮﻓﺔ ﻋﺪﺩ ﳎﻤﻮﻋﺔ ﻣﻦ ﺍﻷﺣﺮﻑ ﰲ ﺳﻠﺴﻠﺔ ﺣﺮﻓﻴﺔ، ﺣﻴﺚ ﳚـﺐ ﺃﻥ ﺗﻜـﻮﻥ ﺗﻠـﻚstrspn ﺑﺎﺳﺘﺨﺪﺍﻡ ﺍﻟﺪﺍﻟﺔ
ﻓﻬﻲ ﺗﻘﻮﻡ ﺑﺘﺤﺪﻳﺪ ﻣﻜﺎﻥ ﳎﻤﻮﻋﺔ ﻣﻦstrcspn ﺍﻷﺣﺮﻑ ﻫﻲ ﺑﺪﺍﻳﺔ ﺍﻟﺴﻠﺴﻠﺔ ﺍﳊﺮﻓﻴﺔ ﻭ ﺇﻻ ﺳﺘﻜﻮﻥ ﺍﻟﻨﺘﻴﺠﺔ ٠، ﺃﻣﺎ ﺍﻟﺪﺍﻟﺔ
:ﺍﳊﺮﻭﻑ ﰲ ﺳﻠﺴﻠﺔ ﺣﺮﻓﻴﺔ، ﻣﺜﺎﻝ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include
h>
main(){
char str1[] = "HHHeeelllooo";
char str2[] = "He";
char str3[] = "lllooo";
int result;
result = strspn(str1, str2);
printf("There are %d character(s) of '%s' in string '%s'\n",\
result, str2, str1);
}
result = strcspn(str1, str3);
printf("First '%s' in string '%s' is start at character %d\n",\
str3, str1, result);
strcspn
ﻭ ﺍﻟﺪﺍﻟﺔstrspn ﺍﻟﱪﻧﺎﻣﺞ ٦٨,٥,٣: ﺍﻟﺪﺍﻟﺔ
...
h>
#include
h>
#include
h>
#include
h>
#include
h>
main(){
char str[10];
printf("Enter a string (Max 10 characters): ");
if((strlen(gets(str)))>10){
printf("%s\n", strerror(12));
exit(1);
}else
printf("'%s' = %d character(s)\n",\
str, strlen(str));
}
strerror
ﺍﻟﱪﻧﺎﻣﺞ ٠٩,٥,٣: ﺍﻟﺪﺍﻟﺔ
...
h>
#include
h ٥١,٥,٣ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ
ﻋﻠﻰ ﳎﻤﻮﻋﺔ ﻣﻦ ﺍﻟﺪﻭﺍﻝ ﺍﳋﺎﺻﺔ ﲟﻌﺎﳉﺔ ﺍﻟﺘﺎﺭﻳﺦ ﻭ ﺍﻟﻮﻗﺖ، ﻭ ﳛﺘﻮﻱ ﻫﺬﺍ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲtime
...
time
...
h
>#include
ﻭ ﺑﺎﺳﺘﺨﺪﺍﻡ ﻫﺬﻩ ﺍﻟﺪﺍﻟﺔ ﳝﻜﻦ ﻋﻤﻞ ﺩﺍﻟﺔ ﺗﺄﺧﺮ ﺗﺴﺎﻋﺪﻧﺎ ﻛﺜﲑﺍ ﰲ ﺑﺮﺍﳎﻨﺎ، ﺍﻟﺪﺍﻟﺔ ﺳﺘﻜﻮﻥ ﻛﺘﺎﱄ:
>#include
h
1
2
238
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void delay(int second);
main(){
int waitsec;
printf("wait(in seconds): ");
scanf("%d", &waitsec);
delay(waitsec);
printf("Time terminated
...
h>
#include
\n", Seconds);
printf("%ld\tminutes since 01/01/1970
...
\n", Hours);
printf("%ld\t\tdays since 01/01/1970
...
h>
#include
\n", Seconds);
printf("%ld\tminutes since 01/01/1970
...
\n", Hours);
printf("%ld\t\tdays since 01/01/1970
...
h>
#include
0f seconds to terminate
...
h>
#include
4d/%
...
2d\n",Year, Month, Day);
printf("Time: %
...
2d:%
...
h>
#include
h>
#include
ﺳﻨﺠﺪ ﺃﻥ ﺍﻟﻔﺮﻕ ﺑﲔ ﻃﺮﻳﻖ ﻭ ﺃﺧﺮﻯ ﻟﻴﺲ ﺑﻜﺒﲑ، ﻓﻤﺜﻼ ﺭﲟﺎ ﻧﺬﻫﺐ ﻋﻠﻰ
ﻃﺮﻳﻖ ﳒﺪﻩ ﺳﻬﻞ، ﺃﻭ ﻃﺮﻳﻖ ﳒﺪﻩ ﺻﻌﺐ، ﺃﻭ ﻃﺮﻳﻖ ﺳﺮﻳﻊ ﺃﻭ ﺑﻄﻲﺀ، ﺃﻭ
...
§ ﺳﺘﺠﺪ ﺣﺠﻢ ﺑﺮﻧﺎﻣﺞ ﻣﻜﺘﻮﺏ ﺑﻠﻐﺔ ﺍﻟﺘﺠﻤﻴﻊ ﺃﺻﻐﲑ ﻣﻦ ﺣﺠﻢ ﺑﺮﻧﺎﻣﺞ ﻣﻜﺘﻮﺏ ﺑﻠﻐﺔ ++
...
ﺧﻠﻴﻞ ﺃﻭﻧﻴﺲ
ﺟﺪﻭﻝ ﺍﻷﺷﻜﺎﻝ )ﺍﻟﺼﻮﺭ(
ﺍﻟﻔﺼﻞ ﺍﻷﻭﻝ – ﺃﺳﺎﺳﻴﺎﺕ ﰲ ﻟﻐﺔ
...
ﺍﻟﺸﻜﻞ ١,١,١: ﻣﺮﺣﻠﺔ ﺇﻧﺸﺎﺀ ﻣﻠﻒ ﺗﻨﻔﻴﺬﻱ
...
C
ﺍﻟﺸﻜﻞ ١,٢,١: ٢٦
...
Variables and Constants
ﺍﻟﺸﻜﻞ ١,٣,١: ﺍﻟﺬﺍﻛﺮﺓ ﻭ ﺍﻟﻌﻨﺎﻭﻳﻦ ﰲ ﺍﻟﻨﻤﻂ ﺍﳊﻘﻴﻘﻲ ٣٤
...
٥٣
ﺍﻟﺸﻜﻞ ٣,٣,١: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺛﺎﺑﺖ
...
Comments
٥,١ ﺍﻹﺩﺧﺎﻝ
...
Operators
ﺍﻟﺸﻜﻞ ١,٦,١: ﺍﻹﺯﺍﺣﺔ ﺇﱃ ﺍﻟﻴﺴﺎﺭ
...
٦٥
ﺍﻟﺸﻜﻞ ٣,٦,١: ﺇﺳﺘﻌﻤﺎﻝ ﺍﳌﺆﺛﺮ ﺃﻭ | ٥٧
...
AND
ﺍﻟﺸﻜﻞ ٥,٦,١: ﺇﺳﺘﻌﻤﺎﻝ ﺍﳌﺆﺛﺮ ^ ٥٨
...
if, else, else…if
ﺍﻟﺸﻜﻞ ١,٧,١: ﻃﺮﻳﻘﺔ ﺇﻋﻼﻥ ﺷﺮﻁ ﺫﺍﺕ ﺃﻣﺮ ﻭﺍﺣﺪ
...
٠٦
ﺍﻟﺸﻜﻞ ٣,٧,١: ﻃﺮﻳﻘﺔ ﻋﻤﻞ ifﻭ ٦٢
...
C
٩,١ ﻣﻠﺨﺺ ﻟﻠﻔﺼﻞ ﺍﻷﻭﻝ، ﻣﻊ ﺇﺿﺎﻓﺎﺕ
...
printf
ﺍﻟﺸﻜﻞ ٢,٩,١: ﻃﺮﻳﻘﺔ ﻋﻤﻞ ﺍﻟﺪﺍﻟﺔ ٦٩
...
(٢) C
١,٢ ﺍﻟﻘﺮﺍﺭ
...
Repeated loop
ﺍﻟﺸﻜﻞ ١,٢,٢: ﺍﻟﺘﻜﺮﺍﺭ ﺑﻮﺍﺳﻄﺔ ٨٦
...
do…while
ﺍﻟﺸﻜﻞ ٣,٢,٢: ﺍﻟﺘﻜﺮﺍﺭ ﺑﻮﺍﺳﻄﺔ ٩١
...
goto
ﺍﻟﺸﻜﻞ ٥,٢,٢: ﺇﻧﺸﺎﺀ ﺇﺳﻢ ﳌﻜﺎﻥ ﳝﻜﻦ ﺍﻟﺬﻫﺎﺏ ﺇﻟﻴﻪ ﻋﱪ ٩٢
...
while
ﺍﻟﺸﻜﻞ ٧,٢,٢: ﺷﺮﺡ ﻟﻌﻤﻠﻴﺔ ﺍﻟﺘﻜﺮﺍﺭ ﰲ ٩٥
...
for
ﺍﻟﺸﻜﻞ ٩,٢,٢: forﺑﻄﺮﻳﻘﺔ ﺃﺧﺮﻯ
...
Arrays
ﺍﻟﺸﻜﻞ ١,٣,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺼﻔﻮﻓﺔ
...
٨٠١
٤,٢ ﺍﳌﺆﺷﺮﺍﺕ
...
٤١١
ﺍﻟﺸﻜﻞ ٢,٤,٢: ﺍﻟﺬﺍﻛﺮﺓ ﻭ ﺍﻟﻌﻨﺎﻭﻳﻦ
...
Functions
ﺍﻟﺸﻜﻞ ١,٥,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺩﺍﻟﺔ
...
Header files
٧,٢ ﺍﻹﺩﺧﺎﻝ ﻭ ﺍﻹﺧﺮﺍﺝ ﰲ ﺍﳌﻠﻔﺎﺕ
...
١٤١
٨,٢ ﺍﻟﺘﺮﺍﻛﻴﺐ
...
٧٤١
٩,٢ ﻣﻠﺨﺺ ﻟﻠﻔﺼﻞ ﺍﻟﺜﺎﱐ، ﻣﻌﺎ ﺇﺿﺎﻓﺎﺕ
...
٨٦١
ﺍﻟﻔﺼﻞ ﺍﻟﺜﺎﻟﺚ – ﺍﻟﺘﻘﺪﻡ ﰲ ﻟﻐﺔ
...
Enumeration
ﺍﻟﺸﻜﻞ ١,١,٣: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺍﳊﺴﺎﺏ
...
Command-line Arguments
٣,٣ ﺍﻟﺘﻮﺟﻴﻬﺎﺕ )
...
٥,٣ ﺍﳌﻜﺘﺒﺔ ﺍﻟﻘﻴﺎﺳﻴﺔ
...
C
١,١ ﺍﻷﺩﻭﺍﺕ ﺍﻟﻼﺯﻣﺔ
...
C
٣,١ ﺍﳌﺘﻐﲑﺍﺕ ﻭ ﺍﻟﺜﻮﺍﺑﺖ
...
١٤
٤,١ ﺍﻟﺘﻌﻠﻴﻘﺎﺕ
...
input
٦,١ ﺍﳌﺆﺛﺮﺍﺕ
...
if, else, else…if
٨,١ﻋﻨﺎﺻﺮ ﻟﻐﺔ
...
C
ﺍﳉﺪﻭﻝ ٢,٨,١: ﺣﺪﻭﺩ ﺃﲰﺎﺀ ﺍﳌﻌﺮﻓﺎﺕ
...
Trigraphs
ﺍﳉﺪﻭﻝ ٤,٨,١: ﺛﻮﺍﺑﺖ ﺧﺎﺻﺔ ﺑﻠﻐﺔ ٦٧
...
ﺍﳉﺪﻭﻝ ١,٩,١: ﺭﻣﻮﺯ ﺍﻟﺪﺍﻟﺔ ٧٨
...
scanf
ﺍﻟﻔﺼﻞ ﺍﻟﺜﺎﱐ – ﺃﺳﺎﺳﻴﺎﺕ ﰲ ﻟﻐﺔ
...
Switch
٢,٢ ﺣﻠﻘﺎﺕ ﺍﻟﺘﻜﺮﺍﺭ
...
Arrays
٤,٢ ﺍﳌﺆﺷﺮﺍﺕ
...
Functions
٦,٢ ﺍﳌﻠﻔﺎﺕ ﺍﻟﺮﺃﺳﻴﺔ
...
Files I/O
٨,٢ ﺍﻟﺘﺮﺍﻛﻴﺐ
...
ﺍﻟﻔﺼﻞ ﺍﻟﺜﺎﻟﺚ – ﺍﻟﺘﻘﺪﻡ ﰲ ﻟﻐﺔ
...
Enumeration
٢,٣ ﻭﺳﺎﺋﻂ ﺍﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ
...
Directives(Preprocessor
ﺍﳉﺪﻭﻝ ١,٣,٣: ﺍﻷﲰﺎﺀ ﺍﳌﻌﺮﻓﺔ
...
٥,٣ ﺍﳌﻜﺘﺒﺔ ﺍﻟﻘﻴﺎﺳﻴﺔ
...
errno
ﺍﳉﺪﻭﻝ ٢,٥,٣: ﺛﻮﺍﺑﺖ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ٢٠٤
...
h
ﺍﳉﺪﻭﻝ ١,٥,٣: ﺛﻮﺍﺑﺖ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ ٢٠٥
...
h
ﺍﳉﺪﻭﻝ ١,٥,٣: ﺃﻫﻢ ﺍﻟﺜﻮﺍﺑﺖ ﺍﻟﱵ ﺗﺴﺘﻌﻤﻞ ﻣﻊ ﺍﻟﺪﺍﻟﺔ ٢١١
...
C
١,١ ﺍﻷﺩﻭﺍﺕ ﺍﻟﻼﺯﻣﺔ
...
C
ﺍﻟﱪﻧﺎﻣﺞ ١,٢,١: ﺍﻟﱪﻧﺎﻣﺞ ﺍﻷﻭﻝ ﰲ ﻟﻐﺔ ٢٥
...
(٢) C
ﺍﻟﱪﻧﺎﻣﺞ ٣,٢,١: ﺍﻟﱪﻧﺎﻣﺞ ﺍﻷﻭﻝ ﰲ ﻟﻐﺔ ٢٧
...
(٤) C
ﺍﻟﱪﻧﺎﻣﺞ ٥,٢,١: ﺍﻟﱪﻧﺎﻣﺞ ﺍﻷﻭﻝ ﰲ ﻟﻐﺔ ٢٧
...
(٦) C
ﺍﻟﱪﻧﺎﻣﺞ ٧,٢,١: ﺍﻟﱪﻧﺎﻣﺞ ﺍﻷﻭﻝ ﰲ ﻟﻐﺔ ٢٨
...
(٨) C
ﺍﻟﱪﻧﺎﻣﺞ ٩,٢,١: ﺍﻟﱪﻧﺎﻣﺞ ﺍﻷﻭﻝ ﰲ ﻟﻐﺔ ٢٨
...
(١٠) C
ﺍﻟﱪﻧﺎﻣﺞ ١١,٢,١: ﺍﻟﱪﻧﺎﻣﺞ ﺍﻷﻭﻝ ﰲ ﻟﻐﺔ ٢٨
...
(١٢) C
ﺍﻟﱪﻧﺎﻣﺞ ٣١,٢,١:ﻃﺒﺎﻋﺔ ﻋﺪﺩ ﺻﺤﻴﺢ
...
٠٣
ﺍﻟﱪﻧﺎﻣﺞ ٥١,٢,١: ﻃﺒﻊ ﻋﺪﺩﻳﻦ
...
٠٣
ﺍﻟﱪﻧﺎﻣﺞ ٧١,٢,١: ﲨﻊ ﻭ ﺇﻇﻬﺎﺭ ﺃﻋﺪﺍﺩ ﺣﻘﻴﻘﻴﺔ
...
١٣
ﺍﻟﱪﻧﺎﻣﺞ ٩١,٢,١: ﻃﺒﺎﻋﺔ ﺣﺮﻑ )٢(
...
٢٣
ﺍﻟﱪﻧﺎﻣﺞ ١٢,٢,١: ﻃﺒﺎﻋﺔ ﻧﺺ )٢(
...
٢٣
٣,١ ﺍﳌﺘﻐﲑﺍﺕ ﻭ ﺍﻟﺜﻮﺍﺑﺖ
...
٥٣
ﺍﻟﱪﻧﺎﻣﺞ ٢,٣,١: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺘﻐﲑ ﻣﻦ ﻧﻮﻉ ﻋﺪﺩ ﺣﻘﻴﻘﻲ
...
٦٣
ﺍﻟﱪﻧﺎﻣﺞ ٤,٣,١: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺘﻐﲑ ﻣﻦ ﻧﻮﻉ ﻋﺪﺩ ﺻﺤﻴﺢ )٢(
...
٦٣
ﺍﻟﱪﻧﺎﻣﺞ ٦,٣,١: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺘﻐﲑ ﻣﻦ ﻧﻮﻉ ﺣﺮﰲ
...
٨٣
ﺍﻟﱪﻧﺎﻣﺞ ٨,٣,١: ﻃﺮﻳﻘﺔ ﲢﺪﻳﺚ ﻗﻴﻤﺔ ﻣﺘﻐﲑ ﻭ ﻃﺒﻌﻬﺎ
...
٨٣
ﺍﻟﱪﻧﺎﻣﺞ ٠١,٣,١: ﻧﺎﺗﺞ ﲨﻊ ﺑﲔ ﻋﺪﺩﻳﻦ ﺻﺤﻴﲔ ﰲ ﻣﺘﻐﲑ
...
٩٣
ﺍﻟﱪﻧﺎﻣﺞ ٢١,٣,١: ﻃﺮﻳﻘﺔ ﻃﺒﺎﻋﺔ ﺣﺮﻑ ﺑﺎﻹﻋﺘﻤﺎﺩ ﻋﻠﻰ ﺭﻗﻤﻪ ﰲ ﺟﺪﻭﻝ ﺃﺳﻜﻲ
...
٠٤
ﺍﻟﱪﻧﺎﻣﺞ ٤١,٣,١: ﻣﺘﻐﲑ ﺑﺪﻭﻥ ﺇﺷﺎﺭﺓ
...
١٤
ﺍﻟﱪﻧﺎﻣﺞ ٦١,٣,١: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺛﺎﺑﺖ ﻭ ﺍﻟﺘﺤﺪﻳﺚ ﰲ ﻗﻴﻤﺘﻪ
...
٢٤
ﺍﻟﱪﻧﺎﻣﺞ ٨١,٣,١: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺛﺎﺑﺖ )٢(
...
٣٤
٤,١ ﺍﻟﺘﻌﻠﻴﻘﺎﺕ
...
٥٤
ﺍﻟﱪﻧﺎﻣﺞ ٢,٤,١: ﺍﻟﺘﻌﻠﻴﻘﺎﺕ ﺍﻟﺴﻄﺮﻳﺔ
...
٦٤
ﺍﻟﱪﻧﺎﻣﺞ ٤,٤,١: ﺍﳋﻄﺄ ١
...
٧٤
٥,١ ﺍﻹﺩﺧﺎﻝ
...
٨٤
ﺍﻟﱪﻧﺎﻣﺞ ٢,٥,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ scanfﻹﺩﺧﺎﻝ ﺣﺮﻑ
...
٩٤
ﺍﻟﱪﻧﺎﻣﺞ ٤,٥,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ scanfﻹﺩﺧﺎﻝ ﻗﻴﻤﺔ ﺻﺤﻴﺤﺔ )٣(
...
Operators
ﺍﻟﱪﻧﺎﻣﺞ ١,٦,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﻣﺆﺛﺮ ﺍﻟﺰﻳﺎﺩﺓ
...
٢٥
ﺍﻟﱪﻧﺎﻣﺞ ٣,٦,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﻣﺆﺛﺮ ﺍﻟﺰﻳﺎﺩﺓ )٣(
...
٣٥
ﺍﻟﱪﻧﺎﻣﺞ ٥,٦,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﻣﺆﺛﺮ ﺍﻟﻨﻘﺼﺎﻥ )٢(
...
٣٥
ﺍﻟﱪﻧﺎﻣﺞ ٧,٦,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﳌﺆﺛﺮﺍﺕ ﺍﻟﻌﻼﻗﻴﺔ
...
٥٥
ﺍﻟﱪﻧﺎﻣﺞ ٩,٦,١: ﻣﺆﺛﺮ ﺍﻹﺯﺍﺣﺔ ﺇﱃ ﺍﻟﻴﺴﺎﺭ
...
٦٥
ﺍﻟﱪﻧﺎﻣﺞ ١١,٦,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﳌﺆﺛﺮ #
...
٧٥
ﺍﻟﱪﻧﺎﻣﺞ ٣١,٦,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﳌﺆﺛﺮ ﺃﻭ | ٥٨
...
AND
ﺍﻟﱪﻧﺎﻣﺞ ٥١,٦,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﳌﺆﺛﺮ ^ ٥٩
...
NOT
٧,١ ﺍﻟﻘﺮﺍﺭﺍﺕ
...
if
ﺍﻟﱪﻧﺎﻣﺞ ٢,٧,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ٦١
...
else
ﺍﻟﱪﻧﺎﻣﺞ ٤,٧,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ٦٣
...
C
ﺍﻟﱪﻧﺎﻣﺞ ١,٨,١: ﺇﺳﺘﻌﻤﺎﻝ ﺭﻣﻮﺯ ٦٥
...
(٢) Trigraphs
ﺍﻟﱪﻧﺎﻣﺞ ٣,٨,١: ﺍﻟﺜﻮﺍﺑﺖ ﺍﻟﻨﺼﻴﺔ
...
٦٦
ﺍﻟﱪﻧﺎﻣﺞ ٥,٨,١: ﺍﻟﺜﻮﺍﺑﺖ ﺍﻟﺮﻗﻤﻴﺔ
...
٨٦
٩,١ ﻣﻠﺨﺺ ﻟﻠﻔﺼﻞ ﺍﻷﻭﻝ، ﻣﻊ ﺇﺿﺎﻓﺎﺕ
...
٠٧
ﺍﻟﱪﻧﺎﻣﺞ ٢,٩,١: ﺁﻟﺔ ﺣﺎﺳﺒﺔ ﺑﺴﻴﻄﺔ
...
١٧
ﺍﻟﱪﻧﺎﻣﺞ ٤,٩,١: ﺃﺧﺬ ﺍﻟﻌﺪﺩ ﺍﻟﻜﺒﲑ
...
putchar
ﺍﻟﱪﻧﺎﻣﺞ ٦,٩,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ ٧٣
...
puts
ﺍﻟﱪﻧﺎﻣﺞ ٨,٩,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ wprintﻭ ﺍﻟﺪﺍﻟﺔ ٧٤
...
putch
ﺍﻟﱪﻧﺎﻣﺞ ٠١,٩,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ getchﻭ ﺍﻟﺪﺍﻟﺔ ٧٦
...
getche
ﺍﻟﱪﻧﺎﻣﺞ ٢١,٩,١: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ ٧٦
...
wmain
ﺍﻟﱪﻧﺎﻣﺞ ٤١,٩,١: ﺍﻟﺪﺍﻟﺔ ٧٧
...
٧٧
ﺍﻟﱪﻧﺎﻣﺞ ٦١,٩,١: ﺇﺭﺟﺎﻉ ﻗﻴﻤﺔ ﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ )٢(
...
٨٧
ﺍﻟﻔﺼﻞ ﺍﻟﺜﺎﱐ – ﺃﺳﺎﺳﻴﺎﺕ ﰲ ﻟﻐﺔ
...
Switch
ﺍﻟﱪﻧﺎﻣﺞ ١,١,٢: ﺁﻟﺔ ﺣﺎﺳﺒﺔ ﺑﺴﻴﻄﺔ ﺑﺈﺳﺘﺨﺪﺍﻡ ٨١
...
switch
ﺍﻟﱪﻧﺎﻣﺞ ٣,١,٢: ﺍﳋﻄﺄ ١
...
Repeated loop
ﺍﻟﱪﻧﺎﻣﺞ ١,٢,٢: ﺍﻟﺘﻜﺮﺍﺭ ﺑﻮﺍﺳﻄﺔ ٨٧
...
(٢) while
ﺍﻟﱪﻧﺎﻣﺞ ٣,٢,٢: ﺍﻟﺘﻜﺮﺍﺭ ﺑﻮﺍﺳﻄﺔ ٨٨
...
(٤) while
ﺍﻟﱪﻧﺎﻣﺞ ٥,٢,٢: ﺍﻟﺘﻜﺮﺍﺭ ﺑﻮﺍﺳﻄﺔ ٨٩
...
(٢) do…while
ﺍﻟﱪﻧﺎﻣﺞ ٧,٢,٢: ﺍﻟﺘﻜﺮﺍﺭ ﺑﻮﺍﺳﻄﺔ ٩١
...
(٢) for
ﺍﻟﱪﻧﺎﻣﺞ ٩,٢,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ٩٢
...
(٢) goto
ﺍﻟﱪﻧﺎﻣﺞ ١١,٢,٢: ﺍﻟﺘﻜﺮﺍﺭ ﺑﻮﺍﺳﻄﺔ ٩٣
...
(٥) while
ﺍﻟﱪﻧﺎﻣﺞ ٣١,٢,٢: ﺍﻟﺘﻜﺮﺍﺭ ﺑﻮﺍﺳﻴﻄﺔ ٩٦
...
(٤) for
ﺍﻟﱪﻧﺎﻣﺞ ٥١,٢,٢: ﺍﻟﺘﻜﺮﺍﺭ ﺑﻮﺍﺳﻴﻄﺔ ٩٧
...
continue
ﺍﻟﱪﻧﺎﻣﺞ ٧١,٢,٢: ﻃﺒﺎﻋﺔ ﺟﺪﻭﻝ ASCIIﺑﺈﺳﺘﺨﺪﺍﻡ ﺣﻠﻘﺎﺕ ﺍﻟﺘﻜﺮﺍﺭ
...
Arrays
ﺍﻟﱪﻧﺎﻣﺞ ١,٣,٢: ﺑﺮﻧﺎﻣﺞ ﺑﻪ ﺃﻛﺜﺮ ﻣﻦ ٠٢ ﻣﺘﻐﲑ
...
١٠١
ﺍﻟﱪﻧﺎﻣﺞ ٣,٣,٢: ﻃﺮﻳﻘﺔ ﺇﻋﻄﺎﺀ ﻗﻴﻢ ﳌﺼﻔﻮﻓﺔ
...
٢٠١
ﺍﻟﱪﻧﺎﻣﺞ ٥,٣,٢: ﻃﺮﻳﻘﺔ ﺇﻋﻄﺎﺀ ﻗﻴﻢ ﳌﺼﻔﻮﻓﺔ )٣(
...
٣٠١
ﺍﻟﱪﻧﺎﻣﺞ ٧,٣,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺼﻔﻮﻓﺎﺕ ﺛﻨﺎﺋﻴﺔ ﺍﻷﺑﻌﺎﺩ )٢(
...
٤٠١
ﺍﻟﱪﻧﺎﻣﺞ ٩,٣,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺼﻔﻮﻓﺎﺕ ﺛﻼﺛﻴﺔ ﺍﻷﺑﻌﺎﺩ )٢(
...
٥٠١
ﺍﻟﱪﻧﺎﻣﺞ ١١,٣,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺳﻠﺴﻠﺔ ﺣﺮﻓﻴﺔ
...
٧٠١
ﺍﻟﱪﻧﺎﻣﺞ ٣١,٣,٢: ﺣﺴﺎﺏ ﻋﺪﺩ ﺃﺣﺮﻑ ﺇﺳﻢ ﻣﺴﺘﺨﺪﻡ
...
٨٠١
ﺍﻟﱪﻧﺎﻣﺞ ٥١,٣,٢: ﺍﻟﺪﺍﻟﺔ ١٠٩
...
strcpy
ﺍﻟﱪﻧﺎﻣﺞ ٧١,٣,٢: ﺍﻟﺪﺍﻟﺔ ١١٠
...
(٢) strcpy
ﺍﻟﱪﻧﺎﻣﺞ ٩١,٣,٢: ﺍﻟﺪﺍﻟﺔ ١١١
...
strncat
ﺍﻟﱪﻧﺎﻣﺞ ١٢,٣,٢: ﻃﺮﻕ ﺃﺧﺮﻯ ﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﳌﺼﻔﻮﻓﺎﺕ
...
٢١١
ﺍﻟﱪﻧﺎﻣﺞ ٣٢,٣,٢: ﻃﺮﻕ ﺃﺧﺮﻯ ﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﳌﺼﻔﻮﻓﺎﺕ )٣(
...
Pointers
ﺍﻟﱪﻧﺎﻣﺞ ١,٤,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﻣﺆﺷﺮ
...
٥١١
ﺍﻟﱪﻧﺎﻣﺞ ٣,٤,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﻣﺆﺷﺮ )٢(
...
٧١١
ﺍﻟﱪﻧﺎﻣﺞ ٥,٤,٢: ﻃﺮﻳﻘﺔ ﺃﺧﺮﻯ ﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﳌﺆﺷﺮﺍﺕ
...
٨١١
ﺍﻟﱪﻧﺎﻣﺞ ٧,٤,٢: ﺇﻣﻜﺎﻧﻴﺎﺕ ﺍﳌﺆﺷﺮ ﻣﻘﺎﺭﻧﺔ ﻣﻊ ﺍﳌﺼﻮﻓﺎﺕ
...
٨١١
ﺍﻟﱪﻧﺎﻣﺞ ٩,٤,٢: ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﻟﻨﺼﻮﺹ ﺑﺈﺳﺘﺨﺪﺍﻡ ﺍﳌﺆﺷﺮﺍﺕ )٢(
...
٩١١
ﺍﻟﱪﻧﺎﻣﺞ ١١,٤,٢: ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﻟﻨﺼﻮﺹ ﺑﺈﺳﺘﺨﺪﺍﻡ ﺍﳌﺆﺷﺮﺍﺕ )٤(
...
٠٢١
ﺍﻟﱪﻧﺎﻣﺞ ٣١,٤,٢: ﺍﳌﺮﺟﻊ
...
void
ﺍﻟﱪﻧﺎﻣﺞ ٥١,٤,٢: ﻣﺆﺷﺮ ﳌﺼﻔﻮﻓﺔ
...
٢٢١
ﺍﻟﱪﻧﺎﻣﺞ ٧١,٤,٢: ﻣﺆﺷﺮ ﳌﺆﺷﺮ
...
٢٢١
ﺍﻟﱪﻧﺎﻣﺞ ٩١,٤,٢: ﺍﳋﻄﺄ ١
...
٣٢١
ﺍﻟﱪﻧﺎﻣﺞ ١٢,٤,٢: ﺍﳋﻄﺄ ٣
...
٤٢١
٥,٢ ﺍﻟﺪﻭﺍﻝ
...
٥٢١
ﺍﻟﱪﻧﺎﻣﺞ ٢,٥,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺩﺍﻟﺔ )٢(
...
٦٢١
ﺍﻟﱪﻧﺎﻣﺞ ٤,٥,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺩﺍﻟﺔ ﺫﺍﺕ ﻭﺳﻴﻂ
...
٧٢١
ﺍﻟﱪﻧﺎﻣﺞ ٦,٥,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻋﻦ ﺩﺍﻟﺔ ﺫﺍﺕ ﺃﻛﺜﺮ ﻣﻦ ﻭﺳﻴﻄﲔ
...
٨٢١
ﺍﻟﱪﻧﺎﻣﺞ ٨,٥,٢: ﺍﻟﻮﺿﻊ ﺍﻹﻓﺘﺮﺍﺿﻲ ﻟﺪﺍﻟﺔ ﺑﺪﻭﻥ ﲢﺪﻳﺪ ﻧﻮﻋﻬﺎ
...
٩٢١
ﺍﻟﱪﻧﺎﻣﺞ ٠١,٥,٢: ﺍﻟﻄﺮﻳﻘﺔ ﺍﻹﻓﺘﺮﺍﺿﻴﺔ ﻟﻺﻋﻼﻥ ﻋﻦ ﻭﺳﻴﻂ ﻟﺪﺍﻟﺔ
...
short
ﺍﻟﱪﻧﺎﻣﺞ ٢١,٥,٢: ﺇﻋﻼﻥ ﻋﻦ ﺩﺍﻟﺔ ﻣﻦ ﻧﻮﻉ ١٣٠
...
١٣١
ﺍﻟﱪﻧﺎﻣﺞ ٤١,٥,٢: ﺇﻋﻼﻥ ﻋﻦ ﺩﺍﻟﺔ ﻣﻦ ﻧﻮﻉ *١٣١
...
٢٣١
ﺍﻟﱪﻧﺎﻣﺞ ٦١,٥,٢: ﺇﺳﺘﺪﻋﺎﺀ ﺩﺍﻟﺔ ﻣﻦ ﳐﺘﺼﺮ
...
٣٣١
ﺍﻟﱪﻧﺎﻣﺞ ٨١,٥,٢: ﺩﺍﻟﺔ ﺫﺍﺕ ﻭﺳﻴﻂ ﻟﺪﺍﻟﺔ ﺃﺧﺮﻯ ﺫﺍﺕ ﻭﺳﺎﺋﻂ
...
٤٣١
٦,٢ ﺍﳌﻠﻔﺎﺕ ﺍﻟﺮﺃﺳﻴﺔ
...
٥٣١
ﺍﻟﱪﻧﺎﻣﺞ ٢,٦,٢: ﺿﻢ ﺍﳌﻠﻒ ﺍﻟﺮﺃﺳﻲ
...
include
٧,٢ ﺍﻹﺩﺧﺎﻝ ﻭ ﺍﻹﺧﺮﺍﺝ ﰲ ﺍﳌﻠﻔﺎﺕ
...
٨٣١
ﺍﻟﱪﻧﺎﻣﺞ ٢,٧,٢: ﻃﺮﻳﻘﺔ ﺇﻧﺸﺎﺀ ﻣﻠﻒ
...
fileio
...
٢٤١
ﺍﻟﱪﻧﺎﻣﺞ ٥,٧,٢: ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ fprintfﻭ ﺍﻟﺪﺍﻟﺔ ١٤٤
...
fputs
ﺍﻟﱪﻧﺎﻣﺞ ٧,٧,٢: ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ fgetcﻭ ﺍﻟﺪﺍﻟﺔ ١٤٥
...
(٢) fputc
٨,٢ ﺍﻟﺘﺮﺍﻛﻴﺐ
...
٨٤١
ﺍﻟﱪﻧﺎﻣﺞ ٢,٨,٢: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﻭ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺒﻨﻴﺎﺕ )٢(
...
٠٥١
ﺍﻟﱪﻧﺎﻣﺞ ٤,٨,٢: ﺇﻋﻄﺎﺀ ﻗﻴﻢ ﻷﻋﻀﺎﺀ ﺑﻨﻴﺔ ﻣﺒﺎﺷﺮﺓ ﺑﻌﺪ ﺍﻟﺘﻌﲑ ﻋﻦ ﺇﺳﻢ ﺍﳌﺒﻨﻴﺔ
...
١٥١
ﺍﻟﱪﻧﺎﻣﺞ ٦,٨,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﺨﺪﺍﻡ ﺑﻨﻴﺔ ﻣﻌﺮﻓﺔ ﺑـ ١٥١
...
(٢) union
ﺍﻟﱪﻧﺎﻣﺞ ٨,٨,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﺨﺪﺍﻡ ﺑﻨﻴﺔ ﻣﻌﺮﻓﺔ ﺑـ ١٥٢
...
(٤) union
ﺍﻟﱪﻧﺎﻣﺞ ١١,٨,٢: ﺍﳌﺼﻔﻮﻓﺎﺕ ﻋﻠﻰ ﺍﻟﺒﻨﻴﺎﺕ
...
٤٥١
ﺍﻟﱪﻧﺎﻣﺞ ٣١,٨,٢: ﺍﳌﺆﺷﺮﺍﺕ ﻋﻠﻰ ﺍﻟﺒﻨﻴﺎﺕ
...
٥٥١
ﺍﻟﱪﻧﺎﻣﺞ ٥١,٨,٢: ﺍﳋﻄﺄ ١
...
ﺍﻟﱪﻧﺎﻣﺞ ١,٩,٢: ﺍﻟﺪﺍﻟﺔ ١٥٧
...
void
ﺍﻟﱪﻧﺎﻣﺞ ٣,٩,٢: ﻣﻌﲎ ﺩﺍﻟﺔ ﺎ ﻭﺳﻴﻂ ١٥٧
...
(٣) void
ﺍﻟﱪﻧﺎﻣﺞ ٥,٩,٢: ﻣﻌﲎ ﺩﺍﻟﺔ ﺎ ﻭﺳﻴﻂ ١٥٨
...
static
ﺍﻟﱪﻧﺎﻣﺞ ٧,٩,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ ١٥٩
...
typedef
ﺍﻟﱪﻧﺎﻣﺞ ٩,٩,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ ١٦٠
...
(٣) typedef
ﺍﻟﱪﻧﺎﻣﺞ ١١,٩,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ ١٦١
...
str
...
٢٦١
ﺍﻟﱪﻧﺎﻣﺞ ٤١,٩,٢: ﺗﺒﺎﺩﻝ ﻗﻴﻢ ﺑﲔ ﻭﺳﻴﻄﲔ
...
٣٦١
ﺍﻟﱪﻧﺎﻣﺞ ٦١,٩,٢: ﻋﻜﺲ ﺳﻠﺴﻠﺔ ﻧﺼﻴﺔ
...
٤٦١
ﺍﻟﱪﻧﺎﻣﺞ ٨١,٩,٢: ﺍﻟﺘﺤﻮﻳﻞ ﻣﻦ ﺍﳊﺮﻭﻑ ﺍﻟﺼﻐﲑﺓ ﺇﱃ ﺍﳊﺮﻭﻑ ﺍﻟﻜﺒﲑﺓ
...
wcscpy
ﺍﻟﱪﻧﺎﻣﺞ ٠٢,٩,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ ١٦٦
...
wcsncat
ﺍﻟﱪﻧﺎﻣﺞ ٢٢,٩,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺪﺍﻟﺔ getwcharﻭ ﺍﻟﺪﺍﻟﺔ ١٦٧
...
_putws
ﺍﻟﱪﻧﺎﻣﺞ ٤٢,٩,٢: ﻃﺒﺎﻋﺔ ﺣﺮﻑ ﻋﱪ ﺭﻗﻤﻪ ﰲ ﺟﺪﻭﻝ ﺃﺳﻜﻲ
...
٨٦١
ﺍﻟﱪﻧﺎﻣﺞ ٦٢,٩,٢: ﺍﳌﺘﻐﲑﺍﺕ ﺍﳋﺎﺭﺟﻴﺔ
...
extern
ﺍﻟﱪﻧﺎﻣﺞ ٨٢,٩,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ ١٧٠
...
auto
ﺍﻟﱪﻧﺎﻣﺞ ٠٣,٩,٢: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﻜﻠﻤﺔ ﺍﶈﺠﻮﺯﺓ ١٧١
...
sizeof
ﺍﻟﱪﻧﺎﻣﺞ ٢٣,٩,٢: ﺍﺳﺘﺪﻋﺎﺀ ﺩﺍﻟﺔ ﻟﻨﻔﺴﻬﺎ
...
٣٧١
ﺍﻟﱪﻧﺎﻣﺞ ٤٣,٩,٢: ﻃﺮﻳﻘﺔ ﺍﻟﺘﺤﻜﻢ ﰲ ﻃﺒﺎﻋﺔ ﺍﻟﻨﺘﺎﺋﺞ
...
C
١,٣ ﺍﳊﺴﺎﺏ
...
enum
ﺍﻟﱪﻧﺎﻣﺞ ٢,١,٣: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ١٧٨
...
(٣) enum
ﺍﻟﱪﻧﺎﻣﺞ ٤,١,٣: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ١٧٩
...
(٥) enum
ﺍﻟﱪﻧﺎﻣﺞ ٦,١,٣: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ١٨٠
...
٠٨١
٢,٣ ﻭﺳﺎﺋﻂ ﺍﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ
...
٢٨١
ﺍﻟﱪﻧﺎﻣﺞ ٢,٢,٣: ﺍﻟﻮﺳﻴﻂ ﺍﻟﺜﺎﱐ ﻟﺪﺍﻟﺔ ﺍﻟﺮﺋﻴﺴﻴﺔ
...
٤٨١
٣,٣ ﺍﻟﺘﻮﺟﻴﻬﺎﺕ )
...
٦٨١
ﺍﻟﱪﻧﺎﻣﺞ ٢,٣,٣: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺘﻮﺟﻴﻪ ١٨٧
...
#endif
ﺍﻟﱪﻧﺎﻣﺞ ٤,٣,٣: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺘﻮﺟﻴﻪ ١٨٨
...
#ifdef
ﺍﻟﱪﻧﺎﻣﺞ ٦,٣,٣: ﻃﺮﻳﻘﺔ ﺇﺳﺘﻌﻤﺎﻝ ﺍﻟﺘﻮﺟﻴﻪ ١٨٩
...
#ifndef
ﺍﻟﱪﻧﺎﻣﺞ ٩,٣,٣: ﺇﺳﺘﻌﻤﺎﻝ ﺍﻷﲰﺎﺀ ﺍﳌﻌﺮﻓﺔ
...
ﺍﻟﱪﻧﺎﻣﺞ ١,٤,٣: ﺗﻮﻓﲑ ﺛﻼﺛﺔ ﻭﺳﺎﺋﻂ ﻟﺪﺍﻟﺔ ﺎ ﻭﺳﻴﻄﲔ
...
٣٩١
ﺍﻟﱪﻧﺎﻣﺞ ٣,٤,٣: ﻃﺮﻳﻘﺔ ﺍﻹﻋﻼﻥ ﺩﺍﻟﺔ ﺫﺍﺕ ﻭﺳﺎﺋﻂ ﻏﲑ ﳏﺪﺩﺓ )٢(
...
Standard Library
ﺍﻟﱪﻧﺎﻣﺞ ١,٥,٣: ﺍﻟﺪﺍﻟﺔ/ﺍﳌﺨﺘﺼﺮ ١٩٥
...
isalnum
ﺍﻟﱪﻧﺎﻣﺞ ٣,٥,٣: ﺍﻟﺪﺍﻟﺔ ١٩٦
...
iscntrl
ﺍﻟﱪﻧﺎﻣﺞ ٥,٥,٣: ﺍﻟﺪﺍﻟﺔ ١٩٧
...
isgraph
ﺍﻟﱪﻧﺎﻣﺞ ٧,٥,٣: ﺍﻟﺪﺍﻟﺔ ١٩٨
...
isprint
ﺍﻟﱪﻧﺎﻣﺞ ٩,٥,٣: ﺍﻟﺪﺍﻟﺔ ١٩٩
...
isspace
ﺍﻟﱪﻧﺎﻣﺞ ١١,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٠٠
...
isxdigit
ﺍﻟﱪﻧﺎﻣﺞ ٣١,٥,٣: ﺍﻟﺪﺍﻟﺘﲔ toupperﻭ ٢٠١
...
perror
ﺍﻟﱪﻧﺎﻣﺞ ٥١,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٠٣
...
errno
...
locale
...
math
...
sin
ﺍﻟﱪﻧﺎﻣﺞ ٠٢,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٠٧
...
tan
ﺍﻟﱪﻧﺎﻣﺞ ٢٢,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٠٧
...
log
ﺍﻟﱪﻧﺎﻣﺞ ٤٢,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٠٨
...
sqrt
ﺍﻟﱪﻧﺎﻣﺞ ٦٢,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٠٨
...
floor
ﺍﻟﱪﻧﺎﻣﺞ ٨٢,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٠٩
...
ldexp
ﺍﻟﱪﻧﺎﻣﺞ ٠٣,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢١٠
...
jmp_buf
ﺍﻟﱪﻧﺎﻣﺞ ٢٣,٥,٣: ﺍﻟﺪﺍﻟﺔ ،va_startﺍﻟﺪﺍﻟﺔ va_argﻭ ﺍﻟﺪﺍﻟﺔ ،va_endﻭ ﺍﳌﺆﺷﺮ ٢١٢
...
size_t
ﺍﻟﱪﻧﺎﻣﺞ ٤٣,٥,٣: ﺍﳌﺘﻐﲑ ٢١٣
...
printf
ﺍﻟﱪﻧﺎﻣﺞ ٦٣,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢١٤
...
vprintf
ﺍﻟﱪﻧﺎﻣﺞ ٨٣,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢١٥
...
vsprintf
ﺍﻟﱪﻧﺎﻣﺞ ٠٤,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢١٦
...
fscanf
ﺍﻟﱪﻧﺎﻣﺞ ٢٤,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢١٧
...
fgetc
ﺍﻟﱪﻧﺎﻣﺞ ٤٤,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢١٧
...
fputc
ﺍﻟﱪﻧﺎﻣﺞ ٩٤,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢١٨
...
getc
ﺍﻟﱪﻧﺎﻣﺞ ٨٤,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢١٩
...
gets
ﺍﻟﱪﻧﺎﻣﺞ ٠٥,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢١٩
...
putchar
ﺍﻟﱪﻧﺎﻣﺞ ٢٥,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٢٠
...
ungetc
ﺍﻟﱪﻧﺎﻣﺞ ٤٥,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٢١
...
freopen
ﺍﻟﱪﻧﺎﻣﺞ ٦٥,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٢٢
...
remove
ﺍﻟﱪﻧﺎﻣﺞ ٨٥,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٢٣
...
tmpfile
ﺍﻟﱪﻧﺎﻣﺞ ٠٦,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٢٣
...
fwrite
ﺍﻟﱪﻧﺎﻣﺞ ٢٦,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٢٥
...
ftell
ﺍﻟﱪﻧﺎﻣﺞ ٤٦,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٢٦
...
feof
ﺍﻟﱪﻧﺎﻣﺞ ٦٦,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٢٧
...
atoi
ﺍﻟﱪﻧﺎﻣﺞ ٨٦,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٢٧
...
rand
ﺍﻟﱪﻧﺎﻣﺞ ٠٧,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٢٨
...
abort
ﺍﻟﱪﻧﺎﻣﺞ ٢٧,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٢٩
...
atexit
ﺍﻟﱪﻧﺎﻣﺞ ٤٧,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٣٠
...
abs
ﺍﻟﱪﻧﺎﻣﺞ ٦٧,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٣٠
...
div
ﺍﻟﱪﻧﺎﻣﺞ ٨٧,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٣١
...
strncpy
ﺍﻟﱪﻧﺎﻣﺞ ٠٨,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٣٢
...
strcat
ﺍﻟﱪﻧﺎﻣﺞ ٢٨,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٣٢
...
strcmp
ﺍﻟﱪﻧﺎﻣﺞ ٤٨,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٣٣
...
strrchr
ﺍﻟﱪﻧﺎﻣﺞ ٦٨,٥,٣: ﺍﻟﺪﺍﻟﺔ strspnﻭ ﺍﻟﺪﺍﻟﺔ ٢٣٤
...
strpbrk
ﺍﻟﱪﻧﺎﻣﺞ ٨٨,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٣٥
...
strlen
ﺍﻟﱪﻧﺎﻣﺞ ٠٩,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٣٦
...
strtok
ﺍﻟﱪﻧﺎﻣﺞ ٢٩,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٣٧
...
٨٣٢
ﺍﻟﱪﻧﺎﻣﺞ ٤٩,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٣٨
...
(٢) time
ﺍﻟﱪﻧﺎﻣﺞ ٦٩,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٣٩
...
localtime
ﺍﻟﱪﻧﺎﻣﺞ ٨٩,٥,٣: ﺍﻟﺪﺍﻟﺔ ٢٤٠
...
ctime
ﺃﻫﻢ ﺍﳌﺮﺍﺟﻊ
The C Programming Language Book, Second Edition By Brian Kernighan And Dennis Ritchie [Prentice Hall 1988;
ISBN 0-131-10362-8]
Fundamentals Programming Family Book, First Edition By IBM International 1985
Turbo C Manuel De Référence Book, By Borland International 1988 [FR]
Wikipedia, the free encyclopedia: www
...
org
CProgramming
...
cprogramming
...
Jones [Macmillan Computer Publishing]
The End
Title: Book Programming
Description: Book will help you to learn the programming language
Description: Book will help you to learn the programming language