C محاضرات فى لغة
رقم الصفحة ١C مقدمة عامة على لغة
بمجموعة من المزايا مثل :- C تتميز لغة - : C * ممیزات لغة
- لغة عامه : أى تصلح لعمل برامج قواعد البيانات والرسومات والحسابات ونظم التشغيل .
عبارة عن دالة رئيسية تنادى C البرنامج المكتوب بلغة : Structured Language - لغة تركيبية
مجموعة من الدوال الأخرى . وكل داله مجموعه من الأوامر .
حيث تستطيع أن تقرأ وتكتب وتغير وتقوم - : Bit manipulation ( - تتعامل على مستوى ( البت
هى اصغر وحدة لقياس المعلومات داخل الكمبيوتر Bit حيث أن . Bit بعمليات على مستوى ال
. byte وهى جزء من ثمانية أجزاء تعادل فى مجموعها حرف واحد
أن يعمل مع أكثر من جهاز مث ل C أى يمكن للبرنامج المكتوب بلغة : Portable - لغة متنقلة
. Apple و IBM
- لغة سريعة : - لأن أدوات اللغة تتعامل مع الآلة مما يختصر وقت التنفيذ .
ANSI C - لغة قياسية : معظم مترجمات اللغة تتوافق مع اللغة القياسية
The Basic Structure of c Program
قواعد بناء البرنامج
C - البرنامج التالى يمثل أبسط تركيب لبرنامج مكتوب بلغة
# include < stdio .h >
main ( )
{
printf ( " hello egypt " ) ;
}
ملاحظات هامة
وبين العلامتين اسم ملف التوجيه الخاص بالدوال # include < ……h > - يبدأ البرنامج بالعبارة
. include المستخدمة فى البرنامج – يمكن كتابة أكثر من
وتبدأ بالقوس } وتنتهي بالقوس { . main ( ) - يتكون البرنامج من دالة رئيسية
- جميع كلمات ودوال اللغة تكتب بالحروف الصغيرة .
) ; - تنتهي كل عبارة بفاصله منقوطة (
- يجوز كتابة أى ملاحظات أو تعليقات خاصة بالبرنامج بوصفها بين العلامين /* */ لأى عدد من
السطور
جسم الدالة يوضع ما بين الأقواس { } \
C محاضرات فى لغة
رقم الصفحة ٢
Data Type أنواع البیانات
* البيانات التى تتعامل معها إما أرقام أو حروف أو كلمات :-
أو حقيقية ( أى بها علامة integer ( - والأرقام يمكن أن تكون صحيحه ( أى ليس بها علامة عشرية
. float ( عشرية
- والحروف يمكن أن تكون حرف واحد أو أكثر من حرف
التى یشغلها :- byte * الجدول التالى یوضح هذه الأنواع وكذلك عدد البایت
نوع المتغیر طوله بالبایت المدى المسموح
1 حرف أو رمز واحد ( char ) حرف
٣٢٧٦٨- 2 إلى ٣٢٧٦٨ ( int ) صحيح قصير
٢٠١٤٧٠٤٨٣٠٦٤٨- 4 إلى ( long ) صحيح طويل
٢٠١٤٧٠٤٨٣٠٦٤٨
e + إلى 38 e- 38 4 ( float ) حقيقى
e+ إلى 308 e -308 8 ( double ) حقيقى مضاعف
وفیما یلى المقصود بكل هذه الأنواع : -
- متغير من نوع حرف : أى متغير يصلح لتخزين حرف فقط .
- متغير من نوع صحيح : أى متغير يصلح لتخزين رقم صحيح ( ليس به علامة عشرية ) .
أى يستطيع أى يخزن رقم صحيح ضعف المتغير : (Long ) - متغير من نوع صحيح ولكن طويل
الصحيح العادى ويستعمل هذا النوع إذا كانت الأرقام التى تتعامل معها أكبر من المساحة المخصصة
وإلا سنحصل على نتائج خاطئة بالرغم من إن البرنامج سليم
- متغير حقيقى : أى متغير يصلح لتخزين رقم حقيقى يقبل الكسور العشرية مثل 5 .33
- متغير حقيقى مضاعف : أى يستطيع أن يخزن رقم حقيقى ضعف المتغير الحقيقى العادى .
* تسمیته المتغیر : - يخضع اسم المتغير لشروط معينه :-
- يجب أن يبدأ المتغير بحرف ثم يكمل المتغير بعد ذلك حروف أو أرقام .
فإذا hp يختلف عن المتغير HP - يفرق المترجم بين الحروف الصغيرة والكبيرة فالمتغير
استعملا فى البرنامج يعتبرهما البرنامج متغيرين
- يجب ألا يكون المتغير بإسم كلمه من الكلمات المحجوزة .
* الأعلان عن المتغیرات : -
فى بداية البرنامج إما إذا كنت تستخدم Variables لابد الإعلان عن المتغيرات C - فى لغة ال
يتم الإعلان عن المتغيرات فى إى مكان بالبرنامج C ++ مترجم لغة
int a ;
float ;
operators * المؤثرات
C محاضرات فى لغة
رقم الصفحة ٣
المؤثرات هى الرموز التى تربط بين المتغيرات والثوابت لإنشاء علامة أو معادلة تختلف أنواع المؤثرات
باختلاف وظيفة كل مؤثر .
arithmetic operators ١- المؤثرات الحسابية
addition + علامات الجمع
Subtraction - علامات الطرح
multiplication * علامات الضرب
division / علامات القسمة
وتستخدم مع المتغيرات والثوابت الرقمية
وتستخدم لمقارنة قيمتين : -:Relational operators ٢- مؤثرات المقارنة
المؤثر الرمز مثا ل النتیجة
1 10>8 > greater than أكبر من
٠ 10<8 < less than أصفر من
0 ١٠==٨ == equal to يساوى
1 ١٠!=٨ ! = not equal to لا يساوى
0 ١٠ < = 8 <= less than or equal to أقل من أو يساوى
٠ 10 > = 8 >= greater than or equal to أكبر من أو يساوى
Logical operator ٣- المؤثرات المنطقية
المؤثر الرمز مثا ل النتیجة
1 10 > 8 && 9 > 7 && AND و
١ 1 0 < 8 || 7 < 8 || OR أو
1 ! (10 = = 8 ) ! NOT لا
Assignment Operators ٤- مؤثرات التخصيص
٩ = وهى مؤثرات تخزين قيمة فى متغير فمثلا إذا كانت قيمة ٦
التخصیص التقلیدى الطریقة الحدیثة النتیجة المؤثر
+ = addition assignment operators 11 A + = 5 A = a +5
Subtraition assignment opertors 1 A - = 5 A = a – 5
Multipication assibnment operators 30 A * = 5 A = a + 5
Division assignment operators 2 A / = 3 A = a / 3
Decrement &increment ٥- مؤثرات الزيادة والنقصان
C محاضرات فى لغة
رقم الصفحة ٤
7 مؤثر زيادة واحد A ++ A = a + 1
5 مؤثر نقصان واحد A -- A = a – 1
٦- مؤثر باقى خارج القسمة %
يستخدم لمعرفة باقى القسمه ( لتحديد هل الأرقام الموجودة فى المتغير زوجية أو فردية فمثلا إذا كانت
1 = 5 / يكون باقى الرقم 2 C = a % وكتب 2 a = قيمة 5
دوال الإدخال والإخراج
* printf() * دالة الطباعة على الشاشة
ملاحظات هامه : كل دالة مرتبطة بملف توجيه معين حيث يستدعى هذا الملف فى أول
وتكتب العبارة # stdio.h معرفة بالملف printf () فمثلا الدالة # include البرنامج بالعبارة
فى أول البرنامج حتى يتعرف المترجم على الدالة وهكذا مع باقى include < stdio.h >
الدوال
لطباعة البيانات بجميع أنواعها printf ( ) - تستخدم دالة الطباعة
على الشاشة فقط . ( String , char , float , int )
- ونأخذ دالة الطباعة عدة صور وكذلك معاملات وأكواد تحدد شكل المخرجات
مثال ١
printf ( " welcome with compuscience " )
هنا يتم طباعة ما بين علامتى التنصيص " "
مثال ٢
printf ( " \n welcome \n with \n compuscience " ) ;
أى سطر جديد وعندما يجد المترجم ١٠٠ يترجمها إلى new line فى هذا المثال : الكود ١٠٠ معناه
سطر جديد ويكون الناتج
welcome
with
compusciene
printf( ) وفيما يلى الاكواد المستخدمة مع الدالة
الكود الاستخدام المثا ل
C محاضرات فى لغة
رقم الصفحة ٥
printf ( " \n “ ) new line الانتقال السطر الجديد \n
print f ( " \t “ ) ( Tap ) نقل المؤشر بعد ٨ مسافات \t
print f ( " \b " ) Backspace إرجاع المؤشر مسافة خلفية \b
طباعة الحرف المناظر للكود المكتوب بالنظام السادس عشر \xdd
hexadecimal
printf ( “ x والنتيجة : ( " 41 a
octol طباعة الحرف المناظر للكود المكتوب بالنظام الثمانى \ddd
( each d represents a digit )
printf ( " \ النتيجة : ( ” 101 a
printf ( " \"" ) double quate ”\ طباعة علامة التنصيص
printf ( " \a “ ) ( إخراج صوت الصافرة ( يبب \a
* أوجد ناتج تنفيذ البرنامج التالى :
/ * program name 1 * /
# include < stdio.h >
main ( )
{
printf ( " \n this text display in new line “ ) ;
printf ( " \n word1 \t lab1 \t tab2 “ ) ;
printf ( " \n bell \a bell \ b “ ) ;
printf ( " \n this line display quotations \ “ “ ) ;
printf ( " \n “ ) ;
}
* طباعة قيم المتغيرات على الشاشة : لطباعة القيم الموجودة بالمتغيرات تستخدم أكواد معينة لتحدد نوع
print f () البيانات المراد طباعتها بالدالة
مثال
printf ( " % d “ , a ) ;
printf ( " % f “ , b ) ;
- فى هذا المثال عندما يقابل مترجم اللغة العلامة % ينظر إلى الحرف التالى لهذه العلامة . ويعتبر
هذا الحرف توصيف لقيمة موجودة بعد العلامة وكل حرف يحدد تنوع معين من البيانات .
والجدول التالى يوضح أكواد طباعة أنواع البيانات :
الكود الاستخدام مثا ل
C محاضرات فى لغة
رقم الصفحة ٦
توصيف لمتغير أو ثابت رقمى صحيح %d
( Signed decimal integer ) int
printf ( "% d “ , - 10)
توصيف لمتغير أو ثابت رقمى حقيقى %f
( floating point ) float
printf ( “ % p “ , 507 )
توصيف لمتغير أو ثابت ( حرف واحد ) %c
char Single character
printf ( “ % c “ , “ a “)
توصيف لعبارة حرفية حرف أو أكثر %s
String
printf ( “ % s “ , “ is “ )
توصيف لمتغير أو ثابت رقمى صحيح بدون إشارة ) %u
(unsigned decimal integer )
printf ( “ % u “ , “ 1٠ )
printf ( “ % x “ , af ) hex توصيف لمتغير أو ثابت بالنظام السادس عشر %x
printf ( “ % o “ , 67 ) Qctal توصيف لمتغير أو ثابت بالنظام الثمانى %o
* أوجد ناتج تنفيذ البرنامج التالى
/ * program name 2 * /
# include < stdio.h >
main ( )
{
int a , b , c ;
float f ;
long t ;
char ch = ‘y ‘ ;
char name [10] = " aly " ;
a = 5 ;
b = 10 ;
c = a + b ;
printf (“ \n c = % d “ , c ) ;
printf ( “\n f = % f “ , f ) ;
printf (“ \n name = % s “ , name ) ;
printf ( “ \n ch = % c “ , ch) ;
printf ( “\n t = % ld “ , t ) ;
}
* ملاحظات على الحل *
يشمل البرنامج السطر رقم ١ للتعليق أو الملاحظة ·
stdio.h وتستخدم لتحميل ملف التوجيه # include < stdio.h > فى السطر ٢ يشمل على الجملة ·
printf ( ) الذى يحتوى على تعريف الدالة
C محاضرات فى لغة
رقم الصفحة ٧
ثم السطر ٤ تبدأ الدالة الرئيسية بالقوس } main ( ) السطر رقم ٣ تبدأ الدالة الرئيسية ·
7 إعلان عن المتغيرات , 6 , فى السطر رقم 5 ·
y وإعطائه القيمة ( char ) من نوع حرف ch فى السطر رقم ٨ الإعلان عن المتغير ·
لتخزين عبارة حرفية وإعطائه القيمة الابتدائية كلمة name فى السطر رقم ٩ الإعلان عن المتغير ·
Aly
C وقيمة A , B فى السطر رقم ١٢ ، ١١ ، ١٠ لإعطاء قيم للمتغيرات ·
ثم طباعة المتغيرات ثم تنتهى الدالة الرئيسية بالقوس } وبالتالى ينتهى البرنامج ·
% 3 : يعنى طباعة ثلاث أرقام بعد العلامة العشرية فمثلا الرقم 534.6735 F ملاحظ ات : الصورة
يظهر بالصورة 534.674
*Scanf ( ) * دالة الإدخال العامة
هى دالة الإدخال الرئيسية التى تسمح بإدخال جميع أنواع البيانات وهى تأخذ نفس المعاملات التى تأخذها
Print f ( ) الدالة
مثال :
C محاضرات فى لغة
رقم الصفحة ٨
# include < stdio.h >
main ( )
{
int a , b , c ;
float r , s , t ;
char name [10];
printf ( " \n \n enter your name : " ) ;
scanf ( " % s " , name ) ;
printf ( " a = " ) ;
scanf ( " % d " , & a ) ;
printf ( “ b = " ) ;
scanf ( % d " , & b ) ;
printf ( " r = " ) ;
scanf ( " % f " , &r ) ;
printf ( " s= " ) ;
scanf ( " % f " & s ) ;
printf ( " \n welcome % s " , name ) ;
printf ( " \n \n c = a + b = % d " , a + b ) ;
printf ( " \n \n t = r + s = % d " , r + s ) ;
}
ملاحظات على الحل
a , b , c , r , s , t , name يتم الإعلان عن المتغيرات ·
enter your name الرسالة printf() تطبع الدالة ·
name العبارة الحرفية التى يدخلها المستخدم ونصفها فى المتغير scan f ( ) تستقبل الدالة ·
٠٠٠٠ كذلك المتغيرات الأخرى
قيمة صحيحه وتخزنها فى scan f ( ) ( “ % d " , &a ) فى سطر scan f ( ) تستقبل الدالة ·
a المتغير
# ماذا یعنى المؤشر & #
يشير إلى a بمعنى أن a تعنى تخزين القيمة الصحيحة فى المكان المخزن عنوانه فى المتغير : &a
عنوان المكان الذى تخزن فيه القيمة حيث العلامة & تجعل المتغير يشير إلى عنوان المكان
* الناتج :-
enter your name : ahmed
a = 5
b = 1٠
r = 2٠
s = 3٠
C محاضرات فى لغة
رقم الصفحة ٩
welcome ahmed
c = a + b = 15
t = r + s = 50
تمرین : برنامج لإیجاد مساحة الدائرة
# include < stdio .h >
/ * program to calculate erea of circle * /
main ( ) / * function heading */
{
float redius, area ; /* variable declarations */
printf ( “ redius = ? “ ) ; /* output statement */
scanf ( “ % f “ , redius ) ; /* input statement */
area = 3.14159 * redius * redius ; /* assignment statement */
printf ( “ area = % f “ , area ) ; /* output statement */
}
* دوال إدخال حرف * هناك دوال أخرى تتعامل مع أنواع خاصة من البيانات كالحروف والعبارات
الحرفية وهى :
getchar ( ) , getche ( ) , getch ( )
( stdio .h ملف توجيه ) - : getchar ( ) ١ – الدالة
تستخدم لإدخال حرف واحد ويظهر الحرف على الشاشة بعد الكتابة ولا تسمح بالانتقال إلى الأمر التالى
enter إلا إذاضغط المستخدم مفتاح الإدخال
مثال
char a ;
a = getchar ( ) ;
printf ( “ % c “ , a ) ;
( conio .h ملف التوجيه ) - : getche ( ) ٢- الدالة
تستخدم لإدخال حرف واحد ويظهر هذا الحرف على الشاشة ولكنها تختلف عن الدالة
للانتقال للسطر التالى وتعمل هذه enter فى أنها لا تحتاج إلى الضغط على مفتاح الإدخال getchar ( )
الدالة بطريقة مشابهة .
مثال
char a ;
a = getche ( ) ;
printf ( “ % c “ , a ) ;
( conio.h ملف التوجيه ) : getch ( ) ٣ – الدالة
C محاضرات فى لغة
رقم الصفحة ١٠
تستخدم لإدخال حرف واحد ولكن تختلف عن الدالتين السابقتين فى أن هذا الحرف لا يظهر على الشاشة
للانتقال إلى السطر التالى enter وكذلك فى أنها لا تحتاج إلى الضغط على مفتاح الإدخال
مثال
char a ;
a = getch ( ) ;
printf ( “ % c “ , a ) ;
( stdio.h ملف توجيه ) : putchar ( ) * دالة طباعة حرف واحد
- تستخدم لطباعة حرف واحد على الشاشة
كما هو a تطبع على الشاشة الحرف putchar ( ' a ') - فمثلا
stdio.h ملف التوجيه * gets ( ) * دالة إدخال عبارة حرفیة
string فى إدخال عبارة حرفية gets ( ) - تستخدم الدالة
مثال
char name[20];
gets (name) ;
Name العبارة الحرفية فى المتغير gets ( ) فى هذا المثال تخزن الدالة
stdio.h ملف التوجيه * puts ( ) * دالة طباعة عبارة حرفیة
حيث تطبع بدون توصيف شكل المخرجات string - تستخدم لطباعة عبارة حرفية
مثال :
char name[10] = “ ahmed “
puts (name) ;
puts ( “mohammed “ ) ;
عند تنفيذ البرنامج نحصل على النتيجة
ahmed
mohammed
من نوع حرفى ويصلح لتخزين كلمة name معناه أن المتغير char name[ ملاحظ ة : الإعلان [ 10
أقصى عدد حروف لها هو ١٠ حروف
* بعض الدوال المكتبة
include الدالة النوع الغر ض ملف
stdlib.h المطلقة i صحيح تعيد قيمة abs ( i )
math.h d مزدوج تعيد لوغاريتم طبيعيا ل log ( d )
math.h d مرفوعة إلى القوة 1 d مزدوج تعيد 1 pow ( d1 , d2 )
math.h l صحيح طويل تعيد قيمة مطلقة ل labs ( e )
math.h d مزدوج تعيد جيب sin ( d )
C محاضرات فى لغة
رقم الصفحة ١١
math.h d مزدوج تعيد الجزر التربيعى ل sqrt ( d )
string.h s فى السلسلة 1 s حرف تنسخ السلسلة 2 strcpy ( s1,s2 )
أوامر التحكم
بترتيب كتابتها . وعند وجود سطور متشابهة يتم main يتم تنفيذ السطور بين أقواس الدالة الرئيسية
العمل بأسلوب أوامر التحكم كالتالى : -
التكرار ( الدورات) التفریغ
Loop أولا التكرار
تستخدم لتكرار تنفيذ عملية عدد محدد من المرات : for ١- الدوارة
For ( initial – value ; condition ; increment ) ; statement ; : الصورة العامة
حيث :
هى القيمة الابتدائية : initial – value
هو شرط إنهاء التكرار : condition
هى قيمة الزيادة الدورية : increment
مثال : برنامج يطبع الأرقام من صفر إلى ٩
# include < stdio.h >
main ( )
{
int i ;
for ( i = 0 ; i < 10 ; i ++ )
printf ( “ \ n i = % d " , i ) ;
}
لتنفيذ أكثر من جملة لعدد محدد من المرات يجب وضع القوس } فى : For * تنفیذ أكث ر م ن جمل ة م ع
بداية البلوك المراد تكراره ووضع القوس { فى نهاية البلوك .
مثال : حساب متوسط قائمة من الأعداد
# include < stdio.h >
/ * calculate the average of n numbers * /
main ( )
{
int n , count ;
float x , average , sum = 0 ;
/ * initialize and read in a value for n * /
C محاضرات فى لغة
رقم الصفحة ١٢
printf ( " how many numbers ? " ) ;
scanf ( " % d " , & n ) ;
/ * read in the numbers * /
for ( count = 1 ; count < = n ; count ++ )
{
printf ( “ x = “ ) ;
scanf ( “ % f " ; & x ) ;
sum + = x ;
}
/ * calculate the average and write out the answer * /
average = sum / n ;
printf ( " \ n the average is % f \n " , average ) ;
}
For * الدوارات المتداخلة باستخدام
- الدوارات المتداخلة عبارة عن دوارة كبيرة تشتمل بداخلها على دوارة أو أكثر
الداخلى يتم تكرار تنفيذها طالما لم ينته العداد فإذا أنتهى loop - بمعنى أن مجموعة التعليمات بال
الخارجى حتى ينتهى . Loop ينتقل التنفيذ إلى الدوارة الخارجية ويتم تكرار التعليمات فى ال
١٢ × ١ إلى ١٢ × مثال : طباعة جدول الضرب من أول ١
# include < stdio.h >
main ( )
{
int i , j ;
for ( i = 1 ; i < = 12 ; i ++ )
{
printf ( “ in ") ;
for ( j = i ; j < = 12 ; j ++ )
{
printf ( " i * j = % d " , i * j ) ;
}
}
}
معناها تكرار تنفيذ الجملة بدون شرط ولا يتوقف التنفيذ حتى : For الدوارة اللانهائیة باستخدام ·
For ( ;; ) وتأخذ الدوارة اللانهائية الصورة CTRL + C يضغط المستخدم
لتكرار تنفيذ جملة أو مجموعة جمل عدد من المرات while تستخدم الدوارة :while ٢ – ال دوارة
غير معلوم العدد ويتوقف هذا على شرط موجود بالدوارة
الصورة العامة :
While ( condition )
{
statement 1 ;
statement 2 ;
}
While ( condition )
Statement ;
C محاضرات فى لغة
رقم الصفحة ١٣
يتم تكرار مجموعة الأوامر بين الأقواس { } عدد من المرات يتوقف على الشرط بين الأقواس ( ) ·
يتوقف تنفيذ هذه الأوامر ويستمر أداء باقى البرنامج . False . عندما يصبح الشرط ·
من البداية False التكرار يكون صفرا حينما يكون الشرط ·
While تمرین : تعديل برنامج حساب متوسط قائمة من الأعداد باستخدام
# include < stdio.h >
main ( )
{
int n , count = 1 ;
float x , average , sum = 0 ;
printf ( “ how many number ? " ) ;
scanf ( “ % d , & n ) ;
while ( count < = n ) ;
{
printf ( “ x = ") ;
scanf ( “ % f " , & x ) ;
sum + = x ;
count ++;
}
average = sum / n ;
printf ( " \ n the average is % f " ; average ) ;
}
* While و For * ملاحظات على
دوارة عددية حيث تعتمد على العداد ويتنهى التكرار فيها بانتهاء عدد مرات التكرار For - ال
حيث تتكرار while فدوارة شرطية أى تعتمد على الشرط الذى يلى الأمر while - أما الدوارة
الجمل التى تليها طالما كان الشرط صحيحا
لتكرار تنفيذ جملة أو مجموعة جمل أكثر من مرة do while تستخدم : Do … while ٣- الدوارة
ثم تختبر الشرط فإذا كان صحيحا تعيد التنفيذ Do بناء على شرط معين . أى يتم تنفيذ الجمل التالية ل
وإلا توقف التكرار
ينفذ مرة أخرى True إذن يتم التنفيذ مرة واحد على الأقل ثم يتم اختبار الشرط المنطقى ( ) فإذا كان
يتوقف التكرار ويستمر تنفيذ البرنامج الأصلى False وإذا كان
تمرين : إيجاد مجموع الأرقام من ٠ إلى ٩
# include < stdio.h >
main ( )
{
int count = 0 ;
int total = 0 ;
do
{
total + = count ;
C محاضرات فى لغة
رقم الصفحة ١٤
printf ( “ count = % d , total = % d \ n “ , count ++ , total ) " ) ;
}
while ( count < = 10 ) ;
}
ثانی اً : التفری غ : لتنفيذ سطر أو عدة سطور طبقا لشرط معين .أى تفريغ بعنى تغير مسار البرنامج .
والتفريغ إما يكون مشروط أو غير مشروط
١) التفریغ المشروط
لتنفيذ جملة أو أكثر حسب شرط معين ( اختبار منطقى ) IF تستخدم كلمة : IF * جملة الشرط
الصورة العامة
if ( condition )
statement ;
نفذ الجملة التالية أما إذا لم يتحقق الشرط فلا تنفذ هذه الجملة ( condition ) معناه إذا تحقق الشرط
وانتقل إلى التى تليها
لابد من فتح قوس } قبل مجموعة الجمل if ملاحظة إذا كان هناك أكثر من جملة تريد تنفيذها مع
والقوس { فى أخر الجمل كما يلى :
if ( condition )
{
statement 1 ;
statement 2 ;
}
فتأخذ الشكل التالى : if الشرطیة المتداخلة : يمكن أن تتداخل جمل if * جملة
if ( condition )
if ( condition )
if ( condition )
وهذا معناه إذا تحقق الشرط الأول انظر إلى الشرط الثانى …. وهكذا
تستخدم لتنفيذ أحد اختيارين وتأخذ الصورة التالية : : if …else * الجملة الشرطیة
if ( condition )
{
statement 1
}
else
{
statement 2
}
C محاضرات فى لغة
رقم الصفحة ١٥
وإلا نفذ ( statement نفذ الجملة الأولى ( 1 true صحيح ( condition ) ومعناها إذا كان الشرط
تستخدم لتحديد اختبار واحد من if ….else أى الجملة الشرطية ( statement الجملة الثانية ( 2
اختيارين ولا يمكن تنفيذ الاختيارين معا .
لتنفيذ خيار من مجموعة خيارات كمقارنة رقمين : if …. else if * الجملة الشرطیة
وفى كل جملة نضع أحد الشروط الثلاثة كما يلى : - IF الطریقة الأولى : باستخدام ثلاث جمل
i = 5 ;
if ( i < 5 ) ;
printf ( “ i less than 5 " ) ;
if ( i = 5 )
printf ( " i equal to 5 " ) ;
if ( i > 5 )
printf ( “ i greater than 5 “ ) ;
وهذه طريقة تستهلك وقتا فى اختبار جمل الشرط
الطریقة الثانیة
if ( condition )
statement 1 ;
else if ( condition )
statement 2 ;
else if ( condition )
statement 3 ;
وتكون صيغة المثال السابق كآلاتى :
I = 5 ;
if ( i < 5 )
printf ( “ i less than 5 " ) ;
else if ( i = 5 )
printf ( “ i equal to 5 " ;
else if ( i > 5 )
printf ( " i greater than 5 " ) ;
برنلمج : اشرح وظیفة البرنامج مع إیجاد الناتج إذا كانت القیم ١٣ و ٧على التوالى :-
# include < stdio.h >
main ( )
{
float num1 , num2 ;
char op ;
while (1)
{
printf ( “ type number , operator , number \ n " ) ;
C محاضرات فى لغة
رقم الصفحة ١٦
scanf ( “ % f % c % f ) , & num 1 , & op , & num 2 ) ;
if ( op = = ' + ' )
printf ( “ = % f " , num1 + num2 ;
else if ( op = = ' – ' )
printf ( “ = % f “ , num1 – num2 ;
else if ( op = = ' * ' )
printf ( " % f " , num1 * num2 ;
else if ( op = = ' / ' )
printf (“ = % f " , num1 / num2 ;
printf ( " \ n \ n " ) ;
}
}
Switch …. case ٢ - التفریع
فى اختبار مجموعة من عبارات معينة من عديد من المجموعات المتاحة Switch تتسبب عبارة
Switch للاستخدام . ويعتمد الاختبار على القيمة الحالية لتعيير موجود داخل عبارة
Switch ….. case تمرین : تعديل برنامج الآلة الحاسبة السابعة باستخدام
#include < stdio.h>
main ( ) /* void main(void) */
{
float num1,num2;
char ch,op;
do
{
printf( “\in type num1 op num2: “ ) ;
scanf( “%f %c %f “, &num1,&op,&num2);
switch (op)
{
case “+”;
printf ( "sum = %f ", num1+num2);
break;
case “-”;
printf ( "sub = %f ", num1-num2);
break;
C محاضرات فى لغة
رقم الصفحة ١٧
case “*”;
printf ( "mul = %f ", num1*num2);
break;
case “/”;
printf ( "div = %f ", num1/num2);
break;
default:
printf\n unknowen operator .”);
}
printf(“\n Again (y/n): “);
}
while (( ch=getch())== ‘y’ ):
}
هو استخدامه فى قوائم switch ….. case ملاحظ ة : من التطبيقات المشهودة لاستخدام التفريع
menu ( ) الاختيارات
switch فى انهاء دورات او الخروج من break تستخدم عبارة
goto ٣) التفریغ غیر المشروط
معناه الانتقال الى مكان محدد داخل البرنامج بدون شرك
#include <stdio.h>
main( )
{
char ss;
ss:
printf(“\t ALLAH”);
goto ss;
}
ويفضل استخدام الدوال لتغيير مسار تنفيذ البرنامج goto ملاحظات : - لا ننصح باستخدام جملة
CTRL+C - للخروج من البرنامج السابق أضغط
** دوال تحسین المدخلات والمخرجات **
conio.h ملف التوجیه : clrscr( ) ١) داله مسح الشاشة )
- تستخدم لمسح الشاشة ووضع المؤشر فى أول عمود من الصف الأول على الشاشة
clrscr( ) - الشكل العام
conio ملف التوجیه : gotoxy( ) ٢) داله تغییر ووضع المؤشر )
C محاضرات فى لغة
رقم الصفحة ١٨
y من الصف x - تستخدم لوضع الموشر فى العمود
gotoxy( ) - الشكل العام
gotoxy( مثال : الانتقال بالمؤشر الى العمود 30 من الصف العاشر أكتب ( 30,10
conio.h ملف التوجیه : textcolor( ) ٣) داله تغییر لون الكتابة )
- تستخدم لتغيير لون الكتابة التى ستطبع بعد الداله
- الصورة العامه
textcolor(color no)
أو
textcolor(color name)
حيث يتم تحديد اللون إما برقم اللون أو باسمه . ولا بد من كتابة اسم اللون بالحرف الكبيرة فقط
الجدول التالى لوضع اكواد الألوان وأسماها
اللو ن رقم اللو ن اسم اللو ن
BLACK اسود 0
BLUE ازرق ١
GRCEN أخضر ٢
CYAN سماوي ٣
RED أحمر ٤
MAGENTA بنفسجي ٥
BROWN بني ٦
LIGHTGRAY رمادي فاتح 7
DARKGRAY رمادي غامق ٨
LIGHBLUE ازرق فاتح ٩
LIGHTGREEN أخضر فاتح ١٠
LIGHTRED سماني فاتح ١١
LIGHTRED أحمر فاتح ١٢
C محاضرات فى لغة
رقم الصفحة ١٩
LIGHTMAGENTA بنفسجي فاتح ١٣
YELLOW أصفر ١٤
WHITG أبيض ١٥
مسائل :
١- اكتب برنامج لإيجاد جملة مبلغ ما اودع فى بنك لمدة ٢٠ سنة بفائدة
٦% لمبلغ ١٠٠ $ والمعادلة كما يلى :
f=p(1+i)n
معدل الفائدة I المبلغ p عدد السنوا ت n : حیث
** البرنامج **
#include <stdio.h>
#include <math.h>
main()
{
float p,r,n,i,f;
/* read input data */
printf( “please enter a value for the princepal (p) : “ );
scanf(“%f” k &p);
printf(“please enter a value for the interest rate( r) : “ );
scanf(“%f”, &r);
printf(“please enter a value for the number or year ( n) : “ );
scanf(“%f”, &n);
/*calculate i , then f */
i=r/100
f=p*pow((1+i),n);
/* write output */
C محاضرات فى لغة
رقم الصفحة ٢٠
printf( “\n the final value (f) is : %2f \n”,f);
}
٢- اكتب برنامج لإيجاد الجذور الحقیقیة لمعادلة من الدرجة الثانیة
ax2 + bx +c = بمعلومیة 0
وباستخدام الصیغة
- b b 2 - 4 ac
2 a
** البرنامج **
# include <stdio.h>
# include < math.h>
/* real roots of a quadratic equation */
main( )
{
float a,b,c,d,x1,x2;
/* read input data */
printf(“a= “ );
scanf(“%f”,&a);
printf(“b= “ );
scanf(“%f”,&b);
printf(“c= “ );
scanf(“%f”,&c);
/* carry out the calculations */
d=sqrt(b*b – 4*a*c);
X=
C محاضرات فى لغة
رقم الصفحة ٢١
x1=(-b+d)/(2*a);
x2=(-b-d)/(2*a);
/* write output */
printf(“x1= “,%e x2=%e “,x1,x2);
}
ملاحظة :
تستخدم للعد الحقيقى بالصور الأسية : %e
٣- اكتب برنامج لتقويم كثیرة الحدود
2 3 4 ( 1)5
5
( 1) 1
4
( 1) 1
3
( 1) 1
2
( 1) 1
x
x
x
x
x
x
x
x
x
y x -
+
-
+
-
+
-
+
-
=
*تمهيد:- لتبسيط البرنامج يتم وضع المتغير ( ( 1
x
u x
-
=
2 3 4 5
u 2 u 3 u 4 u 5 y = + + + +
** البرنامج **
# include<stdio.h>
# include<math.h>
main( )
{
float u,x,y;
/* read input data */
printf (“ x = “ );
scanf(“ %f “,&x );
/* carry out the calculations */
u= (x –1)/x;
y=u+pow(u,2.)/2+pow(u,3.)/3+poe(u,4.)/4+pow(u,5.)/5;
C محاضرات فى لغة
رقم الصفحة ٢٢
printf(“x= “,%f y =”%f “, x,y );
}
٤- برنامج لإدخال كلمة سر
# include<stdio.h>
# include<conio.h>
main( )
{
char pass[10];
do
{
printf(“\n enter password: “ );
scanf(“%s”,pass);
}
while(strcmp(pass,”dahe”)!=0);
}
ملاحظات:
هنا كلمة السر سوف تظهر أثناء الكتابة ·
فإذا كان المتغيرين string تقوم بمقارنه متغيرين من نوع عبارة حرفية : strcmp( ) الدالة ·
متطابقين كان الفرق بينهما صفر
تعديل لبرنامج كلمة السر:-
( عدم ظھور كلمة السر التى يكتبھا المستخدم على الشاشة )
# include<stdio.h>
# include<conio.h>
C محاضرات فى لغة
رقم الصفحة ٢٣
main( )
{
chat ch;
char pass[10];
do
{
textcolor(WHITE);
textbackground(BLUE);
cprintf(“\n enter password: “ );
textbackgrounf(WHITE);
cscanf(“%s”,pass);
}
while(strcmp(pass,”dahe”)!=0);
}
اكتب برنامج:
لطباعة عبارة حرفیة تم ادخالھا مع بیان عدد حروفھا وعدد الكلمات
/* count characters and word in a phrase عبارة typed in */
# include <stdio.h>
main( )
{
int charcnt=0;
int wordcnt=0;
char ch;
printf(“ type in a phrase : \n “);
/* read characters and quit loop on [ return ] */
while((ch=getche())!=’\r’);
{
charcnt ++ /* count character */
if(ch==’ ‘ ); /* space ? */
wordcnt++;
}
printf(“\n character count is %d “,charcnt );
printf(“\n word count is %d “ , wordcnt );
}
تذكر
عندما ترید استخدام الدالة
printf( ) طباعة حروف او أرقام
C محاضرات فى لغة
رقم الصفحة ٢٤
puts( ) طباعة عبارات حرفية فقط
scanf( ) ادخال حروف او أرقام
gets( ) ادخال عبارات حرفية
getch() ادخال حرف دون إظهاره على الشاشة
getche( ) ادخال حرف مه اظهاره على الشاشة
clrscr( ) مسح الشاشة
gotoxy( ) تغيير موضع المؤشر
textcolor( ) تغيير ألوان الكتابة
textbackground( ) تغيير ألوان خلفية الكتابة
cprintf( ) , cputs الطباعة بالألوان على الشاشة
cscanf( ), cgets ادخال البيانات بالألوان
FUNCTION الدوال
نوعین :- C ا لدولا فى لغةال
scanf( ) أو دالة printf( ) وهى الدوال القياسية مثل دالة Built in Function ١) دوال اللغة )
وهى دوال عامة يستطيع اى مبرمج استخدامها
-:User Function ٢) دوال المستخدم المبتكرة )
- وهى الدوال التى من وضع المبرمج
- والهدف منها : انه عند تكرار مجموعة من سطور الأوامر اكثر من مرة فى مواضع مختلفة فإن
أوامر التكرار لن تكون ذات منفعة . ولذلك يتم كتابة هذه السطور منفصلة عن البرنامج الأساسى
م زايا استخدام الدولا
١- عدم تكرار التعليمات داخل البرنامج : حيث يتم إنشاء الدالة مرو واحدة ثم يتم استدعائها أكثر من
مرة عند الحاجة إليها
٢- باستخدام الدوال يصبح البرنامج أكثر وضوحاً
الصور العامة:
# include < filename>
function declarations;
main( )
{
C محاضرات فى لغة
رقم الصفحة ٢٥
function1
function2
}
function1
{
------
------
}
function2
{
------
------
}
أذ ن تتكون الدالة من :-
١) الإعلان عن الدالة ( ٢) جسم الدالة )
مثال : دالة بدو ن دلیل
#include <stdio.h>
#include<conio.h>
void line2(void);
main( )
{
clrscr( )
line2( )
printf(“ ** Allah the god of all world ** \n “);
line2( )
/* end of main( ) function */
}
void line2(void)
{
int j;
for(j=0;j<=40;j++);
printf( “ * “);
printf(“\n “);
}
فى ثلاث مواضع :- line وقد ظهرت كلمة ( ) 2 line فى البرنامج السابق أنشأنا دالة بالاسم ( ) 2
C محاضرات فى لغة
رقم الصفحة ٢٦
يكون ذلك قبل الدالة الرئيسية function declaration الموضع الأول : يسمى الأعلان عن الدالة
كما فى السطر رقم ٣ ونلاحظ الفاصلة المنقوطة فى نهاية الجزء main( )
لأنه أعلان.
ويظهر فى أى مكان داخل الدالة الرئيسية ويسمى main( ) الموض ع الث انى : داخل الدالة الرئيسية
كما فى السطر line أى استدعاء الدالة ويكون بالشكل ( ) 2 function coling
٧و ٩ وفيه يتم كتابة اسم الدالة فقط بدون نوع وإذا كان لها معاملات نكتب
المعاملات.
وهذا الجزء يسمى تعريف الدالة .main( ) الموض ع الثال ث : يكتب بعد انتهاء الدالة الرئيسية
وفيه يتم كتابة محتويات الدالة . وتبدأ فى البرنامج من function definition
السطر رقم ١١ باسم الدالة ثم بالقوس } وكانها برنامج ونبدأ كتابة تعليمات الدالة
بعد القوس ثم ننتهى بالقوس {
** Function Type ** نأواع الدولا
int function دوال تعيد قيمة صحيحة
float function دوال تعيد قيمة حقيقية
string function دوال تعيد عبارة حرفية
void function دوال لا تعيد اى قيمة
struct function structure دوال تعيد قيمة من نوع
تمرين :
# include <stdion.h>
int sum(int a, int b ) الاعلان عن الدالة
main( )
{
int z , x = 10 , y = 40;
z = sum(x,y);
printf(“\n\n z = %d “ , z );
}
/* الدالة */
int sum(int a , int b )
{
C محاضرات فى لغة
رقم الصفحة ٢٧
int s;
s = a + b ;
return s;
}
** ملاحظات على البرنامج **
وهى نوع الدوال int وسبقت بالكلمة sum( ) - فى السطر رقم ٢ تم الاعلان عن دالة بالاسم
مع ملاحظة وجود متغيرين بين الأقواس وهما معاملات الدالة. void وتقابل كلمة
ويستخدمان كمعاملات للدالة x ,y - فى السطر رقم ٦ يتم استدعاء الدالة وبين أقواسها المتغيرات
(لابد من كتابة معاملات الدالة لأننا أعلنا عنها بهذه الصورة )
- تشمل السطور من ٩ الى ١٤ على جمل الدالة نفسها :-
وهى القيمة ١٠ . كذلك x بالقيمة الموجودة فى المتغير a السطر رقم ٩ نعوض عن المتغير ·
. وهى ٤٠ y بالقيمة الموجودة فى المتغير b نعوض عن المتغير
s ونضع النتيجة فى متغير جديد هو b والمتغير a السطر رقم ١٢ نجمع محتويات كلا من المتغير ·
return الى مكان استدعاء الدالة باستخدام كلمة s السطر رقم ١٣ نطلب اعادة محتويات المتغير ·
. z = s الموجودة بالسطر رقم ٦ تعادل الجملة z = sum(x,y) نفهم ان جملة ·
ملاحظة هامة: معنى الدالة يتضح من القاعدة التى تقول أن نوع الدالة يتوقف على القيمة المرتجعة
من الدالة.
int كان نوع الدالة int فإذا كانت القيمة المرتجعة
float كان نوع الدالة float وإذا كانت القيمة المرتجعة
void فتكون من نوع (return أما الدالة التى لا تعيد قيمة(الدالة لا تشتمل على جملة
** استدعاء الدالة **
- يتم استدعاء الدوال اما بمعاملات او بدون معاملات
اى عدم كتابة قيم بين أقواس الدالة void line2(void) - تكون الدالة بدون معاملات مثل الدالة
* برنامج يوضح كيفية استدعاء الدالة بمعاملات *
# include < stdio.h>
# include <conio.h>
void line3(int no)
main( )
{
clrscr( )
line3(30);
printf(“ ** Allah the god of all world ** \n “);
line3(70);
}
C محاضرات فى لغة
رقم الصفحة ٢٨
/* الدالة */
void line3(int no)
{
int j , no;
for(j = 0 ; j <= no ; j++ )
printf(“ * “ );
printf(“\n”);
}
وفى كل مرة يتم ارسال قيمة .no ** ملاحظة : الدالة هنا لها معامل واحد من نوع صحيح وهو
مختلفة للمعامل وذلك عند استدعاء الدالة.
** استدعاء الدالة بمتغیرا ت **
- ممكن استدعاء الدالة بمعاملات من نوع قيم ثابتة موجودة بالبرنامج نفسه
- وأيضا يمكن ان تكون هذه المعاملات متغيرات تستقبل قيمها من المستخدم او من داخل البرنامج
وهذا يفيد فى حالة تغير واختلاف المتغيرات فى كل مرة ( إعطاء مرونة فى التعامل مع البرنامج )
* برنامج لتحديد الكمیة الأكبر من ثلاث كمیات صحیحة
# include <stdio.h>
/* determine the largest of three integer quantities */
main( )
{
int a, b, c, d;
/* read the integer quantities */
printf(“\n a = “);
scanf( % d “ , &a );
printf(“\n b = “);
scanf( % d “ , &b );
printf(“\n c = “);
scanf( % d “ , &c );
/* calculate and display the maximum value */
d = maximum( a, b );
printf(“\n \n maximum = % d , maximum(c ,d ));
}/* determine the larger of two integer quatities */
maximum(x ,y )
C محاضرات فى لغة
رقم الصفحة ٢٩
int x ,y;
{
int z;
z = (x >= y ) ? x | y;
return(z);
}
ملاحظة هامة : من ضمن أوامر التحكم ( علامة الاستفهام الشرطية |? ) حيث :-
اختبار test عبارة (x > = y ) -
if - ؟ عبارة عن سؤال
Else - | عبارة عن
وإذا كانت القيمة غير صحيحة يأخذ x صحيحا يأخذ القيمة (x >= y ) بمعنى إذا كان الاختبار
y القيمة
** باستخدا م ا لدولا أكتببر نامج
لتحويل الساعات إلى دقائق مع إيجاد الفرق
# include<stdio.h>
/* calculates difference between two times */
main( )
{
int mins1 , mins2;
printf(“ type first time ( from 3:22 ): “ );
mins1=getmins();
printf(“ type second(later) time “ );
mins2=getmins();
printf(“ Difference is %d minutes.” , mins2-mins1);
}/
* getmins function */
/* gets time in hours : minutes formal */
/* return time in minutes */
getmins( )
{
int hours, minuts;
scanf(“ %d : %d “, &hours , &minutes);
return(hours * 60 + minutes);
}
تتكون من دالتین :- int * الآتى برنامج يستعمل دالة من نوع
- دالة لحساب مربع القيمة وإعادة حاصل الضرب الى الدالة الرئيسية
C محاضرات فى لغة
رقم الصفحة ٣٠
- دالة تحسب نكعب قيمة وتعيدها عند الاستدعاء
# include < stdio.h>
int sqr(int a):
int qup(int q):
main( )
{
int s , qu , no =10;
s = aqr(no);
qu = qup(no);
printf(“\n squer of no = %d “ , s ):
printf(“\n qupic of no = %d “ , qu ):
}
int sqr(int a)
{
int v1;
v1= a*a;
return v1;
}
int qup(int q )
{
int v2;
v2=q*q*q;
return v2;
}
نتيجة التنفيذ :
squar of on = 100
qupic of on = 1000
تقوم بجمع رقمین وإعادة float الآتيبرنامج يستعمل دالة من نوع
النتیجة الى الدالة الرئیسیة عند الاستدعاء . والقیمة المرتجعة قیمة
float ويالتالى يكون نوع الدالة float حقیقیة
# include <stdio.h>
# include < conio.h>
float add( float x , float y )
main( )
{
float no1, no2;
printf(“\n enter no1 , no2 : );
scanf(“ %f ,%f “ , &no` ,&no2 ):
C محاضرات فى لغة
رقم الصفحة ٣١
printf(“\n addition of number is %f”, add(no1,no2) );
}
float add(float x , float y );
{
float yt;
yt= x + y ;
return yt;
}
عند التنفيذ نحصل على :-
Enter no1 ,no2 : 3,2 , 4,3
Addition of squares is 6.5
** الآتي برنامج لإيجاد العدد فردى أم زوجى وكذلك موضحا العدد سالب
أم موجب
# include < stdio.h>
/* tests use of external variables */
int keynumb;
main( )
/* external variables */
{
printf(“ type keynumb : “ );
scanf(“%d “ , &keynumb );
addeven( );
negative( );
}
/* checks if keynumb is odd or even */
oddeven( )
{
if (keynumb %2 )
printf(“ keynumb is odd. \n”);
else
printf( “ keynumb is even. \n”);
}
C محاضرات فى لغة
رقم الصفحة ٣٢
/* checks if keynumb is nagative */
ngative( )
{
if (keynumb < 0 )
printf(“ keynumb is negative . \n”);
else
printf( “ keynumb is positive . \n”);
}
MACROS الماكرو
ويتم إنشاء function هو مجموعة من التعليمات تؤدى غرض معين ويشبه إلى حد كبير الدالة
الماكرو مرة واحدة وبعد ذلك يمكن استدعائه كلما احتجت إيه ( أى يتم تعريف الثوابت او عمليات
محدده فى بداية البرنامج وتكون لها صفه العمومية للاستخدام داخل الدالة الرئيسية والدوال الفرعية )
C إذن : الماكرو من ضمن بناء برنامج لغة ال
كیفیة إنشاء الماكرو :-
#define - يتم ذلك باستعمال الكلمة
ومعناها التوجيه preprocessor او directive - وهذه الكلمة تسمى
# define macro line * الصورة العامة
#define a مثلا 5
بالقيمة 5 a وهى عبارة عن تعريف طرف بطرف ومعناها عرف المتغير
تمرين يوضح كیفیة الإعلان عن الماكرو وكیفیة استعماله
# include<stdio.h>
# define sum(a,b) a+b
# define mul(x,y) x*y
main ( )
{
C محاضرات فى لغة
رقم الصفحة ٣٣
int v1=5 , v2 = 10;
printf(“\n\n sum(v1,v2) = % d”,sum(v1,v2);
printf(“\n\n mul(v1,v2) = % d”,mul(v1,v2);
}
ملاحظات على البرنامج :-
ووظيفته استبدال sum لتعريف ماكرو بالاسم define - فى السطر رقم 2 استخدمنا كلمة
a+b بالصور a,b المتغيرين
x*y بنتيجه الضرب x,y - كذلك فى السطر رقم 3 يستبدل المتغيرين
- ومعناها كلما قبل المترجم اللغة الطرف الأول للماكرو يستبدله بالطرف الثانى
يمكن استبدالهما بأى متغيرين أو قيمتين داخل البرنامج. واسم a,b ملاحظ ھامة : المتغيرين
الماكرو هو الذى يحدد العملية التى يقوم بها الماكرو ( هل هى عملية جمع أم ضرب أم ….. بناء على
المعادلة الموجودة فى الطرف الأيمن من الماكرو )
* الفرق بین الماكرو وبین الدالة :- اى برنامج يمر بثلاث مراحل :-
.C ويخصص لملف المصدر الامتداد source code المرحلة الأولى : كتابة وهذا يسمى
compilation المرحلة الثانیة : ترجمة البرنامج للغة يفهمها الحاسب وتسمى هذه المرحلة
.obj ويخصص للملف الامتداد
بمكتبات اللغة ليصبح قابل للتنفيذ وتسمى هذه العملية object المرحلة الثالثة : ربط الملف ال
.exe ويخصص لهذا الملف الإمتداد linking
ومن خلال هذه المراحل تستطيع ان تستخرج الفرق بين الماكرو وبين الدالة كما يلى :-
١- فى مرحلة الكتابة ايس هناك فرق بين الماكرو وبين الدالة.
وتنتظر object يتم تحويل تعليمات الدالة الى لغة الآلة compilation ٢- فى مرحلة الترجمة
ولا تنفذ الدالة إلا فى مرحلة الربط linking وحدة الربط
٣- اما فى حالة الماكرو يتم استبدال الماكرو بنتيجة تنفيذ الماكرو
( فى التمرين السابق يتم استبدال الماكرو الموجود فى السطر رقم 7 بنتيجة التنفيذ مباشرة . اى يتم
وبالتالى عندما تاتى مرحلة التنفيذ sum(v1,v وضع القيمة 15 وهى نتيجة تنفيذ الماكرو مكان ( 2
( يجد البرنامج نتيجة تنفيذ الماكرو جاهز وهى 15
مزايا الماكرو :- \
١- بسيط فى الإنشاء
٢- بسيط فى الاستعمال ويعطى فى النهاية ملف تنفيذى أصغر
٣- إذا كانت العملية المطلوبة بسيطة ويمكن كتابتها فى سطر واحد نستعمل الماكرو.
تمرين :
C محاضرات فى لغة
رقم الصفحة ٣٤
# include<stdio.h>
# define pi 3.14159
main ( )
{
float area(float);
float radius;
printf(“enter radius sphers : “);
scanf(“%f”, &radius):
printf(“area of sphere is 2f”,area(radius));
}/
* returns ares of sphere */
float area(rad)
float rad;
{
return(4*pi*rad*rad);
}
ARRAYS المصفوفات
مقدمة *
وتسمى هذه float وبيانات حقيقة int وبيانات رقمية char تنقسم البيانات الى بيانات حرفية
بالأنواع الرئيسية للبيانات حيث لا يمكن تجزئتها أقل من ذلك. ( int , float , char ) الأنواع
من هذه النواع ( Type dived data ) وهناك انواع أخرى من البينات تسمى بالأنواع المشتقة
.arrays المصفوفات
** المصفوفة **
هى مجموعة من البيانات التى تتشابه فى النوع ولها اسم مشترك. تتشابه فى النوع array المصفوفة
او اعداد ذات علامة int بمعنى أن تكون البينات التى تخزنها فى المصفوفة كلها اعداد صحيحة
فيمكن ان نضع المصفوفة من اى نوع من انواع البيانات. . float عشرية
*الإعلان عن المصفوفة * للإعلان عن إحدى المصفوفات هناك ثلاثة أشياء يجب ان تحددها.
١) اسم المصفوفة : وهو اسم تختاره مثلما تختار اسم أى متغير )
٢) عدد العناصر داخلها )
٣) نوع البيانات المستخدم فيها )
C محاضرات فى لغة
رقم الصفحة ٣٥
مثلاً : نفرض أنك تريد تخزين مرتبات 120 موظفاً يعملون فى شركتك وكانت مرتبات هؤلاء الموظفين
ويتم الاعلان عن المصفوفة float تحتوى على كسور عشرية. فى هذه الحالة شيكون نوع البيانات
float salary[ كما يلى : [ 120
تنقسم المصفوفة إلى المصفوفة ذات بعد واحد ومصفوفات ذات البعدين.
** المصفوفة ذات البعد الواحد :-
وتسمى مصفوفة ذات بعد واحد لأنها تتكون من صف واحد أو عمود واحد A[ مثلا : [ 2 5 9 12 15
هو اسم المصفوفة والأرقام هى عناصر المصفوفة ويتم الإشارة إلى كل عنصر برقم A وفيها حرف
العنصر اى بترتيبه داخل المصفوفة
** الإشارة إلى عناصر المصفوفة **
- يتم ذلك بان تذكر اسم المصفوفة ثم رقم المصفوفة الذى تريد التعامل معه بين القوسين [ ]
- اى عندما ترغب فى ذكر رقم العنصر داخل المصفوفة يجب أن تبدأ العد داخل المصفوفة من صفر
وليس من 1
student - مثلاً : إذا كنت تريد وضع الرقم أو القيمة 75 فى العنصر 3 من المصفوفة المسماه
student[3] = نكتب التالى : 75
إلى أحد salary - وإذا كنت تريد ان تنقل القيمة الموجودة فى العنصر 38 من المصفوفة
a = salary[ المتغيرات نكتب التالى : [ 37
- كذلك يمكن ان تمرر القيمة الموجودة فى أحد عناصر المصفوفة الى اجراءات مكتبة التشغيل مثل
printf(“ The higest mark is %d “, student[45]);
** البرنامج التالى يعرض مثالاً عن كيفية الإعلان عن إحدى المصفوفات واستخدامها :-
# include <stdio.h>
# define max 10
void main(void)
{
float salary[max];
float average;
int count;
average = 0.0;
for(coint=0; count<max ; count++)
C محاضرات فى لغة
رقم الصفحة ٣٦
{
printf(“ please enter salary for employee %d”, count+1);
scanf(“%f”, &salary[count]);
}
printf(“\n\n salary average is : %f”, average/max);
}
ملاحظات على البرنامج :-
- هذا البرنامج يطلب من المستخدم إدخال مرتبات 10 موظفين ثم يقوم بحساب وطباعة متوسط هذه
الرواتب.
هذه المصفوفة تستخدم لتخزين float salary[max] - فى بداية البرنامج نعلن عن المصفوفة
float salary[ 10 اعداد ذات كسور عشرية وبالتالى فإن الإعلان السابق يساوى [ 10
وهو تستخدم لتخزين مجموع الرواتب حتى نتمكن من average - بعد ذلك نعلن عن المتغير
استخراج متوسطها.
لنطلب من scanf() لادخال 10 موزفين لذلك نستخدم الإجراء for - لهذا نستخدم جملة التكرار
scanf("%f ", &salary[count] المستخدم إدخال الرواتب
كما يلى average - وكلما ادخل المستخدم أحد الرواتب أضفنا قيمته الى المتغير
average += salary[count]
وفى نفس الوقت for كعداد لتكرار count الملاجظة الھامة : هى كيف استخدمنا المتغير
ففى بداية Scanf(“%f”, salary[couny]) . استخدمناه للإشارة للعناصر المختلفة داخل المصفوفة
يساوى الصفر count التكرار سيكون المتغير
** تھیئة المصفوفة عند الإعلان عنھا **
- من الممكن ان تقوم بتهيئة المصفوفة عند الإعلان عنها إذا كنت تعرف مسبقا المحتويات التى
هنا نعلن عن مصفوفة مكونه من خمسه int marks[5] = { ستضعها فيها { 12 4 7 9 11
int عناصر عددية صحيحة
* المصفوفة الغیر محددة العدد **
- إذا كنت ستهيئ مصفوفة عند الاعلان عنها يمكن ان تترك للمترجم مهمة حساب عدد العناصر
فيها.
int marks[ ] = { - مثلاً : { 5 9 4 10 7
- هنا أعلنا عن المصفوفة ولكن لم نحدد عدد العناصر فيها لأن المترجم سيقوم بعَِد القيم
المذكورة بين القوسين { } ويحدد حجم المصفوفة تلقائيا .
C محاضرات فى لغة
رقم الصفحة ٣٧
** برنامج **
# include <stdio.h>
/* calculate the average of a numbers , the compute deviation of each number
about the average */
main( )
{
int n , count ;
fliat avg, d , sum=0 ;
/* read in a value for n */
printf(“\n how many numbers will be average? “;
scanf(“%d”, &n);
printf(“\n”);
/* read in the numbers and calculate ther sum */
for(count = 0 ; count < n count++ )
{
printf(“i = %d x= “, count+1);
scanf(“%f”, &list[count]);
sum+= list[count];
}/
* calcuate and write out the average */
avg = sum/n;
printf(“\n the average is %5.2f\n\n “, avg);
/* calculate and write out the deviations about the average */
for(count = 0 ; count < n ; count++)
{
d=list[count] – avg ;
C محاضرات فى لغة
رقم الصفحة ٣٨
printf(“i = %d x%5.2f d=%5.2f \n” , count+1, list[count] , d);
}}
ناتج ھذا البرنامج :-
The average is 4.18
i = 1 x = 03.00 d = -1.18
i = 2 x = -2.00 d = -6.18
i = 3 x = 12.00 d = 7.82
i = 4 x = 4.40 d = 0.22
i = 5 x = 3.50 d = -0.68
** برنامج إعادة ترتیب قائمة من الأعداد **
# include<stdio.h>
# define size 100
/* reorder a one-dimensinal, integer array from smallest to largest */
main( )
{
int i , n , x[size];
void reorder(int n , int x[ ]);
/* read in the a value for n */
printf(“\n how many number will be entered ? “ );
scanf(“%d”, &n );
printf(“\n”);
/* read in the list of number */
for(i = 0 ; i<n ; i++)
{
printf(“i = %d x = “, i+1);
scanf(“%d”, &x[ i ]);
}/
* reprder all array elements */
reorder(n , x )
/* display the reordered list of numbers */
print(“\n\reordered list of number :\n\n “);
for(i=0;i<n; i++)
printf(“i=%d x=%d\n”, i+1 , x[ i ] );
}
int i, item ,temp;
C محاضرات فى لغة
رقم الصفحة ٣٩
for(item = 0;item<n-1 ; item++ )
if(x[ i ] < x[item])
{/
* interchange twwo elements */
temp = x[item];
x[item] = x[ i ];
x[ i ] = temp ;
}
return;
}
* المصفوفة ذات البعدین :*
- هى المصفوفة التى ترتب عناصرها فى شكل صفوف وأعمدة
ومعناه أن المصفوفة ش مصفوفة ذات بعدين int a[5] [ - ويتم الإعلان عنها بالشكل التالى [ 10
5 صفوف و 10 أعمده ويتم الاشارة الى العنصر برقم الصف ورقم العمود
for ملاحظة : عند استخدام مصفوفة ذات البعدين لابد من استعمال دوارة
* إعطاء قیمة ابتدائیة للمصفوفة: يمكن إعطاء قيمة ابتدائية للمصفوفة ذات البعدين كمايلى
int a[3][4] =
{{
4,5,7,8 },
{3,2,4,5},
{7,8,9,6}
};
ملاحظة : فى هذا الشكل يأخذ العنصر رقم 0,0 القيمة 4 والعنصر رقم 0,1 القيمة 5
- تتحد القيم الأربع فى أول زوج أقواس { } داخلية لعناصر المنظومة فى الصف الأول وتتحدد القيم
الموجودة فى زوج الأقواس { } التالى لعناصر المنظومة فى الصف الثانى ٠٠٠ وهكذا
شكل آخر للمصفوفة ذا ت البعدين :
int values[3][4] = {1,2,3,4,5,6,7,8,9,,10,11,12};
ويأخذ العنصر 0,1 القيمة 2 أى values[0][ فى هذا الشكل يأخذ العنصر رقم 0,0 القيمة 1 أى [ 0
values[0][1]
مثال: على استخدام المصفوفات متعددة الأعمدة
# include <stdio.h>
# define stud 3
C محاضرات فى لغة
رقم الصفحة ٤٠
# define marks 10
void main (void)
{
int student[stud][marks];
int c1 ,c1 ;
for(c1 = 0 ; c1 < stud ; c1++)
for ( c2 = 0 ; c2 < marks ; c2++)
{
printf ( “ enter marks: %2d for student %2d : “ , c2+1 , c1+1 );
scanf (“ %d “, &student[c1][c2]);
}
for(c1 = 0 ; c1 < stud ; c1++ )
for(c2= 0 ; c2 < marks ; c2++)
printf(“ student [%2d] , marks[%2d] = %d\n “, c1+1, c2+1 , student[c1][c2]);
}
ذات البعدين student ملاحظات : فى بداية البرنامج نعلن عن المصفوفة
int student[stud][marks];
داخل بعضهم . نستخدم هذين التكرارين لطلب الدرجات من for - وبعد ذلك نستخدم تكرارين
المستخدم. التكرار الأول يستمر بعد الطلاب والتكرار الثانى بعد الدرجات.
- كذلك نستخدم تكرارين لنطبع الدرجات التى أدخلها المستخدم.
* برنامج : جمع جدولین من العداد اى نحسب مجموع العناصر المتناظرة
فى الجدولین أى نحسب
c[i][j] = a[i][j] + b[i][j]
ثم نستخرج الجدو ل الجديد محتوياً على المجموع
# include <stdio.h>
# define mrow 20
# define mcol 30
/* caluculates the sum of the elements in two tables of integers */
void main (void)
{
int mrow , mcol;
/* array definitions */
int a[mrow][mcol] , b[mcol][mcol] , c[mcol][mcol];
/* function protyotypes */
void readinput(int a[ ][mcol],int nrow , int ncol);
void computesum ( int a[ ][mcol], int b[ ][mcol] , int c[ ][mcol], int nrow ,
int ncol);
C محاضرات فى لغة
رقم الصفحة ٤١
void writeoutput ( int c[ ][mcol], int nrow , int ncol );
printf ( “ How many rows ?” );
scanf (“ %d “ , nrow);
printf ( “ How many columns ?” );
scanf (“ %d “ , ncol);
printf ( “ \n\n first table : \n” );
readinput( a, nrow , ncol );
printf ( “ \n\n second table : \n” );
readinput( b, nrow , ncol );
computsum(a, b, c, nrow, ncol);
printf ( “ \n\n sums of the elements : \n \n” );
writeoutput(c , nrow , ncol);
}
void readinput( int a[ ][mcol] , int m , int n )
/* read in a table of integers */
{
int row , col ;
for(row = 0 ; row < m ; row ++ )
{
printf\n enter data for row no. %2d \n “ , row+1 );
for( col = 0 ; col < n ; col++)
scanf(“ %d “, &a[row[col]):
}
return;
}
void computsum(int a[ ][mcol] , int b[ ][mcol] , int c[ ][mcol] , int m ,int n )
/* add the elements of two integer tables */
{
int row, col ;
for(row = 0 ; row < m ; row++)
for(col = 0 ; col < n ; col++)
c[row][col] = a[row][col] + b[row][col];
return;
}
void writeoutput(int a[ ] [mcol] , int m , int n )
/* write out a table of integers */
{
C محاضرات فى لغة
رقم الصفحة ٤٢
int roe , col ;
for (row = 0 ; row <m ; row ++)
{
for(col = 0 ; col < n ; col ++)
printf(“%4d “, a[row][col]):
printf(“\n”;
}
return;
}
ملاحظات :
مصفوفة ثنائية الأبعاد ولكل منها نفس عدد الصفوف ونفس عدد العمدة a ,b ,c -
متغير صحيح يحدد العدد الفعلى للصفوف فى كل جدول. row -
متغير صحيح يحدد العدد الفعلى للأعمدة فى كل جدول ncol -
عداد صحيح يحدد رقم الصف row -
عداد صحيح رقم العمود col -
* أفرضا ن البرنامج استخدم فى جمع الجدولین الاتى :-
الجدول الأول الجدول الثانى
10 11 12 13 1 2 3 4
14 15 16 17 5 6 7 8
18 19 20 21 9 10 11 12
والاتى تنفیذ البرنامج :-
how many rows? 3
how many columns? 4
first table :
enter data for row no. 1
1 2 3 4
enter data for row no. 2
5 6 7 8
enter data for rpw no. 3
9 10 11 12
second tables :
enter data for row no. 1
10 11 12 13
enter data for row no. 2
14 15 16 17
enter data for row no. 3
C محاضرات فى لغة
رقم الصفحة ٤٣
18 19 20 21
suns if the elements :
11 13 15 17
19 21 23 25
16 19 31 33
( array of string * سلاسل الحروف * ( مصفوفة العبارة الحرفیة
string تستخدم كلمة سلسلة حروف مقابل لكلمة
* الإعلان عن سلاسل الحرو ف *
- عندما ترغب فى استخدام مصفوفة حروف فأنك تعلن عنها كما تعلن عن بقية المصفوفات الأخرى
char name[ نكتب التالى : [ 80 char ** وللأعلان عن نوع البيانات
تفترض ان المصفوفة تنتهى c التى تتسع ل ٧٩ حرف ( لأن لغة name - هنا نعلن عن المصفوفة
(null) بحرف الصفر
char name[ ] = "ali ahmed" ** شكل آخر للأعلان
- هنا سوف يقوم المترجم بعد الحروف وتحديد حجم المصفوفة وتهيئتها بالحروف المذكورة
** استخدام مصفوفة الحرو ف :-
- بعد أن تنتهى من الإعلان عن مصفوفة الحروف . يمكنك البدء فى استخدامها
أو printf - كذلك يمكن ان تمرر اسم المصفوفة الى أحد اجراءات مكتبة التشغيل مث ل الاجراء
أو غيرها. ويمكنك أيضا الكتابة الى أى حرف داخلها أو قراءة الحرف فيها ووضعها فى gets
متغيرات أخرى
** والبرنامج التالى يوضح استخدام مصفوفات الحرو ف :-
# include<stdio.h?
C محاضرات فى لغة
رقم الصفحة ٤٤
void main(void)
{
char namr[80]
printf(“place enter your name : “);
gets(name);
printf(“welcome , %s “, name);
}
* ملاحظات :
ليقرأ اسم gets ثم نستخدم الاجراء name - فى هذا البرنامج يعلن عن مصفوفة الحروف
المستخدم من لوحة المفاتيح ثم يخزن الحروف التى أدخلها المستخدم فى المصفوفة
name[0] = 'a' - إذا رغبت أن تتعامل مع كل حرف من حروف المصفوفة على حدة اكتب التالى
- إذا اردت ان تنقل القيمة الموجودة فى أحد الحروف فى المصفوفة الى أحد المتغيرات الأخرى
ss = name[ نكتب ;[ 15
** مصفوفة الحرو ف تنتھى بالرقم صفر **
( null ) يجب ان تلاحظ ان مصفوفة الحروف يجب ان تنتهى بالرقم صفر
* برنامج *
# include <stdio.h>
void main(void)
{
char strin[ ] = “hello”;
printf(“character array = %s , its length = %d \n, strin , sizeof(string));
}
* ملاحظات :
string - فى هذا البرنامج نعلن عن مصفوفة باسم
char string[ ] = "hello” كما يلى hello - نطلب من المترجم ان يهيئها بان يضع فيها كلمة
ليطبع محتويات هذه المصفوفة printf - بعد ذلك نستخدم الاجراء
لنحصل على حجم هذه المصفوفة ونطبعه يكون الناتج sizeof - استخدام كلمة
character array = hello its length = 6
hello - لاحظ ان حجم المصفوفة هو 6 حروف فى حين اننا وضعنا فيها 5 فقط وهى الحروف
- السبب : هو أن مصفوفة الحروف تنتهى دائماص بالرقم صفر الذى يستخدم كدلالة على نهايتها
كما فى الشكل :
1 2 3 4 5 6
h e l l o \0
** لكى نتأكد من هذه النقطة انظر البرنامج التالى :-
C محاضرات فى لغة
رقم الصفحة ٤٥
# include<stdio.h>
void main(void)
{
int count;
char string[ ] = “ hello “
for(count = 0 ; count < sizeof(string); count ++)
printf(“ string[%d] = =%d %c \n “, count, string[count], string[count]);
}
لنطبع محتويات كل for ثم نستخدم تكرار string - فى هذا البرنامج نعلن عن مصفوفة الحروف
حرف فيها
Count < sizeof(string) . - لاحظ شرط استمرار التكرار
وفى كل string - سيؤدى هذا الشرط الى استمرار التكرار بعدد الحروف الموجود فى المصفوفة
مرة يعمل فيها التكرار نطبع الحرف الموجود فى المصفوفة كحرف وكرقم فى جدول آسكى كما فى
الشكل التالى :-
String[ 0 ] = 104 h String[ 1 ] = 101 e
String[ 2 ] = 108 l String[ 3 ] = 108 l
String[ 4 ] = 111 o String[ 5 ] = 0
لاحظ كيف يعرف البرنامج الحرف السادس فى المصفوفة على أنه = صفراً
** بعضالاجراءا ت التى تتعامل مع مصفوفات الحرو ف **
هناك العديد من اجراءات مكتبة التشغيل التى تسهل التعامل مع مصفوفات الحروف
١) معرف عدد الحروف فى المصفوفة :- )
يعود strlen - إذا اردت ان تعرف عدد الحروف الموجودة فى أى مصفوفة حروف استخدم الاجراء
بعدد الحروف الفعلية الموجودة فى المصفوفة بدون عد اصفر الموجود فى نهايتها
len = strlen("count this string " ) - مثلا
٢) نسخ مصفوفة حروف الى اخرى :- )
بنقل محتويات مصفوفة حروف الى اخرى مباشرة . c - لا تسمح لك لغة ال
سيقوم الاجراء strcpy ( string1 , string يستخدم كما يلى : ( 2 strcpy - هناك الاجراء
string الى المصفوفة 1 string بنسخ محتويات المصفوفة 2
لنسخ مجموعة احرف الى مصفوفة اخرى . strcpy - ويمكن ان نستخدم الاجراء
هنا سيقوم المترجم بوضع الجملة المذكورة strcpy( string , " hello my string "); - مثلاً
string فى المصفوفة
- كذلك يجب أن نتأكد أن المصفوفة التى ستنقل إليها الحروف تتسع لكل الحروف الموجودة فى
لا يتأكد من ذلك. strcpy المصفوفة الأخرى لأن الاجراء
C محاضرات فى لغة
رقم الصفحة ٤٦
٣) دمج محتویات مصفوفتى حروف :- )
سيضيف الاجراء strcat(string1 , string كما يلى: ( 2 strcat - لعمل ذلك استخدم الاجراء
string الى محتويات المصفوفة 1 string محتويات المصفوفة 2 srcat
string تتسع لكل الحروف الموجودة فى المصفوفة 2 string - هنا يجب أن نتأكد أن المصفوفة 1
بالإضافة الى الحروف التى كانت أصلا موجودة
# include < stdio.h>
void main(void)
{
char string1[20] = “learning c “;
char string2[ ] = “ is easy “;
strcat(string1 , string2 );
printf(string1);
}
learning c is easy : الناتج
٤) مقارنة محتویات مصفوفتین : )
- من الممكن ايضا ان تقارن محتويات مصفوفتين من الحروف
وله الصيغة التالية: strcmp - لعمل ذلك استخدم الاجراء
result = strcmp(string1 , string2 );
result محتويات المصفوفتين ويضع ناتج المقارنة فى المتغير strcmp - سيقارن الاجراء
- إذا كانت المصفوفتان متطابقتين ( اى يحتويان على نفس مجموعة الحروف ) يكون المتغير
فى هذه الحالة يساوى صفراً result
يحتوى على نتيجة بخلاف الصفر result - وإذا كانت المصفوفتان مختلفتين فإن المتغير
-: strcmp * البرنامج التالى يعطى مثالاً على استخدام الاجراء
# include < stdio.h>
# include <string.h>
void main(void)
{
char string1[80];
char string2[80];
int result;
printf(“ enter the first string “);
gets(string1);
printf(“ enter the second string : “);
gets(string2);
result = strcmp(string1,string2);
if(result == 0 )
printf(“the two string are identical : );
else
printf(“the two string are different : );
C محاضرات فى لغة
رقم الصفحة ٤٧
}
ملاحظات :
ليقلرن strcmp - فى هذا البرنامج سيطلب من المستخدم غدخال عبارتين ثم يستخدم الاجراء
بينهما ويعرض نتيجة المقارنة
ليقارن بين محتويات مصفوفة حروف ومجموعة strcmp - ويمكن ايضا ان تستخدم الاجراء
result = strcmp(string1,string حروف مثل ;( 2
* برنامج عام *
لاستخدام الاجراءا ت المختلفة التى تتعامل معھا مصفوفة الحرو ف
# include < stdio.h>
# include < string.h>
void main(void)
{
char string1[80];
char string2[80];
int result , choice;
printf(“ enter the first string : “ );
gets(strig1);
printf(“enter the second string : “ );
gets(strung2);
printf(“\n enter the function you want: \n “
“1- strcpy \n “
“2- strcat \n “
“3- strcmp \n”);
printf(“enter you choice : );
scanf(“%d “ , &choice);
switch(choice)
{
case 1:
printf(\n copy second string to first \n”);
strcpy(string1 , string2 );
printf(string1);
break;
case 2:
printf(\n merging the two string \n”);
strcat(string1 , string2 );
C محاضرات فى لغة
رقم الصفحة ٤٨
printf(string1);
break;
case 3:
printf(“\n comparing the two strings \n “);
result = strcmp(string1,string2);
if(result == 0 )
printf( “ the two strimg are identical “);
else
printf( “ the two strimg are different “);
break;
default :
printf(“plase enter a number 1-3 “ );
}}
** تمرير مصفوفة الى الاجراءا ت **
- من الاستخدامات المفيدة للمصفوفات سواء المصفوفات العادية أو مصفوفات الحروف هو ان
تتمكن من تمريرها الى بعض الاجراءات التى تكتبها
- عندما ترغب فى تمرير إحدى المصفوفات الى اجراء يجب ان تعلن عن الاجراء بحيث تخبر
هنا تخبر void fn(int num[ ] ); المترجم انه سيتلقى مصفوفة وليس متغيراً عادياً مثل
بعد ذلك عندما ترغب فى تمرير int سيتلقى مصفوفة من نوع fn المترجم ان الاجراء
fn(num); المصفوفة اى الاجراء أذكر اسم المفوفة فقط كما يلى
* البرنامج التالى :-
يعطى مثالاً على كیفیة تمیر مصفوفة حرو ف الى احد الاجراءا ت :-
# include < stdio.h>
# include <ctype.h>
# include <string.h>
void changetoupper(char string[ ] );
void main(void)
{
char string[80];
do
{
printf(“ enter a string to change to upper “ case \n enter \ “quit \ “to exit”);
gets(string);
changetoupper(string);
}
while(strcmp(string , “quit”));
}
C محاضرات فى لغة
رقم الصفحة ٤٩
void changetoupper(char string[ ] )
{
unsigned int count;
for(counr = 0 ; count < strlen(string); count++)
printf(“%c” , toupper(string[count]));
printf(“\n\n”);
}
ملاحظات :
- هذا البرنامج يطلب من المستخدم ان يدخل مجموعة حروف ثم يحولها الى حروف كبيرة
ويستمر فى طلب مجموعات الحروف حتى do….while - عندما يبدا البرنامج يدخل فى تكرار
وعندها يخرج من التكرار quit يدخل المستخدم كلمة
ونمرر له changetoupper - فى كل مرة يدخل المستخدم مجموعة حروف تستدعى الاجراء
مصفوفة الحروف التى أدخلها المستخدم ليطبعها بالحرف الكبيرة.
أولاً ثم نمرر الحرف الذى يعود به الى الإجراء toupper - هنا تستدعى الإجراء
printf(“%c” , toupper(string[count])); ليطبعه printf
string functions ** ب ع ض دولا العبارا ت لاح رف یة
الدالة وظیفتها
اضافة سلسلة حرفية ( كلمة ) الى نهاية سلسلة حرفية اخرى ( كلمة اخرى ) strcat( )
ايجاد ترتيب موضع حرف معين داخل كلمة strchr( )
مقارنة كلمتين ( او متغيرين من نوع حرفى) strcmp( )
نسخ محتويات متغير حرفى فى متغير حرفى آخر strcpy( )
ايجاد عدد حروف سلسة حرفية strlen( )
تحويل كلمة من الحروف الصفير الى الحروف الكبيرة strupr( )
** ب ع ض دولا للتحويل من متغیر رقمى الى حرفىو العكس :-
الدالة وظیفتها
تحويل متغير من نوع حرفى الى متغير من نوع رقم حقيقى atof
تحويل متغير من نوع حرفى الى متغير من نوع رقم صحيح Atoi
تحويل متغير من نوع حرفى الى متغير من نوع رقم صحيح طويل Atol
تحويل متغير من نوع حرفى الى متغير من نوع رقم حقيق مضاعق Strtod
تحويل متغير من نوع صحيح الى متغير من نوع حرف _itoa
تحويل متغير من نوع رقم طويل الى متغير حرفى _ltoa
C محاضرات فى لغة
رقم الصفحة ٥٠
Structure ( التركیب (المنشات
معناه ان تضع مجموعة من البيانات التى تختلف فى النوع معاً. structure معناه : التركيب
بحيث يمكن التعامل معها كوحدة واحدة أو يمكن التعامل مع العناصر المفردة داخلها.
- ومن اهم التطبيقات فى عالم البرامج ( تطبيقات قواعد البيانات ). فمثلا لكتابة برنامج تسجيل
بيانات الموظفين فى الشركة التى تعمل فى هذه الحالة انت تحتاج الى تخزين :
( char اسم الموظف وعنوان ( سلسلة حروف من نوع ·
( int سن الموظف ( عدد صحيح ·
( float راتب الموظف ( عدد ذو علامة عشرية ·
يضم هذه العناصر سوياً كوحدة واحدة. وبعد ذلك سوف structure فى هذه الحالة نقوم بعمل تركيب
نتمكن من التعامل مع هذه البيانات المختلفة كوحدة واحدة او نتعامل مع كل عنصر فيها على حدة
* الاعلان عن التركیب :-
- عندما ترغب فى الاعلان عن تركيب جديد أتبع الصيغة التالية :-
struct اسم التركيب
{
--------------;
--------------;
--------------;
};
C من الكلمات الاساسية فى لغة struct وكلمة
إذا رغبت فى عمل تركيب ليحمل بيانات الموظفين :- ·
struct employee
{
char name[40];
مجموعة البيانات التى يتكون منها التركيب
C محاضرات فى لغة
رقم الصفحة ٥١
char address[40];
int age;
float salary;
};
يعتبر ( وصفه ) نعطيها للمترجم حتى يتعرف على نوع التركيب وحجمه employee - التركيب
- عندما ترغب فى استخدام التركيب فعلاً يجب ان تعلن عن متغير من نفس النوع مثل:
struct employee emp1;
وسيقوم المترجم بحجز الذاكرة له حسب ( الوصفة ) السابقة وبالتالى emp - أصبح لدينا المتغير 1
86 ويتكون من اربعة عناصر هى :- byte يساوى emp سيكون حجم 1
( 4 byte) 2 ) * المرتب byte) 40 ) * العمر byte) 40 ) * العنوان byte) * الاسم
* استخدام التركیب :-
- للتعامل مع اى عنصر داخل التركيب أذكر اسم التركيب ثم حرف النقطة ثم اسم العنصر داخل التركيب
emp1.age : مثلاً
الموجود فى التركيب نكتب التالى : age - وإذا أردت ان تضع الرقم 30 فى المتغير
emp1.age=30;
a.emp1.salary; : - كذلك إذا أردت ان تنقل القيمة الموجودة فى العنصر الى متغير آخر اكتب
- كذلك يمكن ان تمرر عناصر التركيب إلى إجراءات مكتبة التشغيل كما نفعل مع المتغيرات الأخرى
ليقرأ سلسلة حروف من لوحة gets هنا نستدعى الإجراء gets(emp1.name); : مثل
emp الموجود داخل التركيب 1 name المفاتيح ويضعها فى المتغير
* البرنامج التالى يوضح كیفیة الإعلان عن التركیبات واستخدامھا :-
# include <stdio.h>
void main(void)
{
struct employee
{
char name[40];
char address[40];
int age;
float salary;
}
struct employee emp1;
printf(“ enter name :”);
gets(emp1.name);
printf(“enter address: “);
gets(emp1.address);
printf(“ enter age : “);
scanf(“%d”, &emp1.age);
C محاضرات فى لغة
رقم الصفحة ٥٢
pruntf(“enter salary : “ );
scanf(“%d”,&emp1.salary);
printf(“\n\n you entered: \n “;
printf(“ employee name :\t%s\n “, emp1.name);
printf(“ employee address :\t%s\n “, emp1.address);
printf(“ employee age :\t%d\n “, emp1.age);
printf(“ employee salary :\t%f\n “, emp1.salary);
}
* مصفوفات من التركیبات *
- لكى نعلن عن مصفوفة من التركيبات يجب أن تعلن عن التركيب أولاً ثم نعلن عن المصفوفة
- مثلاً لو أردنا تخزين 100 موظف
struct employee
{
char namr[40];
char address[40];
int age;
float salary;
};
struct employee emp[100]
التى تتسع لتخزين معلومات emp ثم اعلنا عن المصفوفة employee - هنا اعلانا عن التركيب
عن 100 موظف
- بعد ذلك عند التعامل مع احد التركيبات فى المصفوفة فأنك تذكر رقمه داخل المصفوفة أولاً.
emp[4].age= - فمثلاً إذا أردنا ان تدخل بيانات الموظف الخامس فى المصفوفة نكتب ; 35
هنا نشير الى رقم التركيب داخل المصفوفة باستخدام emp[count].salary = - كذلك 123.5
count المتغير
* البرنامج الآتي يعطى مثالاً على كیفیة إنشاء مصفوفة من التركیبات
والتعامل مع العناصر المختلفة فیھا :-
#inclide<stdio.h>
#include<string.h>
#include<stdlib.h>
#define max عدد الكتب // 10
void main(void)
C محاضرات فى لغة
رقم الصفحة ٥٣
{
struct booktag
{
char title[40];
char author[40];
int pages;
int year;
char edition;
};
struct bootag book[max]; // مصفوفة الكتب
int c ,c1 , result;
char temp[10];
أبدأ فى استقبال المعلومات من المستخدم //
for(c = 0 ; c < max ; c++)
{
printf(“ enter data for record no[%d]\n “m c+1);
printf(“ or enter \ “ quit \ “ to end \n\n”;
printf”enter title : “ );
gets(boo[c].title);
إذا كتب المستخدم كلمة (خروج) فإننا نخرج من التكرار */
result = strcmp (book[c].title,”quit”);
if (result = = 0 )
break;
printf(“enter author : “);
gets(book[c].author);
printf(“enter number of pages : “ );
gets(temp);
book[c].pages = atoi(temp);
printf(“enter year of publication : “ );
gets(temp);
book[c].year = atoi(temp);
printf(“enter edition : “ );
gets(temp);
book[c].edition = atoi(temp);
}
اطبع المعلومات //
printf(“record no. %d\n:, c1++);
printf(“book title : \t\%\n “, book[c1].title);
printf(“ book author : \t%d\n”, book[c1].author);
printf(“no of pages :\t%d \n “, book[c1].pages);
printf(“date of pub. \t%d\n”,book[c1].year);
printf(“edition : \t%d\n\n “,book[c1].edition);
}
C محاضرات فى لغة
رقم الصفحة ٥٤
** ملاحظات على البرنامج **
تستخدم لتخزين المعلومات عن الكتب فى مكتبة ما book - هذا البرنامج ينشئ مصفوفة باسم
- البرنامج يتوقف ليسأل المستخدم عن المعلومات الخاصة بكل كتاب ثم تخزن هذه المعلومات فى
المصفوفة ثم طباعة هذه المعلومات
الذى سيستخدم لحمل بيانات الكتب booktag - فى بداية البرنامج نعلن عن التركيب
- هذا التركيب يتكون من خمسة عناصر هى :-
* العنوان * المؤلف * عدد الصفحات * سنة النشر * الطبعة
struct booktag boo[max] - بعد ذلك نعلن عن مصفوفة مكونة من 10 تركيبات
لإدخال المعلومات الخاصة بالكتب من المستخدم ويستمر ذلك حتى for - بعد ذلك نستخدم التكرار
للخروج بدلاً من عنوان الكتاب quit يدخل المستخدم معلومات خاصة ب 10 كتب او يدخل كلمة
فغن ادخل هذه quit - لذلك عندما نطلب من المستخدم غدخال عنوان الكتب نقارن ما ادخله بكلمة
لنخرج من التكرار break الكلمة فإننا نستخدم كلمة
result = strcmp(book[c].title , “quit”);
if(result = = 0
break;
فإذا كانا متطابقين فإن الإجراء quit ليقارن العنوان بكلمة strcmp - فهنا نستدعى الإجراء
fot وبذلك نخرج من التكرار result سيعود بالقيمة صفر ويضعها فى المتغير strcmp
** تمرير التركیب إلى الإجراءا ت**
من الممكن أن نمرر التركيبات الى الإجراءات. والبرنامج التالى يوضح ذلك :-
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct studenttag
{
char name[40];
int age;
int grade;
}
void print(struct stdenttag student);
void main(void)
{
struct studenttag student;
char temp[10];
printf(“enter student namr : “);
gets(student.name)
printf(“enter student age : “ );
gets(temp);
student.age=atoi(temp);
C محاضرات فى لغة
رقم الصفحة ٥٥
printf(“enter student grade : “ );
gets(temp);
student.grade = atoi(temp);
printf(“\n\n you entered: \n\n”);
استدعاء الاجراء الذى يطبع محتويات الكتب //
printf(student);
}
الاجراء الذى يطبع محتويات الكتب //
void print(struct studenttag student)
{
printf(“student name : \t%s\n “, student.name);
printf(“student age : \t%d \n “, student.age);
printf(“student grade :\t %d\n “, student.grade);
}
* ملاحظات *
- فى هذا البرنامج نكلب من المستخدم بعض المعلومات عن أحد الطلبة ثم نضعها فى تركيب الى
ليطبع محتوياته print الاجراء
الذى سيستخدم لتخزين المعلومات . studenttag - فى بداية البرنامج نعلن عن التركيب
- وهو يتكون من ثلاثة عناصر :- * اسم الطالب * وعمره * ومرحلته
الذى سيطبع محتويات التركيب print - لاحظ كيف أعلنا عن الاجراء الفرعى
void print(struct studenttag student)
print(student); - كذلك كيف نستدعى الإجراء
** تلاحظ انك عندما تمرر تركيباً إلى أحد الاجراءات فإن هذا الإجراء يتلقى ( نسخة ) من هذا التركيب
فقط ولا يتلقى التركيب الأصلي. لذلك إذا غيرت الإجراء فى محتويات التركيب فإنه سيغير
فى محتويات النسخة ولن تؤثر ذلك فى التركيب الأصلى.
** برنامج **
تمرير التركيبات الى الاجراءات والعودة بتركيب من الاجراء //
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct sudenttag
{
char name[40];
int age;
int grade;
};
C محاضرات فى لغة
رقم الصفحة ٥٦
void print(struct studenttag student);
struct studenttag detinfo(void)
void main(void)
{
struct studenttag student;
student = getinfo( );
print(student);
}
الاجراء الذى يطبع محتويات التركيب //
void print(sturct studenttag student)
{
printf(“\n\n you entedred : \n\n “);
printf(“student name: \t%s\n”,student.name);
printf(“sudent age: \t%d\n”,student.age);
printf(“student grade : \t%d\n”,student.grade);
}
الاجراء الذى يطلب المعلومات من المستخدم ويضعها فى التركيب //
struct studenttag getinfo(void)
{
sturct studenttag student;
char temp[10];
printf(“enter student name : “ );
gets(student.name);
printf(“enter student age : “ );
gets(temp);
student.age = atoi)temp);
printf(“enter student grade : “ );
gets(temp);
student.grade = atoi(temp);
return(student);
}
ملاحظات :
هذا الاجراء getinfo - هذا البرنامج يشبه البرنامج السابق ولكن يزيد عليه أننا وضعنا الاجراء
main يطلب المعلومات من المستخدم ويعود بها الى الاجراء
C محاضرات فى لغة
رقم الصفحة ٥٧
- لاحظ كيف اعلنا عنه فى بداية البرنامج
struct studenttag detinfo(void)
وانه يعود void لا يستقبل اى بيانات وذلك بسبب كلمة getinfo - هذا الإعلان معناه أن الإجراء
studenttag بقيمة إلى من يستدعيه. وهذه القيمة هى تركيب من نوع
وهذا الاجراء يطلب student = getinfo وهو main من الاجراء getinfo - لاحظ كيف نستدعى
return(student); المعلومات من المستخدم وعندما ينتهى
بالمعلومات التى حصل عليها من المستخدم الى الاجراء getinfo - بهذا الشكل سيعود الاجراء
بعد ذلك main وسوف يقوم الاجراء student الذى يستقبل ويضعها فى التركيب main
ليطبع محتوياته print بتمرير نفس هذا الترتيب الى الاجراء
** تركیب داخل تركیب **
- من الممكن ان تضع تركيباً داخل تركيب آخر . فمثلا إذا كنت تريد وضع تركيب لك ل قسم من
فى داخل تركيب القسم لتخزن فيه employee الأقسام فى الشركة . من الممكن أن تضع التركيب
المعلومات الخاصة بالموظف المسئول عن القسم
أولاً employee - فى هذه الحالة يجب أن تعلن عن التركيب
struct employee
{
char name[40];
char address[40];
int age;
float salary;
}
- وبعد ذلك نعلن عن التركيب الأخر ونضعه فيه مثل :-
struct dept
{
int deno;
int product;
sturct employee emp;
}
dept فى داخل التركيب emp - لاحظ كيف وضعنا التركيب
struct dept dept كما سبق مثل ; 1 dept - بعد ذلك يمكن ان نعلن عن التركيب
dept1.emp.age = - فى حالة التعامل مع عنصر داخل تركيب فرعى اكتب : 25
اسم التركيب الرئيسى ثم نقطه dept حيث 1
اسم التركيب الفرعى ثم نقطه emp
اسم العنصر داخل التركيب الفرعى age
C محاضرات فى لغة
رقم الصفحة ٥٨
** برنامج **
#include<stdio.h>
#include<stdlib.h>
struct employee
{
char name[40];
char address[40];
int age;
float salary;
};
struct department
{
int depnum;
char product[40];
struct employee emp;
};
void main(void)
{
struct deparment dept;
char temp[10];
printf(“enter dept no : “ );
gets(temp);
dept.deptnum = atoi(temp);
printf(“enter dep. Product : “ );
gets(dept.product);
prints(“enter employee name : “ );
gets(dept.emp.name);
printf(enter employee address” );
gets(dept.emp.address);
printf(“enter employee age : “ );
gets(temp);
dept.emp.age = atoi(temp);
printf(“enter employee salary : “ );
gets(temp);
dept.emp.salary = atof(temp)
printf(“\n\n you entered \n\n “ );
printf(“dept no : \t\t%d\n “,dept.deptnum);
printf(“dept product : \t\t%s\n “,dept.product);
printf(“employee address : \t\t%d\n”, dept.emp.address);
C محاضرات فى لغة
رقم الصفحة ٥٩
printf(“employee age : \t\t%d\n”,dept.emp.age);
printf(“employee salary: \t\t%f”,dept.emp.salary);
}
ملاحظات :-
أولا employee - فى بداية البرنامج نعلن عن التركيب
employee ونضع داخله التركيب department - ثم نعلن عن التركيب
- لاحظ كيف نتعامل مع عناصر التركيب الفرعى فعندما نطلب من المستخدم إدخال اسم الموظف ،
الموجودة فى التركيب الفرعى name ونمرر له مصفوفه الحروف gets فإننا نستخدم الإجراء
gets(dept.emp.name); : كمايلى emp
لطبع المعلومات على printf - بعد ان ينتهى المستخدم من ادخال جميع المعلومات نستخدم الاجراء
الشاشة.
** تنويعات فى الإعلان عن التركیبات **
* فى جميع الأمثلة السابقة ذكرنا خطوتين للإعلان عن التركيب :-
- الأولى : ان نعلن عن التركيب نفسه مثل:-
struct enployee
{
char name[40];
char address[40];
int age;
float salary;
};
- الثانیة : ان نعلن عن متغير عن هذا التركيب مثل :-
struct employee emp;
*ملاحظة :- يمكن دمج الخطوتين السابقتين معاً . فتعلن عن بنيه التركيب وعن متغير فيه فى
خطوة واحدة مثل :-
struct employee
{
char name[40];
char address[40];
int age;
float salary;
} emp;
بين القوس { وبين الفاصلة المنقوطة وسيكون لها نفس تأثير emp - لاحظ كيف تم وضع كلمة
struct employee emp; العبارة
- كذلك يمكن استخدام نفس الطريقة السابقة عن عدة تركيبات من نفس النوع
struct employee
{
C محاضرات فى لغة
رقم الصفحة ٦٠
char name[40];
char address[40];
int age;
float salary;
} emp1 , emp2 , emp3;
- يمكن الاعلان عن تركيب واحد أو عدة تركيبات مع الاستغناء عن اسم التركيب
struct
{
char name[40];
char address[40];
int age;
float salary;
} emp;
- كذلك يمكن ان تضع المعلومات فى التركيب عند الاعلان عنه مباشرة مثل :-
struct
{
char name[40];
char address[40];
int age;
float salary;
} emp = {
“ali ahmed”
“26 st. cairo “
39
135.6
};
C محاضرات فى لغة
رقم الصفحة ٦١
pointer المؤشرات
- : pointer *معنى المؤشر
- هو نوع من انواع البيانات . ويعرف بانه متغير يحتفظ ( يخزن به ) بعنوان مكان فى الذاكرة . أى
هو( متغير يستخدم ليحمل عنوان متغير آخر فى الذاكرة )
- اى أن المؤشر يشير إلى مكان فى الذاكرة.
- من المعلوم أن كل مكان فى الذاكرة له عنوان والجهاز يتعامل مع هذا المكان بالعنوان المحدد له
ونحن بطريقه غير مباشرة نتعامل مع هذا العنوان .
2 واجعل byte حجمه ram معناه احجز مكان فى الذاكرة int d = - فمثلا فى هذا الاعلان ; 5
وضع فيه القيمة 5 d اسمه
- عندما ترغب فى استخدام المؤشرات هناك خطوتان :-
الأولى : أن تعلن عن هذا المؤشر وتخبر المترجم عن اسمه وعن نوعيه البيانات التى تشير ·
إليها.
الثانية : تهيئ هذا المؤشر بأن تجعله يشير إلى احد المتغيرات الفعلية ·
** الإعلان عن المؤشر **
- عندما ترغب فى استخدام المؤشر يجب ان تعلن عنه اولاً كما نفعل مع بقية المتغيرات ( أي يتم
الإعلان عن مؤشر إلى اى متغير من انواع البيانات بنفس الطريقة التى تعلن بها عن البيانات
العادية )
- وعندما ترغب فى الإعلان عن مؤشر يجب ان نحدد شيئيين :-
الأول : هو اسم المؤشر ويتم اختيارة كما نختار المتغيرات العادية
الثانیة : هو نوعية البيانات التى سيشير إليها
int * p;
C محاضرات فى لغة
رقم الصفحة ٦٢
أصبح مؤشراص الى مساحة فى الذاكرة مقدارها 2 p - هذا الإعلان يخبر المترجم أن المتغير
p مع الاحتفاظ بعنوان هذا المكان فى المتغير byte
float * degree;
وان هذا المؤشر سيشير إلى بيانات degress - هذا الاعلان يخبر المترجم أننا نريد استخدام المؤشر
float من نوع
- وإذا كنت ستستخدم المؤشر ليشير إلى تركيب يجب أن تعلن عن التركيب أولاً . مثل :
struct student
{
char name[40];
int mark;
}
ثم نعلن عن المؤشر بعد ذلك . مثل :
struct student *st;
** تھیئة المؤشر **
- بعد أن نعلن عن المؤشر يتم تهيئته اى نجعله يشير إلى عنوان فى الذاكرة فعلاً ويتم ذلك باستخدام
معامل العنوان & هذا المعامل يستخدم للحصول على عنوان أى متغير فى الذاكرة الجهاز
وعندما نضعه قبل احد المتغيرات فإنه يعنى عنوان unary - هذا المعامل من المعاملات الأحادية
scanf(“%d”,&var); : هذا المتغير فى الذاكرة مثلاً
- مثال على تهيئة المتغير وجعله يشير إلى عنوان فى الذاكرة
int num;
int *ptr;
num = 5;
ptr = #
الذى سنستخدمه ptr ثم نعلن عن المتغير num - فى هذه العبارات نعلن عن المتغير العددى
فى الذاكرة num كمؤشر ليشير إلى عنوان المتغير
ونضع فيه الرقم 5 num - بعد ذلك نهيئ المتغير
فى num فاننا نستخدم المعامل &لنحصل على عنوان المتغير ptr = &num - أما العبارة
ptr الذاكرة ونضع هذا العنوان فى المؤشر
أى انه ( يشير ) إلى هذا المتغير. num حاملاً لعنوان المتغير ptr - بهذا الشكل يصبح المؤشر
اسم المؤشر الحرف(*) نوع البيانات التى سيشير إليها
C محاضرات فى لغة
رقم الصفحة ٦٣
** استخدام المؤشر ** ھناك طريقتان لاستخدامه :-
الطریقة الأولى : هى ان تستخدم العنوان الموجود فى المؤشر .
- فى هذه الحالة نستخدم اسم المؤشر بدون إضافات.
addten(ptr); : - فمثلا إذا أردت ان نمرر العنوان إلى إجراء آخر نكتب
فى الذاكرة num اى عنوان المتغير ptr ونمرر له المؤشر addten - هنا نستدعى الإجراء
الطریقة الثانیة : هى ان تستخدمه لتعديل قيمة المتغير
*ptr = - فى هذه الحالة نضع حرف ( * ) قبله مثلاً ; 10
إلى 10 ولكن بطريقة غير مباشرة num - فى هذه الحالة نعدل قيمة المتغير
a=*ptr; - كذلك يمكن ان نستخدم المؤشر لقراءة محتويات العنوان الذى يشير إليه المؤشر نكتب
* تمرين :
#include<stdio.h>
void main(void)
{
int u = 3;
int v;
int *pu; /* pointer to an integer */
int *pv /* pointer to an integer */
pu = &u; /* assing address of u to pu */
v = pu; /* assign values of u to v */
pv =&v; /* assing address of v to pv */
printf(“\n u=%d &u=%x pu=%x *pu=%d” , u , &u , pu , *pu);
printf(“\n v=%d &v=%x pv=%x *pv=%d” , v , &v , pv , *pv);
}
ملاحظات :
v عنوان pv ويمثل u وعلى هذا يمثل عنوان .v مشير إلى u ,pv مشير إلى pu - لاحظ ان
تلقائيا بواسطة المترجم بأنه مثلا u تمث ل القيمة 3 ويتحدد عنوان u - فى السطر الأول
فى النظام السادس عشر ) ) FF8E
FF8E ( العنوان ( السادس عشر pu لذا يمثل . pu - وتتحدد هذه القيمة للمشير
( FF8E اى القيمة المخزنة فى خلية فى الذاكرة التى عنوانها )pu - كذلك القيمة التى يشير إليها
تعنى 3
v الى *pv تمثل القيمة 3 حيث اننا حددنا القيمة v - وبالمثل فى السكر الثانى يبين أن
**تمرين آخر :
#include<stdio.h>
C محاضرات فى لغة
رقم الصفحة ٦٤
main( )
{
int u1 ,u2;
int v =3;
int pv / pv pointer to v */
u1 = 2*(v + 5 ); /* ordinary expression */
pv = &v ;
u2 = 2*(*pv + 5 );
printf(“\n u1 = %d us2 = %d “,u1 , u2 );
}
ملاحظات :
2 وهو تعبير حسابى معتاد . اما الثانى *(v + - يشمل هذا البرنامج تعبيرين صحيحين اولهما ( 5
يمث ل v , *pv 2 يحتوى على استخدام مشير ويتكافئ التعبيران حيث أن كلا من *(*pv + 5 )
نفس القيمة الصحيحة
- ناتج البرنامج :
v = 3 u1 = 15 u2 = 16 pv = 3
u1=2*(v + 5 ) u2 = 2*(*pv + 5)
u1=2*(3+5) u2=2*(3+5)
u1= 16 u2=16
** تمرير المؤشرا ت إلى الاجراءا ت الفرعیة **
تمرر المتغيرات إلى الإجراءات بالقيمة وليس بالاشارة. C - من المعلوم أن لغة
- اى عندما تمرر متغيراً لأحد الإجراءات فإن هذا الإجراء يتلقى نسخة من المتغير وليس المتغير
نفسه ( أى يتلقى " قيمة " المتغير وليس المتغير نفسه ) كما فى الشكل التالى :-
void main(void)
{
int num = 5;
change(num);
……;
}
void change( int num )
{
num = 7 ;
………;
}
ملاحظات :
5
هذا التعديل لا يؤثر فى المتغير الأصلى
C محاضرات فى لغة
رقم الصفحة ٦٥
change ونضع فيه العدد 5 ثم نستدعى الإجراء num نعلن عن المتغير main - فى الإجراء
ونمرر له هذا المتغير.
وهى العدد 5 إلى الاجراء num - فى هذه الحالة يقوم المترجم بتمرير القيمة الموجودة فى المتغير
main الموجود فى num من رؤية المتغير change ولن يتمكن الإجراء change
إلا ان ك ل واحد change وفى الإجراء main موجود فى الإجراء num - فرغم ان المتغير
خاص بالإجراء الذى يوجد فيه. local منهما يختلف عن الاخر، فكل واحد منهما متغير محلى
- ملاحظة : ( تمرير المتغيرات بالقيمة وليس بالإشارة مسالة مفيدة لنها تحمى المتغيرات المحلية
لكل إجراء من اى تعديل غير مقصود )
* إذا أردت أن تتيح للإجراء الفرعى أن يعدل المتغير الذى تمرره له . أتبع الاتى :-
الخطوة الأولى : -
- هى أن تعدل الاعلان عن الإجراء فى بداية البرنامج ورأس الاجراء نفسه بحيث تخبر المترجم ان
سيتلقى مؤشراً وليس متغيراً عادياً.
void change ( int * ptr ); : - فمثلاً الاعلان عن الاجراء التالى
سيتلقى مؤشراً وليس متغيراً عادياً change - هنا نخبر المترجم ان الإجراء
الخطوة الثانیة :
هو مؤشر لأحد ptr على اعتبار change(ptr) : - هى ان تمرر للإجراء عنواناً فى الذاكرة مثل
المتغيرات
- فى هذه الحالة سيكون لدى الاجراء الفرعى عنوان المتغير ويتمكن بالتالى من تعديل قيمته.
البرنامج التالى يوضح ذلك :
#include<stdio.d>
void change( int *ptr );
void main(void)
{
int num = 5;
int *ptr;
ptr = &num ;
printf( “berfore change , num =%d \n “, num);
change(ptr);
printf(“after change, num = %d \n “, num );
}
void change( int * ptr )
C محاضرات فى لغة
رقم الصفحة ٦٦
{
*ptr = 7;
}
ملاحظات
void change( int *ptr ); - فى بداية البرنامج نعلن عن الاجراء
يستقبل مؤشراً وليس متغيراً change - هذا الاعلان يخبر المترجم ان الاجراء
- والسبب فى ذلك هو الحرف ( * ) الذى يسبق اسم المؤشر كذلك نفس الصيغة فى رأس الاجراء .
وننقل ptr ونضع فيه العدد 5 ثم نعلن عن المتغير num نعلن عن المتغير main - وفى الاجراء
ptr = &num : فى الذاكرة مثل num إليه عنوان المتغير
حاملاً لعنوان المتغير فى الذاكرة ptr - بهذا الشكل يصبح المتغير
ثم change قبل استدعاء الإجراء num لنطبع قيمة المتغير peintf - بعد ذلك نستخدم الاجراء
ptr ونمرر له المتغير change نستدعى الاجراء
لتضع العدد 7 ptr هذه العبارة تستخدم المؤشر *ptr = يحتوى على ; 7 change - الاجراء
فى العنوان الذى يشير إليه.
الى العدد num فإن هذه العبارة تغير محتويات المتغير num يشير إلى ptr - ولما كان المتغير
- ويكون ناتج البرنامج :-
before change , num = 5
after change , num = 7
** العودة بأكثر من قیمة من الإجراء الفرعى **
للعودة بقيمة ما من الاجراءات الفرعية ولكن return - ملاحظة : سبق إن ذكرنا أن استخدام كلمة
تعود بقيمة واحدة فقط return كلمة
- الحل : هو ان تعلن عن متغيرات محلية بعدد المعلومات التى تريد ان يعود بها الاجراء ثم تمرر
مؤشرات لهذه المتغيرات للاجراء ليضع المعلومات فيها
- البرنامج التالى يوضح ذلك :-
#include<stdio.h>
void fn( int *var1 , int *var2 , int *var3);
void main(void)
{
int var1 ,var2, var3;
fn(&var1 , &var2 , &var3)
printf(“var1 = %d , var2 = %d , var3 = %d”, var1 , var2 , var3);
}
void fn( int *p1 , int *p2 , int *p3)
{
*p1=10;
C محاضرات فى لغة
رقم الصفحة ٦٧
*p2=20;
*p3=30;
}
ملاحظات :
ولا نضع فيها اى قيمة var1,var2,var - فى بداية البرنامج نعلن عن ثلاثة متغيرات محلية 3
ونمرر له عناوين هذه المتغيرات الثلاثة fn - بعد ذلك نستدعى الاجراء
p1,p2,p يستقبل هذه العناوين ويضعها فى مؤشرات باسم 3 fn - الاجراء
بتعيين هذه للعناوين التى تشير إليها هذه المؤشرات fn - بعد ذلك يقوم الاجراء
لنطبع القيمة الموجودة فى المتغيرات printf نستخدم الاجراء main - وعندما نعود الى الاجراء
var1,var2,var3
فى العناوين التى مررناها له ويكون الناتج :- fn - نلاحظ انها نفس القيمة التى وضعها الاجراء
var1 = 10, var2 = 20 , var3 = 30
بهذا الشكل يمكنك استقبال اى عدد من البيانات من الاجراءات الفرعية
** برنامج عام ** ( تجديد سجلات العملاء )
- اعد نظاماً بسيطاً لإعداد فواتير عملاء فى هذا النظام من خلال تخزين سجلات العملاء داخ ل
منظومة من الهياكل، ويخزن كل سجل كهيكل منفرد ( اى كعنصر منظومة ) محتوياً على اسم
العميل ، واسم الشارع الذى يسكن فيه ، واسم المدينة ، ورقم الحساب ، وحالة الحساب ( جار أٍو
والموازنة السابقة ، والمبلغ المدفوع ، ( delinquent أو مماطل ، overdue متاخر السداد
حالياً ، والموازنة الجديدة ، وتاريخ الدفع.
- الطريقة : هى إدخال سجل كل عميل ، وتجديده بمجرد إدخاله ليعكس المبالغ المدفوعة حاليا وبعد
ذلك تعرض كل السجلات المجددة مع الحالة الحالية لكل حساب والتى تعتمد على قيمة المبلغ
المدفوع بالنسبة للموازنة السابقة للعميل.
* توضیح :-
١- إذا كان المبلغ المدفوع – حالياً – أكبر من صفر – لكنه أقل من % 10 من الموازنة القائمة
overdue السابقة ، حيث يكون الحساب متأخر السداد
٢- إذا كانت هناك موزانة قائمة ، وكان المبلغ المدفوع حالياً صفراً ، فإن الحساب يكون مماطلاً
وإلا كان الحساب جارياً delinquent
* ويكون البرنامج كما يلى :-
١- حدد عدد حسابات العملاء ( أى عدد الهياكل ) المراد تشغيلها .
٢- لكل حساب ٠٠٠ تقرأ العناصر التالية :-
1- name 2-street 3- city
4- account number 5- previous balance 6- current balance
C محاضرات فى لغة
رقم الصفحة ٦٨
7- payment date
٣- مع قراءة سجل كل عميل ، يتم تجديده طبقاً لما ياتى :-
- يقارن المبلغ المدفوع حالياً مع الموزانة السابقة، وذلك لتحديد الحالة المناسبة للحساب
- تحسب موزانة الحساب الجديد بطرح المبلغ المدفوع – حالياً – من الموزانة السابقة
٤- بعد ادخال كل سجلات العملاء وتشغيلها ، نكتب المعلومات التالية كمخرجات لكل عميل:
1- name 2- account number 3- street
4- city 5- oldbalance 6- current balance
7- new balance 8- account status
* فیما يلى محتويات البرنامج :-
#include<stdio.h>
struct date
{
int month;
int day;
int year;
};
struct account
{
char name[50];
char street[45];
char city[60];
int acc_no;
int acct_type; /* c = current , o = overdue , d = delinquent */
float oldbalance;
float newbalance;
float paymeny;
struct date lastpayment;
}
main( )
{
int i ,n ;
void readinput(int i );
void writeoutput(int i (;
printf(“customer billing system \n\n”);
printf(“how many customer are there ? “ );
scanf(“%d”,&n);
for(i=0,i<n,i++)
{
C محاضرات فى لغة
رقم الصفحة ٦٩
readinput(i);
if(customer[i].payment > 0 )
customer[i].acct_type =
(customer[i].oldbalance < 0.1*customer[i].oldbalabce) ? ‘o’ | ‘c’;
else
customer[i].acct_type =
(customer[i].oldbalance > 0 ) ? ‘d’ | ‘c’ ;
};
for (i = 0 ; i < n ; i ++)
writeoutput(i);
} void readinput(int i
)
{
print(“\n customer no. %d\n”, i+1);
printf(“ name : “ );
sccanf(“ %[ ] “,customer[ i ].name);
printf(“ street : “ ) ;
scanf(“% [ ] “,customer[ i ] .street);
printf(“ city : “ );
scanf(“ %[ ] “,customer[ i ] .city );
printf(“ account number : “ );
scanf(%d “ , &customer[ i ] . oldbalance);
printf( current payment : “);
scanf(“%f”, &customer[ i ] .payment);
printf(“ payment date (mm/dd/yyyy) : “);
scanf(“%d / %d / %d “, &customer[ i ] .lastpayment.month,
&customer[ i ] .lastpayment.day
&customer[ i ] .lastpayment.year
return;
}v
oid writeoutput(int i)
{
printf(“ name : %s”, customer[i].name);
printf(“ account number : %d\n”, customer[i].acct_no);
printf(“street : %s\n , customer[i].street);
printf(“city : %s\n\n” , customer[i].city);
printf(“old balance “ %7.2f”, customer[i].oldbalance);
printf(“ current payment : %7.2f” , customer[i].payment);
printf(“ new balance : %7.2f\n\ “,customer[i].newblance);
printf(“ account status : “);
switch ( customer[i].acct_type)
{
case ‘c’
printf(“ current\n\n”);
break;
C محاضرات فى لغة
رقم الصفحة ٧٠
case ‘o’
printf(“ overdue\n\n”);
break;
case ‘d’
printf(“ delinqunt\n\n”);
break;
default;
printf(“ error \n\n”)
}
return;
}
ليست هناك تعليقات:
إرسال تعليق