برنامه‌ي زير ، يك عدد صحيح را با يك عدد مميز شناور جمع مي‌كند :

int main()
{ // adds an int value with a double value:
int n = 22 ;
double p = 3.1415 ;
p += n ;
cout << " p = " << " , n = " << n << endl ;
return 0;
}

خروجي برنامه‌ي بالا بصورت زير است :

p = 24.1415 , n = 22

در برنامه‌ي بالا ابتدا مقدار n از مقدار صحيح 22 به مقدار اعشاري 22.0 گسترش مي‌يابد و سپس اين مقدار با مقدار قبلي p جمع مي‌شود ، حاصل يك عدد مميز شناور است .

************************************************************

مثال : گسترش نوع

اين برنامه يك char را به int ، float و double گسترش مي‌دهد :

int main()
{ // prints promoted values of 65 from char to double :
char c = 'A' ;   cout << " char c = " << c << endl ;
short k = c ;  cout << " short k = " << k << endl ;
int m = k ;       cout << " int m = " << m << endl ;
long n = m ;    cout << " long n = " << n << endl ;
float x = n ;    cout << " float x = " << x << endl ;
double y = x ; cout << " double y = " << y << endl ;
return 0;
}

خروجي برنامه :

char c = A
short k = 65
int m = 65
long n = 65
float x = 65
double y = 65

در مثال بالا ابتدا متغير c از نوع char تعريف شده و كاراكتر 'A' در آن قرار گرفته است . سپس مقدار c درون متغير k كه از نوع short است قرار گرفته . چون نوع k بالاتر از نوع c است ، پس مقدار c به نوع short گسترش مي‌يابد و مقدار 65 كه معادل عددي كاراكتر 'A' است درون k قرار مي‌گيرد .

در خط بعدي ، مقدار k درون متغير m قرار مي‌گيرد . m از نوع int است كه نوع بالاتري از short مي‌باشد . پس مقدار k به int گسترش مي‌يابد و اين مقدار گسترش يافته درون m گذاشته مي‌شود .

به همين ترتيب در خطوط بعدي ، مقدار m به نوع long گسترش يافته و درون n قرار مي‌گيرد . مقدار n نيز به نوع float گسترش يافته و درون x قرار مي‌گيرد . مقدار x نيز به نوع double گسترش مي‌يابد و درون y قرار مي‌گيرد . دقت كنيد كه مقدار x و y در خروجي بجاي آنكه 65.0 باشد بشكل 65 نشان داده شده . اين مقدار يك عدد صحيح نيست اما چون قسمت اعشاري آن صفر است ، اعشار حذف شده و 65 تنها نشان داده شده است .

تبديل نوع ، گسترش نوع

در قسمت‌هاي قبلي با محاسبات رياضي انواع عددي آشنا شديم اما در محاسبات رياضي كه انجام داديم همه‌ي متغيرها از يك نوع بودند . اگر بخواهيم در يك محاسبه دو يا چند متغير از انواع مختلف بكار ببريم چه اتفاقي مي‌افتد ؟

قانون كلي اين است كه در محاسباتي كه چند نوع متغير وجود دارد ، جواب هميشه بشكل متغيري است كه دقت بالاتري دارد . يعني اگر يك عدد صحيح را با يك عدد مميز شناور جمع كنيم ، پاسخ بشكل مميز شناور است . به اين منظور ابتدا متغيرها و مقاديري كه از نوع با دقت كمتر هستند به نوع با دقت بيشتر تبديل مي‌شوند و سپس محاسبه روي آنها انجام مي‌شود . پس اگر يك عدد صحيح را اب يك عدد مميز شناور جمع كنيم ، ابتدا عدد صحيح تبديل به يك عدد مميز شناور مي‌شود ، سپس اين عدد با عدد مميز شناور ديگر جمع بسته مي‌شود و واضح است كه پاسخ نيز بشكل مميز شناور خواهد بود . اين كار بشكل خودكار انجام مي‌گيرد و ++C در چنين محاسباتي بشكل خودكار متغيرهاي با دقت كمتر را به متغيرهايي با دقت بيشتر تبديل مي‌كند تا همه‌ي متغيرها از يك نوع شوند و آنگاه محاسبه را انجام مي‌دهد و پاسخ را نيز بشكل نوع با دقت بيشتر به دست مي‌دهد . به اين عمل گسترش مي‌گويند .

اما اگر عكس اين عمل مورد نظر باشد ، يعني اگر بخواهيم يك متغير صحيح را با يك متغير مميز شناور جمع ببنديم و بخواهيم كه حاصل از نوع صحيح باشد نه مميز شناور بايد چكار كنيم ؟ در چنين حالتي از عملگر تبديل نوع استفاده مي‌كنيم . اين تبديل خودكار نيست بلكه كاملاٌ بايد دستي انجام شود و برنامه نويس ، خود بايد مراقب اين عمل باشد . براي اينكه مقدار يك متغير از انواع مميز شناور را به نوع صحيح تبديل كنيم از عبارت ()int استفاده مي‌كنيم . مثال‌هاي زير تبديل نوع و گسترش نوع را نشان مي‌دهند.

مثال : تبديل نوع

اين برنامه ، يك نوع double را به نوع int تبديل مي‌كند :

int main()
{ // casts a double value as an int
double v = 1234.987 ;
int n ;
n = int ( v ) ;
cout << " v = " << v << " , n = " << n << endl ;
return 0;
}

خروجي برنامه‌ي بالا بصورت زير است :

v = 1234.987 , n = 1234

