C ++ හි “->” ක්‍රියාකරු යනු කුමක්ද?

C ++ / STL හි සැඟවුණු විශේෂාංග සහ අඳුරු කොන කියවීමෙන් පසු comp.lang.c++.moderated, පහත දැක්වෙන ස්නිපටය විෂුවල් ස්ටුඩියෝ 2008 සහ ජී ++ 4.4 යන දෙවර්ගයේම සම්පාදනය කර වැඩ කිරීම ගැන මම පුදුමයට පත් වීමි.

මෙන්න කේතය:

#include <stdio.h>
int main()
{
    int x = 10;
    while (x --> 0) // x goes to 0
    {
        printf("%d ", x);
    }
}

ප්‍රතිදානය:

9 8 7 6 5 4 3 2 1 0

මම හිතන්නේ මෙය සී, එය ජීසීසී හි ද ක්‍රියාත්මක වන නිසා. මෙය ප්‍රමිතියෙන් අර්ථ දක්වා ඇත්තේ කොහෙන්ද? එය පැමිණියේ කොහෙන්ද?

-->ක්‍රියාකරුවෙකු නොවේ. ඇත්ත වශයෙන්ම එය වෙනම ක්‍රියාකරුවන් දෙදෙනෙකි, --සහ >.

කොන්දේසිගත කේතය අඩු xවන අතර, එහි xමුල් (අඩු නොකළ) අගය නැවත ලබා දෙන අතර, පසුව මුල් අගය ක්‍රියාකරු 0භාවිතා කිරීම සමඟ සංසන්දනය කරයි >.

වඩා හොඳින් අවබෝධ කර ගැනීම සඳහා ප්‍රකාශය පහත පරිදි ලිවිය හැකිය:

while( (x--) > 0 )

නැතහොත් සම්පූර්ණයෙන්ම වෙනස් දෙයක් සඳහා ... xවිනිවිදක 0.

while (x --\
            \
             \
              \
               > 0)
     printf("%d ", x);

එතරම් ගණිතමය නොවේ, නමුත් ... සෑම පින්තූරයකම වචන දහසක් පින්තාරු කරයි ...

එය ඉතා සංකීර්ණ ක්‍රියාකරුවෙකි, එබැවින් ISO / IEC JTC1 (ඒකාබද්ධ තාක්ෂණික කමිටුව 1) පවා එහි විස්තරය C ++ ප්‍රමිතියේ විවිධ කොටස් දෙකක තැබීය.

පසෙකට විහිලු, ඔවුන් දෙදෙනා වෙනස් ක්රියාකරුවන් වේ: --හා >§5.2.6 / 2 පිළිවෙලින් විස්තර §5.9 C ++ 03 සම්මත.

එය සමාන වේ

while (x-- > 0)

x--(පසු අඩුවීම) ඒ හා සමාන වේ x = x-1, කේතය පහත පරිදි පරිවර්තනය වේ:

while(x > 0) {
    x = x-1;
    // logic
}
x--;   // The post decrement done when x <= 0

x ප්‍රතිවිරුද්ධ දිශාවට ඊටත් වඩා වේගයෙන් ශුන්‍යයට යා හැකිය:

int x = 10;

while( 0 <---- x )
{
   printf("%d ", x);
}

8 6 4 2

ඊතලයක් මඟින් ඔබට වේගය පාලනය කළ හැකිය!

int x = 100;

while( 0 <-------------------- x )
{
   printf("%d ", x);
}

90 80 70 60 50 40 30 20 10

;)

එය

#include <stdio.h>
int main(void){
     int x = 10;

     while( x-- > 0 ){ // x goes to 0

       printf("%d ", x);
     }

     return 0;
}

අවකාශය මඟින් දේවල් විහිලු, --අඩු වීම හා >සංසන්දනය කරයි.

භාවිතය -->historical තිහාසික අදාළත්වයක් ඇත. X86 ගෘහ නිර්මාණ ශිල්පය වැඩි කිරීමට වඩා වේගවත් කිරීම (සහ තවමත් සමහර අවස්ථාවල පවතී). භාවිතා -->කරන බව හඟවන xයන්නේ 0, සහ ගණිතමය පසුබිම් සහිත අය කියා සිටිනවා.

while( x-- > 0 )

එය විග්‍රහ කරන ආකාරයයි.

සම්පූර්ණයෙන්ම ගීක්, නමුත් මම මෙය භාවිතා කරමි:

#define as ;while

