Printable View
سلام ...
به انجمن هاي برنامه نويسي ديگه (دلفي و ويژوال بيسيک و ويبي.نت ) که مي رفتم ديدم هر کدوم يه تاپيک دارن در مورد آموزش زبان برنامه نويسي اون انجمن . گفتم خوب بهتره انجمن C هم يکي داشته باشه .
من از امروز ان شاءالله شروع مي کنم . بهتره دوستاي ديگه هم که در مورد Syntax اين زبان مشکل دارن سوالاتشونو تو اين تاپيک مطرح کنن و وقتي هم که مي خوان در مورد مشکل برنامه اي که نوشتن راهنمايي بخوان اون موقع تاپيک جديد ايجاد کنن .
اميدوارم به کمک دوستان به تاپيک مفيدي تبديل بشه ... :20:
بدون هيچ حاشيه اي شروع مي کنم .
فقط قبلش اينکه بحث راجع به کلاس ها رو به آخر موکول مي کنم . فعلا بيشتر روي ساخت يافته ( Structured ) بحث مي کنم .
نکاتي هم که مهم تر هستن با رنگ قرمز نشون ميدم .
سعي مي کنم مطالب رو به مرور با گذاشتن يکي دو تا فايل PDF ، منظم تر کنم .
ضمنا از دوستان محترم هم درخواست دارم از کوچکترين اشکال علمي يا املايي چشم پوشي نکرده و گوشزد کنند . :20:
فصل اول : مباحث پايه اي ++C
خوب مي خوايم برنامه بنويسيم . به زبان ++C ! تقريبا هر برنامه اي تو ++C ، چه به صورت ساخت يافته نوشته بشه و چه به صورت شي گرا ، حداقل از يک تابع تشکيل ميشه که يکيشون دقيقا اسمش بايد main باشه . اجراي برنامه از تابع main شروع ميشه . يعني کامپايلر مياد و دستورات داخل اين تابع رو خط به خط اجرا مي کنه و اين تابع هست که تابع و کلاس هاي ديگه رو براي انجام کارهاي ديگه فراخواني مي کنه .
خوب حالا تابع چيه ؟
اين بمونه براي فصول بعد .... :20:
مي خوايم سريعا اولين برنامه مونو بنويسيم . پس همون طوري که اشاره شد تابع main مون رو مي نويسيم :
[html]
int main ()
{
}
[/html]
اين تعريف تابع main هست . کلمه int ميگه که نوع داده برگشتي اين تابع int هستش . ( در مورد نوع داده بعدا بحث ميشه . ) پرانتزهاي باز و بسته ليست پارامترهاي تابع رو نشون ميدن . ( پارامتر هم بمونه براي چند فصل بعد . چون ما فعلا راجع به تابع main بحث مي کنيم و اين ليست پارامتر ها براي main هميشه خالين . ) اين ليست پارامتر خالي به ما ميگه اين تابع براي انجام کارش هيچ داده يا اطلاعاتي رو دريافت نمي کنه . نوع داده برگشتي هم بمونه براي بعد ولي فقط اينو بدونين که هميشه سعي کنين شکل تعريف تابع main تون اينجوري باشه .
حالا ما دستوراتمونو تو تابع main مي نويسيم .
به عنوان مثال مي خوايم يه متني رو چاپ کنيم . کافيه تو تابع main بنويسيم :
[html]
cout << "متن مورد نظر";
[/html]
هر عبارتي که داخل " " باشه تو خروجي ( که به طور پيش فرض صفحه نمايش هست ) چاپ ميشه .
اين cout چيه ؟ اين cout يک شي متعلق به کلاس ostream هست که کار چاپ اطلاعات تو صفحه نمايش رو انجام ميده .
ostream چيه ؟ اين بمونه براي آخر آخر .... :31: شايد هم نرسيديم ... :20:
>> يه عملگر گفته ميشه که طرف راست خودش رو تو cout قرار ميده و اين کار باعث ميشه که عبارت طرف راستي تو خروجي چاپ بشه . الگوريتم کار براي چاپ اطلاعات تو خروجي در کتابخانه استاندارد ++C وجود داره . بنابراين ما بايد اينو به کامپايلر هم نشون بديم . اين کار با قرار دادن عبارت زير در اول برنامه انجام ميشه :
[html]
#include <iostream>
[/html]
ما گفتيم که از يک شيء به نام cout که متعلق به فضاي نام std هست هم استفاده کرديم . بنابراين اينو هم بايد به کامپايلر گفت . با اين دستور :
[html]
using std::cout;
[/html]
چون گفتيم قبل از تابع main يه int بذارين ، آخر تابع main هم يدونه :
[html]
return 0;
[/html]
بذارين که معلوم بشه اجراي برنامه به پايان رسيده .
بنابراين برنامه مون به شکل زير در مياد :
[html]
#include <iostream>
uaing std::cout;
int main ()
{
cout << "Welcome to C++";
return 0;
}
[/html]
خروجي برنامه اين ميشه :
[html]Welcome to C++[/html]
خوب ادامه مطالب :
ديديم که مي تونيم با استفاده از شيء cout که معمولا به صفحه نمايش وصله يه چيزي رو تو خروجي چاپ کنيم . حالا برعکس اون اينکه از ورودي يه چيزي بگيريم از cin استفاده مي کنيم . cin هم به طور معمول به صفحه کليد وصله . cin يه مقداري رو از صفحه کليد مي گيره و تو يه متغير ذخيره مي کنه . حالا متغير چيه ؟
متغير چيزيه که تغيير مي کنه . برنامه نويسان از متغيرها استفاده مي کنن تا مقاديرشون رو طي اجراي برنامه تو اونا ذخيره کنن . هر متغير يه نوع داده داره ، يه مقدار ، يه اسم و يه اندازه .
انواع داده اصلي ++C عبارتند از :
int, char, float, double .
int ، اعداد صحيح رو نگه مي داره . تا اونجايي که يادمه از منفي دو ميليارد تا مثبت دو ميليارد . 4 بايت حافظه اشغال مي کنه .
char ، کاراکتر ذخيره مي کنه . ( فقط يک کاراکتر ) . 1 بايت هم حافظه مي گيره .
توضيح : تو ++C ، يه نوع داده هم اضافه شده به اسم string که مي تونه دنباله اي از کاراکترها يا همون رشته ها رو تو خودش ذخيره کنه که جزو انواع داده اي اصلي محسوب نمي شه . ( پرانتز بسته ! )
float هم اعداد اعشاري رو مي تونه تو خودش ذخيره کنه . ايشون هم 4 بايت حافظه مي گيرن .
double هم مثل float ولي با کمي Range بيشتر . ( کمي بيشتر از کمي :46: ) مي تونين دو برابر فرض کنين چون 8 بايت حافظه مي گيره .
خوب براي تعريف يه متغير ، اول نوع داده بعد اسم متغير و بعد سمي کالن ( ; ) .
راستي يادم رفت بگم که تو ++C براي اينکه بگيم يه دستوري تموم شده آخرش يه سمي کالن مي ذاريم . يه استثناء وجود داره که اون هم دستورهاي پيش پردازنده هستن . همون include ها .
مثلا مي خوايم يه متغير از نوع int به اسم num بگيريم :
[html]
int num;
[/html]
يه متغير يا مقدارشو از صفحه کليد مي گيره و يا توسط دستورهاي انتساب يا assignment .
حالت اول :
[html]
cin >> num;
[/html]
در اينجا با همون cin اي که قبلا اشاره شد يه مقداري از صفحه کليد گرفته ميشه و تو num ذخيره ميشه .
حالت دوم :
[html]
num = 124;
[/html]
در اينجا هم num مقدار 124 رو ميگيره .
نکته : هر متغيري که تعريف ميشه ، قبل از اينکه مقداري توش گذاشته بشه يه مقدار زايد به خودش ميگيره . مثل 858993460 - . پس حتما قبل از اينکه يه همچين مقداري توش جاي بگيره خودتون يه مقداري مثل صفر بهش بدين .
براي جمع و ضرب و اينا هم فرض کنين num1 و num2 دو متغير از نوع int هستن . براي جمع و تفريق و ضرب و تقسيم به ترتيب :
[html]
num1 + num2
num1 - num2
num1 * num2
num1 / num2
[/html]
تو ++C يه عملگر هم داريم که باقيمانده تقسيم دو عدد صحيح ( int ) رو به ما ميده . اون هم % هستش .
مثلا اگه num1 برابر 23 باشه و num2 برابر 7 ، 7 % 23 ميشه 2 :20: .........
راستي num1 / num2 هم ميشه 3 . نه 3.28 . چرا ؟ چون هر دو عدد صحيح بودن و جواب هم بايد عدد صحيح باشه .
اگه هر دو float يا double بودن چي ؟
جواب : بله اون وقت ميشد 3.28 :46: .
براي مقايسه هم :
[html]
>
>=
<
<=
==
!=
[/html]
که به ترتيب :
بزرگتر
بزرگتر يا مساوي
کوچکتر
کوچکتر يا مساوي
برابر
نابرابر
سلام خیلی ممنون،
بهتره اول از شیء گرایی شروع کنیم
يعني شما ميگين اين طوري بهتره ؟نقل قول:
من گفتم اول از ساخت يافته شروع کنيم که مطالب براي تازه کارها زياد پيچيده نباشه .
خوب پس اگه صلاح باشه من بقيه رو با مقدمه اي از کلاس ها و اشياء پي مي گيرم . با کمک شما دوستان عزيز . :20:
سلام .
در مورد کلاس ها و اشياء و برنامه نويسي شيء گرا
در برنامه نويسي ساخت يافته ، واحد برنامه نويسي تابع است . يعني هر برنامه ساخت يافته از يک يا چند تابع تشکيل مي شوند .
در برنامه نويسي شيءگرا ، واحد برنامه نويسي ، قطعاتي به نام کلاس هستند . يعني هر برنامه شيءگرا از يک يا چند کلاس تشکيل مي شود .
هر کلاس رو به قول آقاي ديتل ميشه يه نقشه فرض کرد . فرض کنين يه کلاسي براي ماشين نوشتيم . ( يعني نقشه ماشين ) . اين کلاس رو مي نويسيم تا بتونيم بعدا از اين کلاس ( نقشه ) يه ماشين درست کنيم . به اين ماشينه ميگيم شيء . يعني هر چيزي که از کلاس ( نقشه ) نمونه سازي بشه ، شيء ناميده ميشه .
کلاس يا نقشه ماشين ما ، تعدادي خصيصه يا attribute و تعدادي رفتار يا behavior داره . مثلا از خصيصه ها ميشه به رنگ ، تعداد در ، تعداد چرخ و ... اشاره کرد . رفتار ها هم مثلا سرعت گرفتن ، ايستادن ، تک چرخ زدن :31: و ... . براي هر رفتار يک دستگيره يا handle در نظر گرفته ميشه که کاربر بتونه با اون دستگيره اين اعمال رو انجام بده . مثلا تو ماشين واقعي براي سرعت گرفتن ، دستگيره پدال گاز در نظر گرفته شده و کاربر يا همون راننده ماشين مي تونه با فشار پا بر روي اون ، ماشين رو وادار به سرعت گرفتن کنه . تو نقشه ماشين يا همون کلاس ، همچين دستگيره اي وجود نداره . فقط الگوريتم اون کار نوشته شده . بنابراين براي تست بايد ما يه ماشين يا شيء از اون کلاس يا نقشه داشته باشيم و پدال گاز مربوط به اونو فشار بديم .
يه مثال از کلاس مي زنم و مطالبي که گفتم تو اون مشخص مي کنم :
[html]
class Car
{
public:
void move ();
void stop ();
void jump ();
private:
int color;
int numOfDoors;
int numOfWheels;
};
[/html]
براي تعريف کلاس از کلمه کليدي class استفاده مي کنيم و بعد از اون اسم کلاس . با آکلاد باز بدنه کلاس رو مشخص مي کنيم . کلمه :public رو مي بينين . اين کلمه نشون ميده که توابع move و stop و jump حالت عمومي دارن و هر جايي خارج از کلاس مي شه بهش به طور مستقيم دسترسي داشت . يعني کاربر مي تونه تابع move مربوط به يک شيء از کلاس رو اجرا کنه تا ماشين سرعت بگيره . سه تابع اشاره شده ، توابع عضو کلاس ناميده ميشن . بعد کلمه private رو مي بينين . اين کلمه هم نشون ميده که متغيرهاي color و اون دو تاي ديگه حالت خصوصي دارن و فقط در داخل کلاس ميشه بهش دسترسي داشت . يعني قرار نيست کاربر بخواد به طور مستقيم بياد و تعداد درهاي يک ماشين رو عوض کنه . ( در عمل هم همچين کاري غير منطقيه ) بنابراين به طور خصوصي تعريف ميشن . پايان کلاس با يه آکلاد بسته به همراه ; تموم مي شه . البته فرض ميشه که توابع move و stop و jump قبلا تعريف شدن . حالا ميايم تو تابع main اين کارارو مي کنيم :
[html]
Car c;
c.move ();
c.stop ();
c.jump ();
[/html]
ماشين حرکت مي کنه ، مي ايسته ، مي پره :46: .
به اون سه تا تابع ميگيم رفتار ( behavior )
به اون سه تا متغير که خصوصيات ماشين رو مشخص مي کردن مي گيم خصيصه ( attribute ) .
تو تابع main يک شيء به نام c ( يک ماشين به نام c ) ايجاد کرديم و از اون سه تا دستگيره براي انجام کارامون استفاده کرديم .
خیلی جالب بود. من حدودا 15 سال هست که مرتبا با مفاهیم Object Oriented کار میکنم اما توضیحی که دادی خیلی روشن بود. ممنون.
ادامه ....................
توابع عضو يا همون توابعي که داخل يک کلاس تعريف شدن عملياتي رو روي داده هاي عضو ( يا همون داده ها و متغيرهايي که در داخل کلاس تعريف شدن ) انجام مي دن . تمام توابع عضو کلاس به طور مستقيم مي تونن به داده هاي عضو دسترسي داشته باشن و مقداراشونو تغيير بدن .
مطلب ديگه اي که در مورد کلاس ها به ذهنم مي رسه سازنده يا Constructor هست .
سازنده چيه ؟
يه تابع عضوه که حتما بايد همنام با کلاس باشه . سازنده ها هيچ وقت نمي تونن يه مقدار برگردونن . بنابراين هيچ وقت نبايد نوع داده برگشتي براشون مشخص بشه . حتي void .
فعلا اينجا من يه پرانتز باز ايجاد مي کنم و توضيحاتي در مورد توابع ميگم . پرانتز بسته رو هم ميگم تا مطالب رو از اينجا پي بگيرين .
پرانتز باز :
خب تو رياضيات که تابع ديدين ؟ تابع ++C هم تقريبا همونه . يعني يه چيزي يا يه چيزايي بهش مي ديم و اون هم يه چيزي بعد از محاسبات به ما ميده . چيزهايي که ما بهش ميديم آرگومان يا Argument ناميده ميشن . حالا تابع رو چجوري تعريف مي کنيم :
[html]
int foo ( int a, int b, int c )
{
return a * b * c;
}
[/html]
foo : اسم تابعه .
int قبل از اسم تابع : ميگه اين تابع يه متغير از نوع int به عنوان نتيجه کار برمي گردونه .
سه متغير تعريف شده داخل پرانتز هاي بعد از نام تابع : پارامترهاي تابع رو مشخص مي کنن . يعني اين تابع براي انجام کارش سه تا آرگومان مي گيره که همش از نوع int هستن .
داخل تابع اين سه تا رو در هم ضرب کرديم و برگردونديم . با دستور return يه مقداري رو از تابع بر مي گردونيم .
شايد بپرسين آرگومان چيه ، پارامتر ( Parameter ) چيه ؟
تقريبا ميشه گفت پارامتر اون چيزيه که تو تعريف تابع ظاهر ميشه . مثل بالا . يعني a و b و c پارامترهاي تابع هستن .
حالا آرگومان .
وقتي مي خوايم تابعي رو فراخواني کنيم که يه کاري رو براي ما انجام بده ما آرگومان رو بهش مي فرستيم و اين آرگومان يا آرگومان ها تو پارامترها قرار مي گيرن و نتيجه برگردونده ميشه .
مثلا :
[html]
result = foo ( 12, 32, 33 );
[/html]
اينجا به تابع foo سه تا آرگومان فرستاديم که اين آرگومان ها مي رن تو تابع به جاي a و b و c قرار مي گيرن و نتيجه برمي گرده و داخل result قرار مي گيره .
فعلا پرانتز بسته .
وقتي مي خوايم يه شيئي از کلاسمون نمونه سازي يا instancing کنيم سازنده به طور اتوماتيک فراخواني ميشه و کاراشو انجام ميده . بنابراين جز اينجا ، جاي ديگه نمي تونيم به طور صريح سازنده رو فراخواني کنيم .
حالا اگه سازنده مون آرگومان داشته باشه ، هنگام تعريف شيء اين آرگومان ها رو براش مي فرستيم . ( بعد از نام شيء و داخل پرانتز )
سازنده اي که آرگومان نداشته باشه توسط کامپايلر به اسم Default Constructor شناخته ميشه . ( خيلي مهمه اين سازنده پيش فرض :46: )
فعلا کمي هم در مورد ساختار هاي کنترلي يا Control Structures :
هر برنامه ++C با استفاده از سه ساختار کنترلي نوشته ميشه .
1 - ساختار ترتيبي يا Sequence Structure : کامپايلر به ترتيب با هر دستوري که با اون مواجه مي شه اونو اجرا مي کنه .
2 - ساختار انتخابي يا Selection Structure : بسته به انتخاب کاربر يک دستور در شرايطي اجرا ميشه و در غير اين صورت يه دستور ديگه . حالت ديگه اي هم که هست اينه که يک دستور از ميان چند حالت موجود اجرا ميشه .
سه حالت داريم . حالت اول اينه که يه دستوري يا اجرا ميشه و يا نه . مثلا :
[html]
if ( a == 22 )
{
cout << a;
}
[/html]
در دستور فوق اگه a برابر 22 باشه چاپ مي شه و در غير اين صورت از شرط مي پره و ميره سراغ دستورات بعدي .
حالت دوم اينه که اگه شرط برقرار باشه يه کاري و در غير اينصوري يه کار ديگه و همين طور تا آخر ... . مثلا :
[html]
if ( a == 22 )
{
cout << a;
}
else if ( a < 22 )
{
cout << "a is less than 22";
}
else
{
cout << "a is greater than 22";
}
[/html]
اگه a برابر 22 باشه چاپ ميشه ، اگه کمتر از 22 باشه يه چيزه ديگه چاپ ميشه و اگه هيچ کدوم نباشه يه چيزه ديگه .
نکته : گذاشتن آکلاد در مواقعي که فقط يه دستور در داخل بدنه شرط داريم نياز نيست . ولي اگه بيش از يه دستور باشه بايد حتما گذاشته بشه .
حالت سوم هم دستور switch هست که يه کاري از بين چند حالت موجود اجرا ميشه .
[html]
switch ( a )
{
case 1:
cout << "one";
break;
case 2:
cout << "two";
break;
case 3:
cout << "three";
break;
default:
cout << "One thousand";
}
[/html]
فهميدين چي شد ؟
a رو ميذاريم داخل يه ظرفي . اگه 1 بود one چاپ ميشه . اگه 2 بود two چاپ ميشه ، اگه 3 بود three چاپ ميشه و در غير اينصورت يه عدد ديگه .
اين break ها رو هم بذارين . اگه مثلا تو دستور اولي نذاريم ، وقتي a ، برابر 1 باشه ، دستور مربوط به اون و دستور مربوط به بقيه case ها همه اجرا ميشن . يعني هم one و هم two والي آخر ... با گذاشتن ;break از اين کار جلوگيري ميشه . حالا اگه گفتين چرا براي default نذاشتيم ؟ :20:
حالت 3 هم که حلقه هاي تکرار هستن بمونه براي بعد .
فعلا ............
خوب حالا حالت سوم :
تو ++C ، سه نوع حلقه تکرار داريم . while ، do ... while و for
اولي ( يعني while ) :
ميگيم تا زماني که اين شرط داخل پرانتز while درست باشه ، يعني true باشه و يا هر مقدار غير صفر باشه ، اين عمليات داخل آکلاد باز و بسته بعد از پرانتز بسته شرط داخل حلقه رو انجام بده .
[html]
a = 40;
while ( a > 20 )
{
a -= 2;
}
[/html]
راستي يه توضيحي در مورد =- بدم .
[html]
a -= b; برابر است با a = a - b;
a += b; برابر است با a = a + b;
a *= b; برابر است با a = a * b;
a /= b; برابر است با a = a / b;
a %= b; برابر است با a = a % b;
a++; يا ++a; برابر است با a = a + 1;
a--; يا --a; برابر است با a = a - 1;
[/html]
حالا a++ با ++a چه فرقي داره ؟ وقتي ميگيم ++a يعني بعد از اينکه مقدار a تو عملياتي به کار برده شد ، بعد از اون يدونه بهش اضافه بشه . مثلا فرض کنيد a = 2 :
[html]
cout << a++;
[/html]
اينجا اول 2 چاپ ميشه بعد a ميشه 3 .
وقتي بگيم :
[html]
cout << ++a;
[/html]
اول a برابر 3 ميشه و بعد چاپ ميشه .
در مورد - هم همين طور .
حالا دومي ( يعني do ... while ) :
در حالت قبل امکان داشت شرط حلقه همون اول غلط باشه و اصلا دستورات حلقه براي يکبار هم اجرا نشه . ولي تو do ... while همون طور که از اسم اون هم پيداست اول يه کاري يا يه کارايي انجام ميده و بعد شرط رو چک ميکنه و اگه شرط درست باشه بعد ميره دوباره همون کارو تکرار مي کنه .
[html]
a = 3;
do
{
a += 3;
} while ( a == 30 );
[/html]
حالا سومي که معمولا پراستفاده ترين هست . يعني حلقه for :
تقريبا ساختار کليش اين جوريه :
[html]
for ( i = 0, j = 0 , k = 4; i <= 5 && j <= 4 && k != 4; i++, j++, k++ )
{
Statements....
}
[/html]
&& هم همون "و" هست تو رياضيات . || هم معادل "يا" هست و ! هم علامت نقيض هست . يعني ( a == 3 )! يعني a != 3 .
در اين حلقه for ، اول به متغيرها مقدار اوليه داده ميشه . يعني i = 0 و j = 0 و k = 4 . بعد شرط رو چک مي کنه و بعد ميره داخل دستورات بدنه رو اجرا مي کنه . وقتي به آکلاد بسته رسيد بر مي گرده اول هر کدوم رو يدونه ++ مي کنه و بعد دوباره شرط رو چک مي کنه و اگه درست باشه دو باره ميره سراغ دستورات .
خوب حالا توابع تا اينجا بمونن . ميريم سراغ آرايه ها و مختصري از اشاره گرها و بعد هم ديگه آخرين مفاهيم شيءگرايي .
سلام.
عالیه دوست من.
ادامه بده....خیلی عالیه...
ممنونم.
توضيحاتت خوبه اما خيلي از اينور به اونور مي پري، ترتيبي تو آموزشت نداري يهو رفتي كلاس درس ميدي در حلي كه قبلش كلي مطالب بايد ميگفتي
برعکس خیلی هم خوب پیش میره، اگر با شی گرایی شروع کنیم خیلی به نفعمون میشه چون بعدا به هر چیزی به شکل یه آبجکت نگاه میکنی و ...(معلوماتم ته کشید:31:)نقل قول:
من نميگم بد توضيح ميدن خيلي خوبه اما يهو پريدن به جايي واسه كسي كه هيچي نميدونه كمي عجيب ميشه! منم خودم يه زماني...نقل قول:
برعکس خیلی هم خوب پیش میره، اگر با شی گرایی شروع کنیم خیلی به نفعمون میشه چون بعدا به هر چیزی به شکل یه آبجکت نگاه میکنی و ...(معلوماتم ته کشید)
به نظرم پله ها رو بالا پايين رفتن
من اگه خدا عمري بده از 5 شنبه به ايشون كمك ميكنم و كلاس رو كاملا توضيح ميدم اگه حالم خوش بودش آخه 5 شنبه كنكور كارشناسي دارم و فكر نمي كنم قبول بشم :41::37::9:
سلام .
ممنون از اظهارنظرهايي که کردين .
در مورد آرايه ها و اشاره گرها به طور مختصر توضيح مي دم و يکراست ميرم سراغ شيء گرايي و مطالب باقيمونده به مرور تو اون بحث ها مطرح ميشه .
آرايه :
يه آرايه رو ، ساختمان داده اي فرض کنين که تمام اعضاي اون از يک نوع هستن . ( يا همشون int ، يا همشون char و ... )
مي خوايم يه آرايه ي 5 عضوي تعريف کنيم از نوع int
[html]
int a [ 5 ];
[/html]
اينجا متغير a داراي 5 خانه است که تو هر کدوم ميشه يه متغير از نوع int جاي داد . حالا چجوري به اين خونه ها دسترسي داشته باشيم :
فرض کنين آرايه مونو تعريف کرديم . مي خوايم مقاديري توي آرايه درج کنيم . اين آرايه در واقع شامل 5 متغير زير است :
[html]
a [0]
a [1]
a [2]
a [3]
a [4]
[/html]
به اون اعدادي که توي دو تا علامت [] قرار مي گيره انديس يا index مي گيم . انديس آرايه از صفر شروع ميشه . به خاطر همين هميشه انديس آخرين خونه ي آرايه يکي کمتر از ظرفيت آرايه است . ( فهميدين که چي شد ؟ :46: )
دو تا مفهوم معمولا در مورد آرايه مطرح ميشه که خيلي مهمه :
1 - انديس n ام .
2 - n امين عضو .
فرض کنين اين آرايه رو به شکل زير مقدار دهي کرديم :
[html]
a [0] = 3;
a [1] = 2;
a [2] = 5;
a [3] = 6;
a [4] = 8;
[/html]
وقتي ميگيم انديس سوم آرايه a ، يعني عدد 6 .
وقتي ميگيم سومين عضو يعني عدد 5 .
ديدين چقدر مهم بود ؟ :31: .
يه چيز ديگه .
a يک آرايه است . يعني حاوي آدرس اولين خونش . چون اين آرايه از نوع int هست و int هم چهار خونه حافظه مي گيره پس آدرس خونه بعدي که انديس 1 باشه ميشه آدرس خونه اول + 4 . :46:
اين نکته خيلي جالبه ها . به غير از آرايه ها هيچ جا نميشه به صراحت گفت که آدرس دو خونه تو حافظه پشت سر هم باشه .
مقدار دهي اوليه به آرايه ها:
اگه تو تعريف آرايه که مقدار دهي کردين هيچ ، اگه نکردين تو يه جاي ديگه بايد دونه به دونه مقدار دهي کنين . مثل اون بالا کاري که من کردم .
حالا فرض کنيم تو تعريف آرايه ميخوايم مقداردهي کنيم . چندين حالت داريم که نمي دونم چند حالته . حالا بگم بعد مي شمرم . :46:
اول اينکه اگه بخوايم تو تعريف آرايه مقدار دهي کنيم بايد ليست مقادير داخل آکلاد باز و بسته باشه .
دستور زير رو در نظر بگيرين :
[html]
int a [ 5 ] = { 2,3,4,5 };
[/html]
مي بينين که ما يه آرايه 5 عضوي تعريف کرديم و براي چهار تا عضو مقدار اوليه مشخص کرديم . عضو آخر که مقدار نداره ، مقدار صفر مي گيره .
حالا يه سوال :
اگه بخوايم به همه صفر بديم ، چيکار کنيم راحت تره ؟ :46:
.
.
.
آفرين . درسته . دستور زير رو مي نويسيم :
[html]
int a [ 5 ] = { 0 };
[/html]
به عضو اول صراحتا مقدار صفر داديم ، بقيه هم که مقدار نگرفتن ، به طور پيش فرض صفر مي گيرن .
يه حالت هم اينه که اگه آرايه 5 عضوي تعريف کرديم ، 5 تا عدد تو ليست بنويسيم . تو اين هم که حرفي نيست . به طور صريح به همه مقدار داده ميشه .
حالت سوم اينه که ليست مقدار اوليه بيشتر از طول آرايه ( تعداد اعضاي آرايه ) باشه . در اين حالت Compile Error.
يه حالت هم اينه که :
[html]
int a [ ] = { 2, 4, 5, 7, 23, 34523, 43 };
[/html]
تو اين جا مي بينين که تعداد اعضا مشخص نشده . همون طور که احتمالا حدس زدين ، تعداد اعضا ميشه 7 . چون تو ليست مقدار اوليه ، 7 عدد مشخص شده . بنابراين از [ a [ 0 داريم تا [ a [ 6 .
فکر کنم شد 4 حالت . :46:
حالا آرايه هاي کاراکتري :
همون طور که قبلا اشاره شد نوع داده char فقط مي تونه يک کاراکتر يا همون حرف تو خودش داشته باشه . حالا اگه بخوايم چند کاراکتر يا همون به قول ++C ، رشته داشته باشيم مي تونيم آرايه اي از کاراکتر ها رو تعريف کنيم .
تعريفش که فرقي نمي کنه . فقط نکاتي در مورد مقدار دهي اوليه مي گم .
به دو روش مي تونيم به آرايه هاي کاراکتري مقدار اوليه بديم .
روش اول :
[html]
char str [] = "siplasplas";
[/html]
الان کامپايلر اين دستورو به شکل زير پردازش کرده :
[html]
str [0] = 's';
str [1] = 'i';
str [2] = 'p';
str [3] = 'l';
str [4] = 'a';
str [5] = 's';
str [6] = 'p';
str [7] = 'l';
str [8] = 'a';
str [9] = 's';
str [10] = '\0';
[/html]
هميشه آخرين عضو يک آرايه کاراکتري 0\ در نظر گرفته ميشه .
متوجه هستيد که در اينجا تعداد اعضا مشخص نبود. بنابراين تعداد اعضا برابر 11 ميشه .
يه حالت مقدار دهي هم به شکل زير است :
[html]
char str [] = { 's', 'i', 'p', 'l', 'a', 's', 'p', 'l', 'a', 's'. '\0' };
[/html]
يعني کاراکترها رو دونه به دونه بهش ميديم و آخر سر هم حتما بايد کاراکتر 0\ رو ما مشخص کنيم . ولي در حالت اول نياز نبود . اگه بخوايم تعداد اعضاي آرايه رو خودمون مشخص کنيم ، حتما بايد يه جاي اضافي هم براي 0\ در نظر بگيريم . مثلا اگه مي خوايم sin رو داشته باشيم بايد به جاي 3 خانه ، 4 خانه در نظر بگيريم . در غير اين صورت Compile Error
نکته مهم : اگه نمي خوايم تو تعريف آرايه مقداردهي رو انجام بديم ، حتما بايد تعداد اعضا ذکر بشه . مثلا دستور زير = Compile Error .
[html]
char str [];
[/html]
آرايه هاي دو بعدي :
آرايه هاي اخير که بحث شد همه يک بعدي بودن . مفاهيم آرايه هاي دوبعدي هم تقريبا همينه .
براي تعريف آرايه دوبعدي 3 در 4 :
[html]
int b [ 3 ][ 4 ];
[/html]
اين يعني 4 سطر و 5 ستون . ( چون انديس گذاري آرايه ها از صفر شروع ميشه . )
دستور زير رو در نظر داشته باشين :
[html]
int b [ 2 ][ 3 ] = { { 1 }, { 2, 3 } };
[/html]
مقدار دهي فوق به صورت زير پردازش ميشه :
[html]
b[0][0] = 1
b[0][1] = 0
b[0][2] = 0
b[1][0] = 2
b[1][1] = 3
b[1][2] = 0
[/html]
البته آرايه هاي بيش از دو بعدي هم داريم . مفاهيم همينا هستن . معمولا از آرايه هاي سه بعدي به بعد به ندرت استفاده ميشه .
اين هم از آرايه ها ................... :46:
جناب آقاي (ويا به احتمال 1% خانم:46:) sin2x=2sinxcosx :
با سلام
با تشكر مجدد از جنابعالي، مطمئنا" بسياري از اين مساعي مستفيض مي گردند كه بنده نيز در اين حلقه ام.لذا مستدعيست مراتب باي نحو كان پيگيري و سعايت بدگويان مانع از ادامه تلمذ نگردد .صحت مسير تائيد و روش خلاقانه اتان دريافت نهايه را ميسور مي نمايد.زياده جسارت است.حق يارتان
دوست كوچكتر شما
فقط تجربه خودمو میگم. اگه نویسنده اول یه فهرست از مطالبی که قرار گفته بشه درست کنه، آخر کار مرتب کردن مطالب خیلی راحت تره. بی فهرست برای هر نظم دادنی باید کلی تغییر بده. میشه حتتا پستای ناقصی نوشت و بعدا کاملشون کرد!
سلام . باز هم ممنون از دوستان عزيز بابت اظهارنظرهايي که فرمودن .
در مورد اينور و اونور پريدن : باشه ديگه تکرار نمي شه . ( همون طوري که ديدين تو بحث آرايه ها ديگه اين کارو نکردم . )
در مورد فهرست هم : چشم براي از اين به بعد فهرست مي ذارم .
ولي باز هم جمله قبليمو تکرار مي کنم :
"خواهشا از هيچ گونه اشتباه علمي و املايي چشم پوشي نکنيد و حتما تذکر دهيد ."
فهرست مطالبي که بعدا بحث ميشه :
1- نابود کننده ها يا Destructor ها
2- اشياء Const و توابع Const
3- کلاس ها و توابع Friend و مفهوم دوستي در کلاس ها
4- اشاره گر this
5- عملگر هاي new و delete
6- اعضاي static کلاس و مفهوم static بودن
7- بحثي کامل در مورد Operator Overloading يا همون سربارگذاري عملگر ها
8- ارث بري و مفاهيم مربوط به آن
9- مبحث Polymorphism و توابع Virtual
10- بحث در مورد توابع بازگشتي
11- اشاره گرها
12- کار با فايل ها
13- مباحثي در مورد ساختمان داده ها ( صف و پشته و ليست پيوندي و ... )
14- آشنايي با وپژگي هاي کلاس string و نحوه استفاده از آن
15- حل مسائل گوناگون مطرح در زبان ++C
ان شاءالله که عمري باقي باشه و بتوان به تمامي اين موارد رسيد .
موفق باشيد .............
سلام. اگه اجازه بدين اشاره گرها رو شروع کنيم .
چون بعدا نياز ميشه .
اشاره گرها يه نوع متغير هستن . اما به جاي يک مقدار ، يک آدرس متغير رو تو خودشون نگه مي دارن .
در زير من يک متغير اشاره گر که به يک مقدار صحيح ( يعني int ) اشاره مي کند ، معرفي مي کنم :
[html]
int* aPtr;
[/html]
اگه بخوايم بيش از يک متغير اشاره گر رو تو يک خط معرفي کنيم بايد قبل از هر کدوم يه star ( * ) بذاريم . عملگر * تو بالا نشون ميده که متغير aPtr يک اشاره گر به int هست .
به غير از آدرس يک متغير ، عدد صفر تنها مقداري است که مي تواند در يک متغير اشاره گر قرار گيرد .
با عملگر & ميشه به آدرس يه متغير دسترسي داشت . مثلا در زير ما با آدرس يک متغير به اشاره گر بالايي مون مقدار ميديم :
[html]
int a;
int* aPtr;
aPtr = &a;
[/html]
آدرس يه متغير يه همچين عدديه : 0015F670 . لازم به ذکره که خود متغيرهاي اشاره گر داراي آدرس هستن .
همون طوري که ديدين ، آدرس متغير a رو تو يه اشاره گر به int قرار داديم . حالا هر تغييري که تو مقدار اين اشاره گر ميشه ، تو a هم اعمال ميشه .
فرش کنين که a = 3 باشه . ما اگه بخوايم aPtr رو چاپ کنيم يه آدرس ( آدرس متغير a ) چاپ ميشه . اگه بخوايم مقدار اون محلي که اين اشاره گر به اون جا اشاره مي کنه چاپ بشه از عملگر * به شکل زير استفاده مي کنيم :
[html]
cout << *aPtr;
[/html]
الان عدد 3 چاپ ميشه .
يه مطلب مهم تو آرايه ها و اشاره گرها که يه کمي دقت مي خواد :
قبلا تو آرايه ها گفتيم که آدرس خونه هاي يک آرايه پشت سر هم هستن . فرض کنين آرايه b رو با 4 عضو داريم . يعني :
[html]
int b [ 4 ];
[/html]
يه اشاره گر هم داريم که آدرس خونه اول اين آرايه رو داره . يعني :
[html]
int *bPtr = b;
[/html]
همون طور که مي دونين اسم آرايه معادل آدرس خونه اول آرايه است . يعني دستور زير با دستور بالايي فرقي نداره :
[html]
int *bPtr = &b [ 0 ];
[/html]
حالا ++bPtr باعث ميشه که bPtr به جاي عضو اول به عضو دوم اشاره کنه . دستور bPtr +=2 باعث ميشه که اشاره گر bPtr به عضو سوم آرايه اشاره کنه .
يادتونه گفتم ؟
"به غير از آرايه ها هيچ جا نميشه به صراحت گفت که آدرس دو خونه تو حافظه پشت سر هم باشه ."
اين جا هم يه چيزي ميگم :
استفاده از اين گونه محاسبات روي اشاره گري که به يک آرايه اشاره نمي کند خطاي منطقيه .
اين دو جمله کاملا به هم مربوطن .
خوب حالا تقريبا ميشه گفت به طور کامل وارد بحث کلاس ها و شيء گرايي شديم . از اين به بعد هر چقدر بگين مطلب رو کشش مي ديم . هر سوالي در اين رابطه هست بپرسين . يا من و يا اگر من هم بلد نباشم اين جا اساتيد حضور دارن که مي تونن راهنمايي کنن .
Destructor يا نابود کننده :
همون طوري که گفتيم سازنده يا Constructor تابع عضو خاصي از يه کلاسه که زماني فراخواني ميشه که يک شيء از اون کلاس ايجاد ميشه . جاي ديگه نمي تونيم به طور صريح اين تابع رو فراخواني کنيم . در مقابل Constructor ، نابود کننده يا Destructor قرار داره . Destructor هم به طور اتوماتيک احضار ميشه . خوب کي ؟
همون طوري که احتمالا حدس زدين ، زماني که يک شيء نابود ميشه .
خب شيء نابود ميشه يعني چي ؟
فرض کنين شيء رو داخل يه تابع تعريف کرديم . تابع با آکلاد باز شروع ميشه و با آکلاد بسته تموم ميشه . تموم ميشه يعني کار تابع به پايان مي رسه و اجرا خاتمه مي يابه . پس بنابراين وقتي اجراي برنامه به آکلاد بسته مي رسه يعني Scope اي که شيء تو اون تعريف شده ترک ميشه و اين به معناي نابودي شيء هست . وقتي برنامه رو Trace کنين ( يعني خط به خط اجرا کنين و تغييرات رو هر لحظه ببينين ) متوجه ميشين که وقتي اجراي برنامه به آکلاد بسته مي رسه ، Destructor احضار ميشه .
نابود کننده هم مثل سازنده هيچ چيزي برنمي گردونه . بنابراين در مورد Destructor هم از کلمه void به عنوان نوع داده برگشتي استفاده نمي کنيم . حالا نابود کننده بر خلاف سازنده هيچ آرگوماني هم نمي تونه بگيره . بنابراين ليست پارامترهاي نابود کننده هميشه خاليه . حالا چجوري به کامپايلر بفهمونيم که کدوم تابع عضو ما Destructor هست ؟
مثل سازنده بايد دقيقا اسم کلاس باشه ، فقط قبلش يه علامت tilde ( ~ ) هم مي ذاريم .
خوب من اون بالا يه جمله اي گفتم : "چجوري به کامپايلر بفهمونيم که کدوم تابع عضو ما Destructor هست ؟"
چه اصراريه به کامپايلر اينو بفهونيم ؟
بله درسته ...
چون کامپايلر سازنده و نابودکننده رو احضار ميکنه نه برنامه نويس . بنابراين بايد براش بشناسونيم .
يه فرق ديگه اي که سازنده با نابودکننده داره اينه که تو هر کلاس ميشه چند تا سازنده داشت ولي نابود کننده يدونه است . :46:
در مورد اشياء و توابع const :
اگه بخوايم يه شيئي رو به صورت const تعريف کنيم ، بايد قبل از نام کلاس کلمه کليدي const رو بذاريم . مثلا مي خوايم از کلاس Polynomial يه شيء const به نام poly بگيريم . مي نويسيم :
[html]
const Polynomial poly;
[/html]
يه نکته :
اگه بخواين از يکي از انواع داده اي اصلي ++C مثل int متغير const تعريف کنين ، بايد تو همون خط ، يعني تعريف متغير مقدار دهي اوليه کنين . در غير اين صورت Compile Error دريافت مي کنين با اين مضمون :
const object must be initialized if not extern
ولي براي دستور بالايي ما که يک نوع داده اصلي نيست ، بلکه يه کلاسه ، ايراد نمي گيره و اجازه مي ده برنامه اجرا بشه . ولي با اين همه يه warning ميده . اون هم در يه شرط . چه شرطي ؟ الان ميگم :
گفتيم که Constructor يه کلاس هنگامي فراخواني ميشه که شيئي از اون کلاس ايجاد بشه . خوب حالا ما مي تونيم هرکاري که دلمون مي خواد تو اون constructor انجام بديم . مثلا ما اين جا مي تونيم به داده هاي عضو کلاس مقدار اوليه بديم تا هنگامي که شيئي ايجاد مي شه همه داده هاي عضو مقدار اوليه داشته باشن . در اين صورت وقتي شيء به صورت const تعريف ميشه ، ديگه warning هم نميده . چون ديگه به محض تعريف شيء ، داده ها مقدار اوليه شونو توسط سازنده گرفتن . وقتي Constructor مون خالي باشه ، هنگام تعريف يک شيء از اون کلاس به صورت const ، پيغام هشدار يا warning دريافت مي کنيم .
براي تعريف يه تابع عضو به صورت const هم بايد کلمه const رو بعد از پرانتز بسته ليست پارامترها قرار بديم .
چند نکته در مورد توابع عضو const و اشياء const
1- اشياء const نمي تونن هيچ تابع عضوي رو احضار کنن ، مگر اينکه خود تابع عضو هم const باشه .
2- توابع عضو اعلان شده به صورت const نمي تونن داده هاي عضو يک شيء رو تغيير بدن .
3- خود تابع عضوي که const هست نمي تونه تابع عضو غير const همون کلاس رو احضار کنه .
4- سازنده ها و نابودکننده کلاس ها همواره شيء رو تغيير مي دن . بنابراين شيء شما چه const باشه و چه غير const ، اونا مجاز هستن عمليات خود رو روي شيء انجام بدن .
5- نمي تونيم سازنده ها و نابود کننده يک کلاس رو به صورت const تعريف کنيم .
6- يه شيء غير const مي تونه تابع عضو const همون کلاس رو احضار کنه .
فکر کنم ديگه تموم شد . اگه نکته اي موند بگين . :20:
سلام . چند روزي بود نبودم ... ببخشيد از وقفه اي که پيش اومد . سعي مي کنم تا يه هفته تموم کنم و برم . چون تا چند هفته بعد ديگه نمي تونم بيام . نه اينترنت و نه P30World . اگر هم تموم نشد يا دوستان ادامه ميدن و يا بعد از يه ماه خودم .
حالا .................
کلاس ها و توابع friend :
قبلا گفتيم که خارج از کلاس نميشه به داده ها يا توابع عضو يه کلاس که به صورت private تعريف شدن به طور مستقيم دسترسي داشت .
حالا اگه يه کلاس يا يه تابعي به صورت friend يه کلاس تعريف بشه ، اين کار شدنيه .
مي خوايم يه تابعي رو براي کلاس Chess به صورت friend يا دوست تعريف کنيم :
[html]
class Chess
{
friend void set ( int );
public:
.
.
.
private:
.
.
.
};
[/html]
مي خوايم يه کلاس ( کلاس A ) رو براي کلاس Chess به صورت friend تعريف کنيم :
[html]
class Chess
{
friend class A;
public:
.
.
.
private:
.
.
.
};
[/html]
نکته : ديدين که کلاس Chess تعيين کرد که کدوم تابع يا کلاس دوست اونه . چون قراره از داده هاي private کلاس Chess استفاده بشه . والا نميشه يه کلاس تعريف کنيم بگيم اين کلاس ما ، دوست کلاس شماست و راحت از داده هاي اون استفاده کنيم . در اين صورت کلا مباني و مفهوم برنامه نويسي شيء گرا زير سوال ميره . :18:
اشاره گر this و کاربرد اون :
گفتيم وقتي يه کلاس رو تعريف مي کنيم ، توابع عضو اين کلاس مي تونن به طور مستقيم به داده هاي عضو کلاس دسترسي داشته باشن . يعني فرض کنين ما متغير x رو به عنوان داده عضو براي کلاس A تعريف کرديم و مي خوايم تو يه تابع عضو مقدار اون رو تغيير بديم . سه راه داريم :
[html]
x = 10;
this->x = 10;
*this.x = 10;
[/html]
در حالت اول به طور ضمني از اشاره گر this براي دسترسي به داده عضو کلاس استفاده شده . در دومي و سومي هم به طور صريح . در اينجا تقريبا فرض کنين this يه شيء از کلاسه . چون this يه اشاره گر هست ، بنابراين براي دسترسي به داده هاي عضو کلاس مربوطه بايد به جاي . از <- استفاده کنيم . وقتي از * استفاده مي کنيم ، بايد از . براي دسترسي استفاده کنيم .
استفاده از اين اشاره گر در مبحث سربارگذاري عملگر ها مفيده .
در مورد تخصيص پوياي حافظه :
شکل کلي دستور اين طوريه :
[html]
نام متغير اشاره گري به يک نوع داده = new همون نوع داده ;
[/html]
اين براي گرفتن بود . براي پاک کردن هم :
[html]
delete نام متغير ;
[/html]
مثال :
[html]
int *aPtr = new int;
delete aPtr;
[/html]
مثال براي تخصيص حافظه براي يک آرايه :
[html]
int *aPtr = new int [ 21 ];
delete [] aPtr;
[/html]
تخصيص حافظه به صورت پويا يه کاربردش اينه که مثلا شما از کاربر بخواين يه عددي رو وارد کنه و شما از اون عدد به عنوان طول يک آرايه استفاده کنين . ( در حالت عادي شما نمي تونين از متغيرهاي غير ثابت براي طول آرايه استفاده کنين . )
نکته : اگه براي يه متغير به صورت پويا حافظه گرفته باشين و اونو پاک نکنين ( توسط دستور delete ) ، اين حافظه به صورت garbage يا آشغال در حافظه مي مونه و بلااستفاده باقي مي مونه .
البته زبان هاي پيشرفته ديگه مثل #C يه قابليتي به نام garbage collector دارن که مي تونن اين کارو به طور اتوماتيک انجام بدن ولي ++C نداره . ( البته تو نسخه Native ) .
در مورد اعضاي static يک کلاس :
فرض کنين يه کلاس ، يه متغير به اسم i داره . توسط constructor بهش مقدار 0 مي ديم . بنابراين با هر شيئي که از اين کلاس ايجاد ميشه ، يه کپي از متغير i براش ايجاد ميشه و بهش مقدار 0 داده ميشه . اين ويژگي يک عضو غير static کلاس هست .
ولي يک عضو static براي کل کلاس هست . 100 تا شيء هم از يه کلاس ايجاد بشه براي همشون به عضو static داريم . فقط يکبار مقدار اوليه به متغير static داده ميشه . اگه شيئي از کلاس نداشته باشيم باز هم ميشه به مقدار يه متغير static دسترسي داشت . ( با تايپ نام کلاس و دو تا دونقطه و نام متغير static ) .
فعلا تا اينجا بمونه ...
قبل از اينکه وارد مبحث Operator Overloading بشم ، يه مثال از کتاب ديتل در مورد کلاس ها ميارم ، خط به خط توضيح ميدم و آخر سر يه بار Trace مي کنم تا مطالب خوب جا بيفتن .
[html]
class Time
{
public:
Time();
void setTime( int, int, int );
void printUniversal();
void printStandard();
private:
int hour;
int minute;
int second;
};
[/html]
خوب ...
اين قطعه کد تعريف يک کلاس رو نشون ميده . اين قطعه کد يه فايل با پسوند h. هست نه cpp. ! برنامه هاي سي پلاس پلاس تو فايل هايي با پسوند cpp. ذخيره ميشن . ولي اين يه کد قابل اجرا نيست و فقط شامل پيش نمونه توابع عضو کلاس هست . گفتيم که اگه بخوايم از اشياء cin يا cout تو برنامه مون استفاده کنيم بايد فايل iostream رو توسط دستور پيش پردازنده include تو برنامه مون بگنجانيم . اين فايل رو داخل <> قرار مي داديم . اين نشون ميده که اين فايل داخل پوشه include کامپايلر قرار داره . اين قطعه کد بالايي ما هم يه چيزي مثل iostream هست . يعني براي اينکه از اين کلاس يه شيء بگيريم ، بايد اين فايل رو include کنيم . ولي اين فايل داخل پوشه include کامپايلر نيست . بنابراين اين رو داخل "" قرار مي ديم . در اين صورت هنگام پيوند دادن برنامه ، وقتي مي خواد تابع main اجرا بشه اين فايل رو در کنار فايلي که تابع main تو اون قرار داره مي گرده . همون طوري که مي بينين اسم کلاس ما ، Time هست . بعد آکلاد باز مياد و کلمه public رو مي بينين . يعني توابع زير اون حالت عمومي دارن و همه جا قابل مشاهده و فراخواني هستن . يه سازنده ، يه تابع به اسم setTime ، که سه پارامتر int مي گيره و چيزي بر نمي گردونه . تابع هاي printUniversal و printStandard که نه پارامتر دارن و نه چيزي بر مي گردونن . بعد سه تا متغير int از نوع private ، داده هاي عضو کلاس رو تشکيل مي دن .
همون طوري که مي بينين اين فايل ما حاوي پياده سازي توابع نيستن . بنابراين نياز به يه فايل ديگه داريم تا تو اون هم پياده سازي توابع رو داسته باشيم .
[html]
#include <iostream>
using std::cout;
#include <iomanip>
using std::setfill;
using std::setw;
#include "Time.h"
Time::Time()
{
hour = minute = second = 0;
}
void Time::setTime( int h, int m, int s )
{
hour = ( h >= 0 && h < 24 ) ? h : 0;
minute = ( m >= 0 && m < 60 ) ? m : 0;
second = ( s >= 0 && s < 60 ) ? s : 0;
}
void Time::printUniversal()
{
cout << setfill( '0' ) << setw( 2 ) << hour << ":"
<< setw( 2 ) << minute << ":" << setw( 2 ) << second;
}
void Time::printStandard()
{
cout << ( ( hour == 0 || hour == 12 ) ? 12 : hour % 12 ) << ":"
<< setfill( '0' ) << setw( 2 ) << minute << ":" << setw( 2 )
<< second << ( hour < 12 ? " AM" : " PM" );
}
[/html]
اين همون فايل پياده سازي هاي توابع هست . تو خط اول فايل iostream رو include کرديم . در خط بعد تعريف شيء cout رو انجام داديم . بعد براي استفاده از اشياء setw و setfill ، فايل iomanip رو include کرديم . بعد خود فايل h. کلاسمون رو include کرديم . يه نکته اي که هست اينه که براي تعريف توابع عضو کلاس ، قبل از اسم توابع ، اسم کلاس رو به همراه دو تا دونقطه مياريم . پياده سازي هم مثل پياده سازي معمولي تو برنامه نويسي ساخت يافته است .
يه فايل ديگه حاوي تابع main لازم داريم تا بتونيم از اين کلاس استفاده کنيم .
[html]
#include <iostream>
using std::cout;
using std::endl;
#include "Time.h"
int main()
{
Time t;
cout << "The initial universal time is ";
t.printUniversal();
cout << "\nThe initial standard time is ";
t.printStandard();
t.setTime( 13, 27, 6 );
cout << "\n\nUniversal time after setTime is ";
t.printUniversal();
cout << "\nStandard time after setTime is ";
t.printStandard();
cout << endl;
return 0;
}
[/html]
داخل تابع main ، يه شيء به اسم t از کلاس Time نمونه سازي کرديم . با اين دستور ، کامپايلر ميره سراغ Constructor کلاس مربوطه ، تا شيء رو بسازه . :46:
مي بينين که تو سازنده يا Constructor ، ما به داده هاي عضو کلاس ، مقدار صفر داديم . بنابراين داده هاي عضو شيء t هم مقادير صفر رو گيرن . چهار خط بعدي با فراخواني توابع چاپ داده هاي عضو کلاس ، اين مطلب رو تاييد مي کنن . ما يه تابع عضو ديگه به اسم setTime تو کلاسمون داشتيم که اجازه ميداد سه تا آرگومان بهش بفرستيم تا اون مقادير رو داخل داده هاي عضو قرار بده . بنابراين تو خط بعدي ما از اين تابع استفاده مي کنيم و مقادير خودمون رو بهش پاس ميديم و در تاييد اين مطلب دوباره توابع چاپ رو قراخواني مي کنيم .
خروجي برنامه بالاخره اين ميشه :
[html]
The initial universal time is 00:00:00
The initial standard time is 12:00:00 AM
Universal time after setTime is 13:27:06
Standard time after setTime is 1:27:06 PM
[/html]
سلام.
خیلی ممنون از این تاپیک مفید.
3 تا سوال:
1- چرا تو Main اون Time.h رو include کردید به جای Time.cpp ؟
2- هیچ وقت دلیل استفاده از این header ها رو تو C نفهمیدم! چرا مثل #C در جا تعریف و پیاده سازی نمی کنند؟
بعد اینی که گذاشتید خیلی ناجوره!
یعنی هرکی این Header رو داشته باشه، خیلی راحت فقط Class::Method رو می نویسه و تعریفش می کنه؟
آخه 1 کم با مفهوم کپسوله سازی و کلاً شیء گرایی نمی خونه!
3- چرا شما New نمی کنید این کلاس ها رو؟
آخه اونجوری که مثلاً می نویسید Time t که Constructor اجرا نمیشه! (یا حداقل تو #C اینجوریه!)
اینجوری فقط میشه یه اعضای Static دسترسی داشت! (یا حداقل تو #C اینجوریه!)
--
اون پست 23 هم فکر می کنم 1 کم عجله ای نوشتید و یک کم نا مفهوم شده!
در کل من Fan این تاپیک شدم!
از کنارش جم نخواهم خورد.
شما هم ادامه بدید.
با آرزوی موفقیت.
سلام دوست عزيز .
1- هميشه تو ++C فايل هدر رو include مي کنيم . چون هر سه فايل Time.h و Time.cpp و main.cpp در يک فولدر قرار دارن ، با include کردن Time.h ، کامپايلر مي تونه فايل cpp مربوط به اون هدر رو پيدا کنه و Link کنه .
2- اتفاقا اين کلاس رو به دو فايل h. و cpp. تبديل مي کنيم تا مفهوم شيء گرايي حفظ بشه . به کاربري که قصد استفاده از اين کلاس ما رو داره فقط فايل هدر داده ميشه که فقط اينو بدونه که اين کلاس ما چه توابعي دارن و چه آرگومان هايي مي گيرن . با ارائه توضيحات در فايل هدر توسط برنامه نويس کلاس ، ميشه بهتر کاربر برنامه نويس تابع main رو در جهت استفاده از کلاس راهنمايي کرد . فايل کامپايل شده فايل cpp کلاس هم به مشتري يا همون استفاده کننده از کلاس داده ميشه که بتونه به فايل h. پيوند بزنه . Source فايل cpp نبايد در دسترس مشتري قرار بگيره و اين همون مفهوم کپسوله سازي و مهندسي نرم افزار و تکنولوژي شيء گراييه که مشتري نبايد از چگونگي پياده سازي توابع اطلاع داشته باشه . فقط کافيه بدونه که چه توابعي وجود دارن و اين توابع چيکار مي کنن . ديگه لازم نيست بدونه که چه الگوريتمي براي انجام اين کار پياده سازي شده .
در مورد اين هم که هر کس فايل هدر رو داشته باشه مي تونه فايل cpp رو از روي اون بنويسه ، بايد بگم که خوب بنويسه . چه اشکالي داره . مهم اينه که به پياده سازي مدنظر ما لطمه وارد نشه .
3- تو ++C فقط کافيه بنويسيم Time t . در اين صورت Constructor ( البته سازنده پيش فرض يا Default Constructor ) اجرا ميشه . حالا فرض کنين Constructor ما يه پارامتر داره از نوع int . بنابراين هنگام تعريف شيء ، مثلا مي نويسيم ( Time t ( 3 . در اين حالت عدد 3 رو به عنوان آرگومان به Constructor مي فرستيم .
در مورد پست 23 هم حق کاملا با شماست . ولي قصد من اين بود که بعدا توسط مثال هايي به اين مطالب پرداخته بشه . فقط خواستم يه پيش نمونه ذهني در اين مورد ايجاد بشه .
موفق باشيد ... :11:
خیلی ممنون.
نمی خوام تاپیکتون رو الکی شلوغ کنم.
بعداً می تونید به همکار ها بگید که پستم رو حذف کنند.
---
با توجه به این توضیحی که در مورد Header دادید، یاد Interface افتادم!
شبیهش ه دیگه!
+
نفرمودید، میشه همزمان تعریف و پیاده سازی کرد یا نه!
در مورد Instancing ، مگر نباید بنویسیم ;() Time t = new Time ؟
یعنی این الان Error میده؟
باز هم ممنون از توضیحتون.
اختيار داريد . اين تاپيک براي آموزش هست چرا بايد سوال ها حذف شوند ؟ ( البته آموزش که نه ، شما استاد ما هستيد )نقل قول:
بله به اين هدرفايل مي گيم Interface و به پياده سازيش ميگيم Implementation . شبيه نيست دقيقا همونه .
اگه منظورتون از همزمان تعريف و پياده سازي کردن اينه که فايل h. و cpp. يدونه باشن بايد بگم بله ميشه . قبلا هم گفتم . ما به اين دو فايل تبديل مي کنيم تا شيوه به کار گرفته شده در پياده سازي توابع عضو به صورت پنهان باقي بمانند .
در مورد اون شکل Instancing هم که شما فرموديد به جاي اون بايد از دستور زير استفاده کنيم . يعني t از نوع اشاره گر به Time گرفته شود . در اين صورت ( شکل تعريف شما ) تخصيص حافظه براي t به صورت دايناميک و در هنگام اجراي برنامه گرفته مي شود که مي توانيم هر زمان که خواستيم با دستور delete آن را به حافظه بازگردانيم .
[html]
Time *t = new Time ();
[/html]
يه مثال هم در مورد ترتيب فراخواني سازنده و نابود کننده توسط کامپايلر ميگم :
[html]
#include <string>
using std::string;
class CreateAndDestroy
{
public:
CreateAndDestroy( int, string );
~CreateAndDestroy();
private:
int objectID;
string message;
};
[/html]
اين يه کلاسه که فقط يه Constructor داره و يه Destructor . دو تا هم داده عضو داره که يکيش از نوع int و دومي از نوع string که خود string هم يه کلاسه از کتابخانه استاندارد ++C .
الان اگه يه نکته بگم باز دوستان ميگن اينور و اونور نپر .
ولي ميگم . :46:
وقتي از شيء يه کلاسه ديگه تو کلاس خودمون استفاده مي کنيم ميگيم از خاصيت Composition يا ترکيب استفاده کرديم . که ميگيم CreateAndDestroy يه string داره . بعدا تو بحث ارث بري اين مفهوم رو بهتر مي فهمين . تو ارث بري هم ميگيم فلان يه فلان است .
تو اين جا message يه شيء از کلاس string هست که پياده سازي کلاس string تو کتابخانه استاندارد هستش و شما کافيه فقط اونو include کنين .
[html]
#include <iostream>
using std::cout;
using std::endl;
#include "CreateAndDestroy.h"
CreateAndDestroy::CreateAndDestroy( int ID, string messageString )
{
objectID = ID;
message = messageString;
cout << "Object " << objectID << " constructor runs "
<< message << endl;
}
CreateAndDestroy::~CreateAndDestroy()
{
cout << ( objectID == 1 || objectID == 6 ? "\n" : "" );
cout << "Object " << objectID << " destructor runs "
<< message << endl;
}
[/html]
اين هم پياده سازي اين کلاس .
يه نکته اي بگم .
لازم نيست تو نابود کننده اين کارايي که تو بالا انجام گرفته انجام بديم . چون اين يه مثاله و مي خوايم ترتيب فراخواني سازنده و نابود کننده معلوم بشه ، اين پيغام ها رو چاپ کرديم .
[html]
#include <iostream>
using std::cout;
using std::endl;
#include "CreateAndDestroy.h"
void create( void );
CreateAndDestroy first( 1, "(global before main)" );
int main()
{
cout << "\nMAIN FUNCTION: EXECUTION BEGINS" << endl;
CreateAndDestroy second( 2, "(local automatic in main)" );
static CreateAndDestroy third( 3, "(local static in main)" );
create();
cout << "\nMAIN FUNCTION: EXECUTION RESUMES" << endl;
CreateAndDestroy fourth( 4, "(local automatic in main)" );
cout << "\nMAIN FUNCTION: EXECUTION ENDS" << endl;
return 0;
}
void create( void )
{
cout << "\nCREATE FUNCTION: EXECUTION BEGINS" << endl;
CreateAndDestroy fifth( 5, "(local automatic in create)" );
static CreateAndDestroy sixth( 6, "(local static in create)" );
CreateAndDestroy seventh( 7, "(local automatic in create)" );
cout << "\nCREATE FUNCTION: EXECUTION ENDS" << endl;
}
[/html]
اين هم تابع main بود .
تو اينجا با مفهوم static بودن هم آشنا ميشين .
يه تابع تعريف کرديم به اسم create که نه چيزي مي گيره و نه چيزي برميگردونه .
بعد يه شيء سراسري يا Global از کلاسمون تعريف کرديم . چون سازنده مون دو تا پارامتر داره پس موقع تعريف شيء هم دو آرگومان براش مي فرستيم . اوليش از نوع int و دوميش از نوع string . ( رشته ها داخل " " قرار مي گيرن . ) چون سازنده فراخواني ميشه ، پس دستورات موجود تو اون اجرا ميشه . پس با اجراي برنامه ، ابتدا پيغام زير چاپ ميشه :
[html]
Object 1 constructor runs (global before main)
[/html]
تابع main شروع ميشه . پيغام زير چاپ ميشه :
[html]
MAIN FUNCTION: EXECUTION BEGINS
[/html]
باز يه شيء ايجاد مي کنيم و سازنده فراخواني ميشه و يه پيغام چاپ ميشه :
[html]
Object 2 constructor runs (local automatic in main)
[/html]
بعد يه شيء static تعريف مي کنيم و سازنده فراخواني ميشه :
[html]
Object 3 constructor runs (local static in main)
[/html]
حالا تابع create رو فراخواني مي کنيم . اجرا از تابع main منتقل ميشه به تابع create .
با اجراي تابع create پيغام زير چاپ ميشه :
[html]
CREATE FUNCTION: EXECUTION BEGINS
[/html]
با تعريف يک شيء داخل اين تابع سازنده فراخواني ميشه و در نتيجه پيغام زير چاپ ميشه :
[html]
Object 5 constructor runs (local automatic in create)
[/html]
يه شيء static ديگه تعريف مي کنيم و باز پيغام چاپ ميشه :
[html]
Object 6 constructor runs (local static in create)
[/html]
دوباره يه شيء ديگه و فراخواني سازنده و چاپ پيغام :
[html]
Object 7 constructor runs (local automatic in create)
[/html]
بعد پيغام زير چاپ ميشه :
[html]
CREATE FUNCTION: EXECUTION ENDS
[/html]
حالا يکي از نکات مهم اينجاست . مي بينين که به پايان تابع create رسيديم . پس با تموم شدن اجراي اين تابع ، اشيايي که تو اون تعريف شده بودن بايد نابود بشن و اين به معناي فراخواني نابود کننده است . پس براي دو شيء 7 و 5 ، نابودکننده احضار ميشه . چرا براي 6 نه ؟ چون اون يه static بود . :46:
پيغام هاي زير چاپ ميشن :
[html]
Object 7 destructor runs (local automatic in create)
Object 5 destructor runs (local automatic in create)
[/html]
اجراي برنامه برميگرده به تابع main .
دستور زير چاپ ميشه :
[html]
MAIN FUNCTION: EXECUTION RESUMES
[/html]
يه شيء ديگه تعريف مي کنيم و سازنده فراخواني ميشه و پيغام زير چاپ ميشه :
[html]
Object 4 constructor runs (local automatic in main)
[/html]
بعد دستور زير چاپ ميشه :
[html]
MAIN FUNCTION: EXECUTION ENDS
[/html]
حالا مهمترين نکته که غرض از اين مثال هم ذکر اين نکته بود .
الان کار تابع main هم تموم شد و نوبت مي رسه به نابود شدن شيء ها يکي پس از ديگري . چه static و چه غير static . حالا کدوم يکي پس از کدوم يکي ؟ اين مهمه ! :46:
چون شيء 4 آخرين شيئي بود که ايجاد شده بود پس اول اون نابود ميشه . چاپ پيغام زير هم اين مطلب رو تاييد مي کنه :
[html]
Object 4 destructor runs (local automatic in main)
[/html]
بعد شيء 2 نابود مي شه :
[html]
Object 2 destructor runs (local automatic in main)
[/html]
حالا اول اون شيء static که تو تابع create بود نابود ميشه و بعد static موجود تو تابع main :
[html]
Object 6 destructor runs (local static in create)
Object 3 destructor runs (local static in main)
[/html]
آخر سر هم اون شيء Global نابود ميشه :
[html]
Object 1 destructor runs (global before main)
[/html]
بنابراين خروجي کامل برنامه اين ميشه :
[html]
Object 1 constructor runs (global before main)
MAIN FUNCTION: EXECUTION BEGINS
Object 2 constructor runs (local automatic in main)
Object 3 constructor runs (local static in main)
CREATE FUNCTION: EXECUTION BEGINS
Object 5 constructor runs (local automatic in create)
Object 6 constructor runs (local static in create)
Object 7 constructor runs (local automatic in create)
CREATE FUNCTION: EXECUTION ENDS
Object 7 destructor runs (local automatic in create)
Object 5 destructor runs (local automatic in create)
MAIN FUNCTION: EXECUTION RESUMES
Object 4 constructor runs (local automatic in main)
MAIN FUNCTION: EXECUTION ENDS
Object 4 destructor runs (local automatic in main)
Object 2 destructor runs (local automatic in main)
Object 6 destructor runs (local static in create)
Object 3 destructor runs (local static in main)
Object 1 destructor runs (global before main)
[/html]
سلام دوستان عزيز .
لطفا يه نظري تا اينجاي مطالب بدين تا من ادامه بدم . چون ديدگاهي که من نسبت به مطالب گفته شده دارم با ديدگاه يه فرد غير از خودم کاملا فرق مي کنه . من الان نمي دونم که از روي مطالب دارم مي پرم ؟ خيلي خلاصه مي گم ؟ خيلي کشش مي دم ؟ ... ؟
اگه لازم باشه باز هم فعلا مثال بيارم . چون مطالب بقيه به طور جدي مربوط به تکنولوژي شيءگرايي ميشه و بحث کاملا جدي تره . مخصوصا مبحث ارث بري و polymorphism .
ديگه اصلا تصميم ندارم سراغ ساخت يافته برم . متغير رو چجوري معرفي مي کنن . چجوري ورودي مي گيرن . با نوع داده double چيکار مي کنن . چه رنجي رو ساپورت مي کنه . اولويت Operator ها به چه صورته و ... .
خوبه ادامه بده....
ممنون.
بد نیست.
هر چند از آخرین درسی که دادی، خوشم نیومد!!!
آخه خیلی کشش دادی، وسط کار یادم رفت که مطلب چی بوده! :دی
ولی ادامه بده.
+
موفق باشی.
سلام دوست عزيز . جالبه ! :20: راجع به پست 23 گفتين خيلي خلاصه اس . الان هم ميگين خيلي کش ميدم .نقل قول:
+++++++++++++++
ببخشيد Unit چيه ؟نقل قول:
حل شد........
به یه فایل cpp. همراه با همۀ فایلهایی که توش include# شده میگن یه unit. تعداد unitها در یه project برابر با تعداد فایل های cpp.یه.
----------------
آموزش خوبه! البته به نظرم مخاطب یه چیزایی باید از قبل بدونه. مثال هم کم داره!
ادامه بده! من که منتظر inheritance هستم :20:
سلام به همه
من تازه كارم و دوست دارم C++ رو از پايه ياد بگيرم لطفا راهنمايي كنيد
آخه شما اول پرسيدين اگه يه يونيت ايجاد کنيم دو تا فايل h. و cpp. ايجاد مي کنه .نقل قول:
حالا من در مورد اين دو تا فايل در پست هاي 24 و 26 توضيح داده ام . مي تونين به اونا مراجعه کنين . h. معمولا حاوي prototype هاي توابع عضو کلاسمون هستن به اضافه تعريف کلاس و cpp. هم حاوي پياده سازي يا implementation توابع .
تازه کار تو ++C يا تازه کار تو برنامه نويسي يا نه تازه کار تو کامپيوتر ؟ :46:نقل قول: