شرط‌هاي مركب

شرط‌هايي مانند n%d و x>=y مي‌توانند بصورت يك شرط مركب باهم تركيب شوند . اين كار با استفاده از عملگرهاي منطقي && (and) و || (or) و ! (not) صورت مي‌گيرد . اين عملگرها بشكل زير تعريف مي‌شوند :

p && q  درست است اگر و تنها اگر هم p و هم q هر دو درست باشند .

p || q  نادرست است اگر و تنها اگر هم p و هم q هر دو نادرست باشند .

p !  درست است اگر و تنها اگر q نادرست باشد .

براي مثال عبارت زير نادرست است اگر و تنها اگر n%d برابر صفر و x كوچكتر از y باشد :

( n%d || x>=y )

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

مثال : استفاده از شرط‌هاي مركب

برنامه‌ي زير براي يافتن مينيمم بين سه عدد از شرط‌هاي مركب استفاده كرده است :

int main()
{   int  n1 , n2 , n3 ;
    cout << " enter three integers : " ;
    cin >> n1 >> n2 >> n3 ;
    if ( n1 <= n2 && n1 <= n3 )   cout << " their minimum is : "
        << n1 << endl ;
    if ( n2 <= n1 && n2 <= n3 )   cout << " their minimum is : "
        << n2 << endl ;
    if ( n3 <= n1 && n3 <= n2 )   cout << " their minimum is : "
        << n3 << endl ;
}

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

enter three integers : 77  33  55
their minimum is : 33

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

مثال : ورودي كاربر پسند

اين برنامه به كاربر امكان مي‌دهد كه براي پاسخ مثبت 'y' يا 'Y' را وارد كند :

int main()
{   char  ans ;
    cout << " are you enrolled (y/n) : " ;
    cin >> ans ;
    if ( ans == 'Y' || ans == 'y' )  cout << " you are enrolled . \ n " ;
    else  cout << " you are not enrolled . \ n " ;
}

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

are you enrolled (y/n) : N
you are not enrolled .

برنامه‌ي بالا از كاربر پاسخي مي‌خواهد و y و n را به عنوان جواب‌هاي ممكن پيشنهاد مي‌دهد . اما هر كاراكتر ديگري را هم مي‌پذيرد و اگر آن كاراكتر 'y' يا 'Y' نباشد فرض مي‌كند كه پاسخ كاربر no است .

مثال : استفاده از بلوك‌ها بعنوان محدوده‌ي حوزه

در اين برنامه سه متغير مختلف با نام n استفاده شده است :

int main()
{   int  n=44 ;
    cout << " n = " << n << endl ;
    {   int  n ;                                      // scope extends over 4 lines
        cout << " enter an integer : " ;
        cin >> n ;
        cout << " n = " << n << end ;
    }
    {  cout << " n = " << n << endl ;   // n that was declared first
    }
    {  int  n ;                                       // scope extends over 2 lines
       cout << " n = " << n << endl ;
    }
       cout << " n = " << n << endl ;    // n that was declared first
}

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

n = 44
enter an integer : 77
n = 77
n = 44
n = 4251897
n = 44

برنامه‌ي بالا سه بلوك داخلي دارد . اولين بلوك ، يك n جديد اعلان مي‌كند كه فقط درون همان بلوك ، معتبر و موجود است . اين n متغير n اصلي را پنهان مي‌كند . بنابراين وقتي مقدار 77 در اين بلوك از ورودي دريافت مي‌شود ، اين مقدار درون n محلي قرار مي‌گيرد و مقدار n اصلي بدون تغيير مي‌ماند . در دومين بلوك ، n جديدي تعريف نمي‌شود ، لذا حوزه‌ي n اصلي اين بلوك را نيز شامل مي‌شود . پس در سومين دستور خروجي ، مقدار n اصلي يعني 44 چاپ مي‌شود . بلوك سوم برنامه نيز مانند بلوك اول يك n جديد تعريف مي‌كند كه n اصلي را پنهان مي‌كند ، اما اين n جديد مقداردهي نمي‌شود . بنابراين در چهارمين خروجي يك مقدار زباله چاپ مي‌شود . در خط انتهايي برنامه ، تمام بلوك‌هاي محلي به پايان مي‌رسند . به همين خاطر وقتي در اين خط دستور چاپ براي n صادر مي‌شود ، مقدار n اصلي يعني 44 چاپ مي‌شود . 