int main(int argc, char* argv[])
{
    int n = atoi(argv[1]);
    do printf("n is %d\n", n) as ( n --> 0);
    return 0;
}

මා කියවූ එක් පොතක් (කුමන පොතදැයි මට නිවැරදිව මතක නැත) ප්‍රකාශ කළේ: සම්පාදකයින් වම් දකුණු රීතිය භාවිතා කරමින් ප්‍රකාශන විශාලතම ටෝකනයට විග්‍රහ කිරීමට උත්සාහ කරයි .

මෙම අවස්ථාවේ දී, ප්රකාශනය:

x-->0

විශාලතම ටෝකන සඳහා විග්‍රහ කිරීම:

token 1: x
token 2: --
token 3: >
token 4: 0
conclude: x-- > 0

මෙම ප්‍රකාශනයට එකම රීතිය අදාළ වේ:

a-----b

විග්‍රහ කිරීමෙන් පසු:

token 1: a
token 2: --
token 3: --
token 4: -
token 5: b
conclude: (a--)-- - b

සංකීර්ණ ප්‍රකාශනය තේරුම් ගැනීමට මෙය උපකාරී වේ යැයි මම බලාපොරොත්තු වෙමි ^^

මෙය හරියටම සමාන වේ

while (x--)
{
   printf("%d ", x);
}

සෘණ නොවන සංඛ්‍යා සඳහා

කෙසේ වෙතත්, අපට දැන් "යන්න" ක්‍රියාකරු ඇත. "-->"දිශාවක් ලෙස මතක තබා ගැනීම පහසු වන අතර “x ශුන්‍යයට යන අතර” යන්න අර්ථය-සෘජු ය.

තවද, එය "for (x = 10; x > 0; x --)"සමහර වේදිකාවලට වඩා ටිකක් කාර්යක්ෂම වේ.

මෙම කේතය මුලින් x හා 0 සංසන්දනය කර x අඩු වේ. (පළමු පිළිතුරෙහි ද මෙසේ සඳහන් වේ: ඔබ x පසු-අඩුවෙමින් x හා 0 >ක්‍රියාකරු සමඟ සංසන්දනය කරයි .) මෙම කේතයේ ප්‍රතිදානය බලන්න:

9 8 7 6 5 4 3 2 1 0

අපි දැන් පළමුව සංසන්දනය කර ප්‍රතිදානයේ 0 දැකීමෙන් අඩු වේ.

අපට පළමුව අඩු කිරීමට හා පසුව සංසන්දනය කිරීමට අවශ්‍ය නම්, මෙම කේතය භාවිතා කරන්න:

#include <stdio.h>
int main(void)
{
    int x = 10;

    while( --x> 0 ) // x goes to 0
    {
        printf("%d ", x);
    }
    return 0;
}

එම ප්‍රතිදානය:

9 8 7 6 5 4 3 2 1

මම මෙම කේතය ක්‍රියාත්මක කරන විට මගේ සම්පාදකයා 9876543210 මුද්‍රණය කරයි.

#include <iostream>
int main()
{
    int x = 10;

    while( x --> 0 ) // x goes to 0
    {
        std::cout << x;
    }
}

බලාපොරොත්තු වූ පරිදි. මෙම while( x-- > 0 ), ඇත්තෙන්ම while( x > 0). මෙම x--පශ්චාත් decrements x.

while( x > 0 ) 
{
    x--;
    std::cout << x;
}

එකම දේ ලිවීමේ වෙනස් ක්‍රමයකි.

මුල් පිටපත "x 0 ට ගියත්" වගේ පෙනීම සතුටක්.

--සහ අතර ඉඩක් නොමැත >. xපශ්චාත් අඩුවී ඇත, එනම් තත්වය පරීක්ෂා කිරීමෙන් පසුව අඩු x>0 ?වේ.

--යනු අඩු කිරීම් සමාගම සහ >තමයි වැඩි-වඩා ක්රියාකරු.

ක්‍රියාකරුවන් දෙදෙනා තනි එකක් ලෙස යොදනු ලැබේ -->.

එය ක්‍රියාකරුවන් දෙදෙනෙකුගේ එකතුවකි. පලමු-- අගය අඩු >කිරීම සඳහා වන අතර, අගය දකුණු අතෙහි ක්‍රියාකාරිත්වයට වඩා වැඩි දැයි පරීක්ෂා කිරීම ය.

#include<stdio.h>