در اين برنامه ، متغير v از نوع double و با مقدار 1234.987 تعريف شده است . همچنين متغير n از نوع int تعريف شده است . در خط پنجم از كد بالا از تبديل نوع استفاده شده است . با استفاده از اين دستور مقدار v ابتدا به نوع int تبديل مي‌شود و سپس اين مقدار درون n قرار مي‌گيرد . خروجي برنامه نشان مي‌دهد كه وقتي از عملگر ()int استفاده كنيم ، عدد مميز شناور بريده مي‌شود ، گرد نمي‌شود . يعني قسمت اعشاري عدد بطور كامل حذف مي‌شود و فقط قسمت صحيح آن باقي مي‌ماند . بنابراين وقتي عدد 1234.987 به نوع int‌ تبديل شود ، حاصل برابر با 1234 خواهد بود و قسمت اعشاري آن (هر قدر هم بزرگ باشد) ناديده گرفته مي‌شود .

در تبديل نوع ، همواره نوع و مقدار متغيرهاي تبديل شده بدون تغيير مي‌ماند . در برنامه‌ي بالا ، مقدار v تا پايان برنامه به همان مقدار 1234.987 باقي مانده و نوع v نيز تغيير نكرده و همچنان از نوع double مانده است . تنها اتفاقي كه افتاده اين است كه مقدار v در يك محل موقتي تبديل به int شده تا اين مقدار درون n قرار گيرد .

اگر فقط بعضي از شمارشگرها مقداردهي شوند ، آنگاه ساير شمارشگرها كه مقداردهي نشده‌اند مقادير متوالي بعدي را خواهند گرفت :

enum Day {SAT=1,SUN,MON,TUE,WED,THU,FRI}

دستور بالا مقادير 1 تا 7 را بترتيب به روزهاي هفته تخصيص خواهد داد .

همچنين دو يا چند شمارشگر در يك فهرست مي‌توانند مقادير يكساني داشته باشند :

enum Answer {NO=0,FALSE=0,YES=1,TRUE=1,OK=1}

در كد بالا دو شمارشگر NO و FALSE داراي مقادير يكسان 0 و شمارشگرهاي YES و TRUE و OK نيز داراي مقدار يكسان 1 هستند . پس كد زير معتبر است و به درستي كار مي‌كند :

Answer answer ;
cin >> answer ;
if ( answer == TRUE ) cout << " you said OK . " ;

به اولين خط كد فوق نگاه كنيد . اين خط ممكن است كمي عجيب بنظر برسد . اين خط متغيري بنام answer از نوع Answer تعريف مي‌كند . اولين قانون در برنامه‌هاي ++C را بخاطر بياوريد : " ++C بين حروف كوچك و بزرگ تفاوت قائل است " . پس Answer با answer متفاوت است . Answer را در خط‌هاي قبلي يك نوع شمارشي تعريف كرديم و answer را متغيري كه از نوع Answer است . يعني answer متغيري است كه مي‌تواند يكي از مقادير YES يا TRUE يا OK يا NO يا FALSE را داشته باشد . نحوه‌ي انتخاب نام‌ها آزاد است . اما بيشتر برنامه‌نويسان از توافق زير در برنامه‌هايشان استفاده مي‌كنند :

1- براي نا‌م‌ ثابت‌ها از حروف بزرگ استفاده كنيد .
2- اولين حرف از نام نوع شمارشي را با حرف بزرگ بنويسيد .
3- در هر جاي ديگر از حروف كوچك استفاده كنيد .

رعايت اين توافق به خوانايي برنامه‌ي شما كمك مي‌كند . همچنين سبب مي‌شود كه انواع شمارشي كه كاربر تعريف مي‌كند از انواع استاندارد مثل int ، float ، char راحت‌تر متمايز شوند .

شمارشگرها قواعد خاصي دارند . نام شمارشگر بايد معتبر باشد . يعني كلمه‌ي كليدي نباشد ، با عدد شروع نشود و نشانه‌هاي رياضي نيز نداشته باشد . پس تعريف زير غير معتبر است :

enum Score {A+ , A , A- , B+ , B , B- , C+ , C , C- }

زیرا +A و +B و -A و -B و -C و +C نام‌هاي غير معتبري هستند چون در نام آنها از نشانه‌هاي رياضي استفاده شده است .

علاوه براين ، شمارشگرهاي همنام نبايد در محدوده‌هاي مشترك استفاده شوند . براي مثال تعريف‌هاي زير را در نظر بگيريد :

enum Score { A , B , C , D }
enum Group { AB , B , BC }

دو تعريف بالا غير مجاز است زيرا شمارشگر B در هر دو تعريف Score و Group آمده است .

و آخر اينكه نام شمارشگرها نبايد بعنوان نام متغيرهاي ديگر در جاهاي ديگر برنامه استفاده شود . مثلاٌ :

enum Score  {A , B , C , D}
float B ;
char C ;

در تعريف‌هاي بالا B و C را نبايد بعنوان نام متغيرهاي ديگر بكار برد زيرا اين نام‌ها در نوع شمارشي Score بكار رفته است . پس اگر اين سه تعريف در يك محدوده باشند ، دو تعريف آخري غير مجاز خواهند بود . انواع شمارشي براي توليد كد " خود مستند " بكار مي‌روند . يعني كدي كه براحتي درك شود و نياز به توضيحات اضافي نداشته باشد . مثلاٌ تعاريف زير خود مستند هستند زيرا براحتي نام و نوع كاربرد و محدوده‌ي مقاديرشان درك مي‌شود :

enum Color { RED , GREEN , BLUE , BLACK , ORANGE }
enum Volume { ZERO , LOW , MEDIUM , HIGH }
enum Level1 { BEGINNER , ADVANCED , EXPERT }
enum Language { C , DELPHI , JAVA , PERL }
enum Gender { MALE , FEMALE }