بلوك‌هاي دستورالعمل

يك بلوك دستورالعمل زنجيره‌اي از دستورالعمل‌هاست كه درون براكت { } محصور شده ، مانند اين :

{    int  temp = x ;
     x = y ;
     y = temp ;
}

در برنامه‌هاي ++C يك بلوك دستورالعمل مانند يك دستورالعمل تكي است . يعني هرجا كه يك دستورالعمل بتواند تنها استفاده شود ، يك بلوك دستورالعمل نيز مي‌تواند استفاده شود . به مثال زير دقت كنيد :

مثال : يك بلوك دستورالعمل درون يك دستور if

اين برنامه دو عدد صحيح را گرفته و به ترتيب بزرگتري ، آن‌ها را چاپ مي‌كند :

int main()
{   int  x , y ;
    cout << " enter two integers : " ;
    cin >> x >> y ;
    if  ( x > y )  { int  temp = x ;
                        x = y ;
                        y = temp ;
                      }                  // swap x and y
    cout << x << " <= " << y << endl ;
}

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

enter two integers : 66  44
44 <= 66

سه دستور درون بلوك ، مقادير x و y را به ترتيب بزرگتري مرتب مي‌كنند ، به اين شكل كه اگر آن‌ها خارج از ترتيب باشند ، جاي آن دو را عوض مي‌كنند . براي اين جابه‌جايي به سه گام متوالي و يك محل ذخيره سازي موقتي احتياج داريم كه در اينجا temp ناميده شده . برنامه يا بايد هر سه دستورالعمل را اجرا كند و يا هيچ يك را نبايد اجرا كند . وقتي اين سه دستور را درون بلوك دستورالعمل قرار دهيم ، منظور فوق برآورده مي‌شود . توجه كنيد كه متغير temp درون بلوك تعريف شده است . اين سبب مي‌شود كه متغير مذكور درون بلوك ، يك متغير محلي (Local variable) باشد . يعني اين متغير فقط وقتي ايجاد مي‌شود كه بلوك اجرا شود . اگر شرط نادرست باشد (يعني x<=y باشد) ، متغير temp هرگز موجود نخواهد شد . اين مثال روش مناسبي براي محلي كردن اشياء را نشان مي‌دهد ، طوري كه اشياء وقتي ايجاد مي‌شوند كه به آن‌ها نياز است . همچنين توجه كنيد كه يك برنامه‌ي ++C خودش يك بلوك دستورالعمل است كه توسط تابع اصلي ()main ساخته شده است . يادآوري كنم كه حوزه‌ي متغير قسمتي از يك برنامه است كه متغير مي‌تواند در آن استفاده شود . اين حوزه از نقطه‌اي كه متغير اعلان مي‌شود شروع شده و تا پايان همان بلوك ادامه مي‌يابد . پس يك بلوك مي‌تواند به عنوان محدوده‌ي حوزه‌ي متغير استفاده شود . يكي از نتايج مهم اين كار آن است كه مي‌توانيم از متغيرهاي متفاوتي با يك نام در قسمت‌هاي مختلف برنامه استفاده كنيم . 

يك خطاي برنامه‌نويسي متداول

اين برنامه خطادار است :

int main()
{      int  n ;
       cout << " enter an integer : " ;
       cin >> n ;
       if  ( n = 22 )  cout << " n = 22 " << endl ; // LOGICAL ERROR !
       else  cout << " n != 22 " << endl ;
}

خروجي برنامه بشكل زير است :

enter an integer : 77
n = 22

ظاهراٌ منطق برنامه‌ي بالا به اين گونه است كه عددي از ورودي دريافت مي‌شود و اگر اين عدد با 22 برابر بود ، پيغام برابري چاپ مي‌شود و در غير اين صورت ، پيغام عدم برابري چاپ مي‌گردد . ولي خروجي بالا نشان مي‌دهد كه برنامه درست كار نمي‌كند . عدد 77 وارد شده ولي پيغام 22=n در خروجي چاپ شده است ! ايراد در خط پنجم برنامه است . عبارت 22=n مقدار 22 را در n قرار داده و مقدار قبلي آن كه 77 است را تغيير مي‌دهد . اما عبارت 22=n به عنوان شرط دستور if استفاده شده پس به عنوان يك عبارت صحيح با مقدار 22 برآورد مي‌شود . لذا شرط (22=n) به عنوان درست تفسير مي‌شود زيرا فقط مقدار 0 به معناي نادرست است . به همين دليل دستور قبل از else اجرا مي‌شود . خط پنجم بايد اين طور نوشته مي‌شد :