int main()
{
    int x = 10;

    while (x-- > 0)
        printf("%d ",x);

    return 0;
}

ප්‍රතිදානය වනුයේ:

9 8 7 6 5 4 3 2 1 0            

ඇත්තටම, x පශ්චාත් අඩුවීමක් වන අතර එම තත්වය සමඟ පරීක්ෂා කරනු ලැබේ. එය නෙමෙයි--> , ඒක(x--) > 0

සටහන: xතත්වය පරීක්ෂා කිරීමෙන් පසු එහි අගය වෙනස් වේ. සමහර සමාන අවස්ථා ද සිදුවිය හැකිය, උදාහරණයක් ලෙස:

-->    x-->0
++>    x++>0
-->=   x-->=0
++>=   x++>=0

සී සහ සී ++ "උපරිම මන්ච්" රීතියට අවනත වේ. (a--) - bඔබේ නඩුවේදී --- b පරිවර්තනය කර ඇති ආකාරයටමx-->0 පරිවර්තනය වේ (x--)>0.

රීතිය අත්‍යවශ්‍යයෙන්ම පවසන දෙය නම් වමේ සිට දකුණට ප්‍රකාශන සෑදී ඇත්තේ වලංගු ප්‍රකාශනයක් වන උපරිම අක්ෂර ලබා ගැනීමෙන් ය.

සියලු සංකූලතා ඇයි?

මුල් ප්‍රශ්නයට සරල පිළිතුර:

#include <stdio.h>
int main()
{
    int x = 10;
    while (x > 0) 
    {
        printf("%d ", x);
        x = x-1;
    }
}

එකම දේ කරයි. ඔබ එය මේ ආකාරයට කළ යුතු යැයි නොකියයි, නමුත් එය එකම දේ කරන අතර එක් පෝස්ට් එකකින් ප්‍රශ්නයට පිළිතුරු දෙනු ඇත.

මෙම x--ඉහත සඳහා පමණක් අයුරෙන් වන අතර, >හුදෙක් සාමාන්ය වැඩි-වඩාoperator . ලොකු අභිරහසක් නැත!

වර්තමානයේ සරල දේවල් සංකීර්ණ කරන බොහෝ අය සිටිති;)

සාම්ප්‍රදායික ක්‍රමයට අපි whileලූප වරහන් ()තුළ ඇති කොන්දේසියක් සහ වරහන් තුළ අවසන් වන තත්වයක් අර්ථ දක්වන්නෙමු {}, නමුත්--> අර්ථ දෙකම එකවරම අර්ථ දක්වන්නෙමු.

උදාහරණයක් වශයෙන්:

int abc(void)
{
    int a = 5
    while((a--) > 0) // Decrement and comparison both at once
    {
        // Code
    }
}

මෙය අඩු වන aඅතර aවඩා විශාල වන අතර ලූපය ධාවනය කරයි0 .

සාම්ප්‍රදායිකව එය මෙසේ වනු ඇත:

int abc(void)
{
    int a = 5;
    while(a > 0)
    {
        a--;
        // Code
    }
    a--;
}

ක්‍රම දෙකම, අපි එකම දේ කර එකම අරමුණු සාක්ෂාත් කර ගනිමු.

(x --> 0) මාධ්‍යයන් (x-- > 0)

1. ඔයාට පාවිච්චි කරන්න පුළුවන් (x -->)
output -: 9 8 7 6 5 4 3 2 1 0

2. ඔබට භාවිතා කළ හැකි (-- x > 0) එය මධ්යන්ය(--x > 0)
output -: 9 8 7 6 5 4 3 2 1

3. ඔයාට පාවිච්චි කරන්න පුළුවන්

(--\
    \
     x > 0)

output -: 9 8 7 6 5 4 3 2 1

4. ඔයාට පාවිච්චි කරන්න පුළුවන්

(\
  \
   x --> 0)

output -: 9 8 7 6 5 4 3 2 1 0

5. ඔයාට පාවිච්චි කරන්න පුළුවන්

(\
  \
   x --> 0
          \
           \
            )

output -: 9 8 7 6 5 4 3 2 1 0

6. ඔබට ද භාවිතා කළ හැකිය

(
 x 
  --> 
      0
       )

output -: 9 8 7 6 5 4 3 2 1 0

ඒ හා සමානව, මෙම විධානය සාර්ථකව ක්‍රියාත්මක කිරීම සඳහා ඔබට බොහෝ ක්‍රම අත්හදා බැලිය හැකිය