if  ( n == 22 )  cout << " n = 22 " << endl ;     // CORRECT

خطاي نشان داده شده در اين مثال ، خطاي منطقي (Logical Error) نام دارد . خطاي زمان كامپايل (مانند از قلم افتادن يك سميكولن) به وسيله‌ي كامپايلر گرفته مي‌شود . خطاهاي زمان اجرا (مانند تقسيم بر صفر) نيز به وسيله‌ي سيستم‌عامل گرفته مي‌شود اما خطاي منطقي را نمي‌توان با اين ابزارها كشف كرد .

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

مثال : مينيمم سه عدد صحيح

اين برنامه از ميان سه عدد صحيح كوچكترين را پيدا مي‌كند :

int main()
{   int  n1 , n2 , n3 ;
    cout << " enter three integers : " ;
    cin >> n1 >> n2 >> n3 ;
    int  min = n1                          // now min <= n1
    if ( n2 < min )  min = n2 ;       // now min <= n1 and n2
    if ( n3 < min )  min = n3 ;       // now min <= n1 , n2 and n3
    cout << " their minimum is : " << min << endl ;
}

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

enter three integers : 77  33  55
their minimum is : 33

سه توضيح ذكر شده در برنامه ، نحوه‌ي پيشرفت كار را نشان مي‌دهد :

ابتدا min برابر با n1 فرض مي‌شود ، لذا min مينيمم مجموعه‌ي {n1} مي‌شود . پس از اجراي اولين if مقدار min برابر با n2 مي‌شود اگر n2 از مقدار فعلي min كوچكتر باشد . پس min برابر مينيمم مجموعه‌ي {n1,n2} مي‌شود . آخرين دستور if ، مقدار min را برابر n3 قرار مي‌دهد اگر n3 از مقدار فعلي min كوچكتر باشد . بنابراين در نهايت مقدار min برابر با مينيمم مجموعه‌ي {n1,n2,n3} خواهد شد .

عملگرهاي مقايسه‌اي

در ++C شش عملگر مقايسه‌اي وجود دارد :

< , > , <= , >= , == , !=

هر يك از اين شش عملگر به شكل زير بكار مي‌روند :

x < Y        // x is smaller than y
x > y        // x is bigger than y
x <= y      // x is smaller than y , or equal by y
x >= y      // x is bigger than y , or equal by y
x == y      // x is equal by y
x != y       // x is not equal by y

اين‌ها مي‌توانند براي مقايسه‌ي مقدار عبارات با هر نوع ترتيبي استفاده شوند . عبارت حاصل به عنوان يك شرط تفسير مي‌شود . مقدار اين شرط صفر است اگر شرط نادرست باشد . براي نمونه عبارت :

7 * 8 < 6 * 9

برابر با صفر ارزيابي مي‌شود ، به اين معني كه اين شرط نادرست است .

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

مثال : مينيمم دو عدد صحيح

اين برنامه مشخص مي‌كند كه از دو عدد صحيح ورودي ، كدام كوچكتر است :

int main()
{     int  m , n ;
      cout << " please enter two integers : " ;
      cin >> m >> n ;
      if  ( m < n )    cout << m << " is the minimum . " << endl ;
      else  cout << n << " is the minimum . " << endl ;
}

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

please enter two integers : 25  45
25 is the minimum .

دقت كنيد كه در ++C عملگر جايگزيني با عملگر برابري فرق دارد . عملگر جايگزيني يك مساوي تكي "=" است ولي عملگر برابري دو مساوي "==" است . مثلاٌ دستور 33=x مقدار 33 را در x قرار مي‌دهد ولي دستور 33==x بررسي مي‌كند كه آيا مقدار x با 33 برابر است يا خير . درك اين تفاوت اهميت زيادي دارد .