जो तेज है: अगर (बूल) या अगर (इंट)?

Question

किस मूल्य का उपयोग करना बेहतर है? बूलियन सच है या Integer 1?

ऊपर विषय मेरे साथ कुछ प्रयोग कर बनाया boolऔर intमें ifहालत। तो बस जिज्ञासा से बाहर मैंने यह कार्यक्रम लिखा:

int f(int i) 
{
    if ( i ) return 99;   //if(int)
    else  return -99;
}
int g(bool b)
{
    if ( b ) return 99;   //if(bool)
    else  return -99;
}
int main(){}

g++ intbool.cpp -S प्रत्येक कार्य के लिए asm कोड बनाता है:

• asm कोड के लिए f(int)

  __Z1fi:
     LFB0:
           pushl  %ebp
     LCFI0:
            movl  %esp, %ebp
     LCFI1:
            cmpl  $0, 8(%ebp)
            je    L2
            movl  $99, %eax
            jmp   L3
     L2:
            movl  $-99, %eax
     L3:
            leave
     LCFI2:
            ret
  

• asm कोड के लिए g(bool)

  __Z1gb:
     LFB1:
            pushl %ebp
     LCFI3:
            movl  %esp, %ebp
     LCFI4:
            subl  $4, %esp
     LCFI5:
            movl  8(%ebp), %eax
            movb  %al, -4(%ebp)
            cmpb  $0, -4(%ebp)
            je    L5
            movl  $99, %eax
            jmp   L6
     L5:
            movl  $-99, %eax
     L6:
            leave
     LCFI6:
            ret
  

हैरानी की बात है, g(bool)अधिक asmनिर्देश उत्पन्न करता है ! इसका मतलब यह है कि if(bool)की तुलना में थोड़ा धीमा है if(int)? मुझे लगता boolहै कि विशेष रूप से सशर्त बयान में उपयोग करने के लिए डिज़ाइन किया गया है if, जैसे कि , मैं g(bool)कम asm निर्देश उत्पन्न करने की उम्मीद कर रहा था , जिससे और g(bool)अधिक कुशल और तेज़ हो।

संपादित करें:

मैं अब तक किसी भी अनुकूलन ध्वज का उपयोग नहीं कर रहा हूं। लेकिन यहां तक ​​कि इसके अभाव में, यह अधिक asm उत्पन्न क्यों करता g(bool)है एक प्रश्न है जिसके लिए मैं एक उचित उत्तर की तलाश कर रहा हूं। मुझे आपको यह भी बताना चाहिए कि -O2अनुकूलन ध्वज वास्तव में एक ही asm उत्पन्न करता है। लेकिन यह सवाल नहीं है। सवाल वही है जो मैंने पूछा है।

---

Comments

यह भी एक अनुचित परीक्षा है जब तक आप उनकी तुलना उचित अनुकूलन के साथ नहीं करते हैं।

— डैनियल प्रेडेन

@ डैनियल: मैं उनमें से किसी के साथ किसी भी अनुकूलन झंडे का उपयोग नहीं कर रहा हूं। लेकिन यहां तक ​​कि अनुपस्थिति, क्यों यह अधिक asm उत्पन्न करता है के लिए g(bool)एक सवाल है जिसके लिए मैं एक उचित जवाब की तलाश कर रहा हूं।

— नवाज

आप एएसएम को पढ़ने की परेशानी में क्यों जाएंगे, लेकिन केवल कार्यक्रम चलाने और परिणाम समय पर नहीं ? प्रशिक्षकों की संख्या वास्तव में प्रदर्शन के बारे में बहुत कुछ नहीं कहती है। आपको न केवल निर्देश लंबाई में, बल्कि निर्भरता और निर्देशों के प्रकारों में भी कारक चाहिए (उनमें से कुछ धीमे माइक्रोकोड पथ का उपयोग करके डिकोड किए गए हैं, जो निष्पादन इकाइयों को उनकी आवश्यकता होती है, निर्देश की विलंबता और प्रवाह क्या है, क्या यह एक कारक है शाखा? एक संस्मरण का उपयोग?

— jalf

@user अज्ञात, और @Malvolio: यह स्पष्ट है; मैं उत्पादन कोड के लिए ये सब नहीं कर रहा हूँ। जैसा कि मैंने अपनी पोस्ट की शुरुआत में पहले ही उल्लेख किया है कि "तो बस जिज्ञासा से बाहर मैंने यह कार्यक्रम लिखा" । तो हाँ, यह एक पूरी तरह से काल्पनिक है ।

— नवाज

यह एक वैध प्रश्न है। वे या तो समकक्ष हैं या एक तेज है। ASM संभवतः सहायक होने या जोर से सोचने के प्रयास में तैनात था, इसलिए इसका उपयोग प्रश्न को चकमा देने और "बस पठनीय कोड लिखने" के लिए एक तरीके के रूप में उपयोग करने के बजाय, यदि आप नहीं जानते हैं तो प्रश्न या STFU का उत्तर दें कहने के लिए कुछ भी उपयोगी नहीं है;) मेरा योगदान यह है कि सवाल जवाबदेह है, और "बस पढ़ने योग्य कोड लिखें" सवाल के चकमा देने के अलावा और कुछ नहीं है।

— त्रिवेंको

Answer 1

मेरी समझ मे आ रहा है। आपका कंपाइलर स्पष्ट boolरूप से 8-बिट मान के रूप में परिभाषित करता है , और आपके सिस्टम ABI को कॉल स्टैक पर पुश करने के दौरान 32-बिट में छोटे (<32-बिट) पूर्णांक तर्क को "बढ़ावा" देने की आवश्यकता होती है। इसलिए एक तुलना करने के लिए bool, कंपाइलर 32-बिट तर्क जो जी प्राप्त करता है, के साथ कम से कम महत्वपूर्ण बाइट को अलग करने के लिए कोड उत्पन्न करता है और साथ तुलना करता है cmpb। पहले उदाहरण में, intतर्क पूर्ण 32 बिट्स का उपयोग करता है जिन्हें स्टैक पर धकेल दिया गया था, इसलिए यह बस पूरी चीज़ के साथ तुलना करता है cmpl।

Comments

मैं सहमत हूँ। यह इस बात पर रोशनी डालने में मदद करता है कि एक चर प्रकार का चयन करते समय, आप इसे दो संभावित प्रतिस्पर्धी उद्देश्यों, भंडारण स्थान बनाम कम्प्यूटेशनल प्रदर्शन के लिए चुन रहे हैं।

— त्रिकोको

क्या यह 64-बिट प्रक्रियाओं पर भी लागू होता है, जो इससे __int64तेज है int? या CPU 32-बिट इंस्ट्रक्शन के साथ 32-बिट पूर्णांक को अलग-अलग सेट करता है?

— 21

@ क्रेंडिंग शायद यह एक और सवाल है?

— डिस्प्ले का नाम

Answer 2

-03मेरे साथ संकलन करना मेरे लिए निम्नलिखित है:

च:

    pushl   %ebp
    movl    %esp, %ebp
    cmpl    $1, 8(%ebp)
    popl    %ebp
    sbbl    %eax, %eax
    andb    $58, %al
    addl    $99, %eax
    ret

छ:

    pushl   %ebp
    movl    %esp, %ebp
    cmpb    $1, 8(%ebp)
    popl    %ebp
    sbbl    %eax, %eax
    andb    $58, %al
    addl    $99, %eax
    ret

.. इसलिए यह अनिवार्य रूप से एक ही कोड को छोड़कर, cmplबनाम के लिए संकलित करता है cmpb। इसका मतलब है कि अंतर, अगर कोई है, कोई फर्क नहीं पड़ता। अडॉप्ट किए गए कोड को देखते हुए यह उचित नहीं है।

---

मेरी बात को स्पष्ट करने के लिए संपादित करें । अडॉप्टेड कोड साधारण डिबगिंग के लिए है, गति के लिए नहीं। अडॉप्टेड कोड की गति की तुलना संवेदनहीन है।

Comments

जितना मैं आपके निष्कर्ष से सहमत हूं, मुझे लगता है कि आप दिलचस्प हिस्से को छोड़ रहे हैं। यह एक के लिए और दूसरे के लिए क्यों इस्तेमाल करता है ? cmplcmpb

— jalf

@ जैलफ: क्योंकि एक boolएकल बाइट है और एक intचार है। मुझे नहीं लगता कि इससे ज्यादा कुछ खास नहीं है।

— CB बेली

मुझे लगता है कि अन्य प्रतिक्रियाओं ने कारणों पर अधिक ध्यान दिया: यह इसलिए है क्योंकि प्रश्न में मंच bool8 बिट प्रकार के रूप में व्यवहार करता है ।

— अलेक्जेंडर गेसलर

@ नथन: नंबर सी ++ में कोई बिट डेटा प्रकार नहीं है। सबसे छोटा प्रकार है char, जो परिभाषा के अनुसार एक बाइट है, और सबसे छोटी पता योग्य इकाई है। boolका आकार कार्यान्वयन-परिभाषित है, और 1, 4, या 8 या जो भी हो सकता है। कंपाइलर हालांकि इसे एक बनाते हैं।

— GManNickG

@ नथन: अच्छी तरह से जावा में मुश्किल है। जावा का कहना है कि डेटा एक बूलियन का प्रतिनिधित्व करता है एक बिट का मूल्य है, लेकिन उस बिट को कैसे संग्रहीत किया जाता है अभी भी कार्यान्वयन को परिभाषित किया गया है। व्यावहारिक कंप्यूटर बस बिट्स को संबोधित नहीं करते हैं।

— GManNickG

Answer 3

जब मैं विकल्पों के एक सेट (विशेष रूप से -O3) के साथ इसे संकलित करता हूं, तो यहां मुझे क्या मिलेगा:

के लिए f():

        .type   _Z1fi, @function
_Z1fi:
.LFB0:
        .cfi_startproc
        .cfi_personality 0x3,__gxx_personality_v0
        cmpl    $1, %edi
        sbbl    %eax, %eax
        andb    $58, %al
        addl    $99, %eax
        ret
        .cfi_endproc

के लिए g():

        .type   _Z1gb, @function
_Z1gb:
.LFB1:
        .cfi_startproc
        .cfi_personality 0x3,__gxx_personality_v0
        cmpb    $1, %dil
        sbbl    %eax, %eax
        andb    $58, %al
        addl    $99, %eax
        ret
        .cfi_endproc

वे अभी भी तुलना के लिए विभिन्न निर्देशों का उपयोग करते हैं ( cmpbउदाहरण के लिए बूलियन बनाम cmpl), लेकिन अन्यथा शरीर समान हैं। इंटेल मैनुअल पर एक त्वरित नज़र मुझे बताता है: ... कुछ भी नहीं। वहाँ के रूप में ऐसी कोई बात नहीं है cmpbया cmplइंटेल पुस्तिकाओं में। वे सब कर रहे हैं cmpऔर मैं समय सारणी नहीं मिल सकता है। हालांकि, मैं अनुमान लगा रहा हूं कि एक बाइट की तत्काल तुलना करने के बीच कोई घड़ी का अंतर नहीं है। लंबे समय तक तत्काल तुलना करना, इसलिए सभी व्यावहारिक उद्देश्यों के लिए कोड समान है।

---

अपने जोड़ के आधार पर निम्नलिखित जोड़ने के लिए संपादित किया

अडॉप्ट किए गए मामले में कोड अलग होने का कारण यह है कि यह अडॉप्टिमाइज्ड है। (हाँ, यह परिपत्र है, मुझे पता है।) जब कंपाइलर एएसटी चलता है और सीधे कोड उत्पन्न करता है, तो यह कुछ भी नहीं जानता है "सिवाय इसके कि एएसटी के तत्काल बिंदु पर क्या है? उस बिंदु पर इसके लिए आवश्यक सभी प्रासंगिक जानकारी का अभाव है। पता चला है कि इस विशिष्ट बिंदु पर यह घोषित प्रकार का इलाज कर सकते boolएक के रूप में int। एक बूलियन स्पष्ट रूप से एक बाइट के रूप में माना जाता है और जब इंटेल की दुनिया में बाइट्स में हेरफेर किया जाता है, तो आपको इसे स्टैक पर रखने के लिए कुछ निश्चित चौड़ाई में लाने के लिए साइन-एक्सटेंशन जैसी चीजें करनी होती हैं, (आप बाइट को धक्का नहीं दे सकते। ।)

जब ऑप्टिमाइज़र एएसटी को देखता है और अपना जादू करता है, हालांकि, यह आसपास के संदर्भ को देखता है और "जानता है" जब यह कोड को बिना शब्दार्थ को बदलने के कुछ और अधिक कुशल के साथ बदल सकता है। तो यह "जानता है" यह पैरामीटर में एक पूर्णांक का उपयोग कर सकता है और इस तरह अनावश्यक रूपांतरण और चौड़ीकरण खो देता है।

Comments

हाहा, मुझे पसंद है कि कैसे कंपाइलर ने केवल 99, या 99 + 58 = 157 = -99 (हस्ताक्षर किए 8 ओवर का अतिप्रवाह) लौटाया ... दिलचस्प।

— deceleratedcaviar

@ डैनियल: यहां तक ​​कि मुझे यह पसंद आया। सबसे पहले, मैंने कहा "कहाँ है -99" और तुरंत मुझे एहसास हुआ कि इसकी कुछ बहुत ही गांठदार है।

— नवाज

lऔर bकेवल एटी एंड टी सिंटैक्स में उपयोग किए गए प्रत्यय हैं। वे cmpक्रमशः 4 बाइट (लंबी) और 1 बाइट (बाइट) ऑपरेंड के उपयोग के संस्करणों को संदर्भित करते हैं। कहाँ इंटेल वाक्य रचना में कोई अस्पष्टता नहीं है, पारंपरिक स्मृति संकार्य के साथ टैग है BYTE PTR, WORD PTRया DWORD PTRबजाय opcode पर एक प्रत्यय डालने की।

— सीबी बेली

समय सारणी: agner.org/optimize दोनों ऑपरेंड-साइज़ का cmpप्रदर्शन समान है, और पढ़ने के लिए कोई आंशिक-रजिस्टर दंड नहीं है %dil। (लेकिन वह andएएल पर बाइट-आकार का उपयोग करके आंशिक रूप से रजिस्टर-स्टाल बनाने से रोकना बंद नहीं करता है, जैसे कि 99 और -99 के बीच शाखा-केस-फ़्लिपिंग के भाग के रूप में।)

— पीटर कॉर्ड

Answer 4

लिनक्स और विंडोज पर जीसीसी 4.5 कम से कम के साथ, sizeof(bool) == 1। X86 और x86_64 पर, आप किसी फ़ंक्शन के लिए एक सामान्य प्रयोजन रजिस्टर के मूल्य से कम में पास नहीं कर सकते हैं (चाहे स्टैक के माध्यम से या कॉलिंग सम्मेलन आदि के आधार पर एक रजिस्टर ...)।

अतः बूल के लिए कोड, जब संयुक्त राष्ट्र द्वारा अनुकूलित किया जाता है, तो वास्तव में तर्क स्टैक से उस बूल मान को निकालने के लिए कुछ लंबाई तक जाता है (उस बाइट को बचाने के लिए एक और स्टैक स्लॉट का उपयोग करके)। यह केवल एक देशी रजिस्टर-आकार चर को खींचने की तुलना में अधिक जटिल है।

Comments

C ++ 03 मानक से, §5.3.3 / 1: " sizeof(bool)और sizeof(wchar_t)कार्यान्वयन-परिभाषित हैं। " इसलिए यह कहना sizeof(bool) == 1कड़ाई से सही नहीं है जब तक कि आप किसी विशिष्ट संकलक के विशिष्ट संस्करण के बारे में बात नहीं कर रहे हैं।

— iljarn

Answer 5

मशीन के स्तर पर बूल जैसी कोई चीज नहीं है

बहुत कम निर्देश सेट आर्किटेक्चर किसी भी प्रकार के बूलियन ऑपरेंड प्रकार को परिभाषित करते हैं, हालांकि अक्सर निर्देश होते हैं जो गैर-शून्य मानों पर कार्रवाई को ट्रिगर करते हैं। सीपीयू के लिए, आमतौर पर, सब कुछ अदिश प्रकारों में से एक या उनमें से एक स्ट्रिंग है।

एक दिया गया संकलक और किसी दिए गए ABI के लिए विशिष्ट आकार का चयन करने की आवश्यकता होगी intऔर boolऔर जब, आपके मामले में की तरह, इन विभिन्न आकारों वे थोड़ा अलग कोड उत्पन्न कर सकता है, और अनुकूलन एक के कुछ स्तरों पर थोड़ा तेज हो सकता है।

क्यों कई प्रणालियों पर एक बाइट है?

यह charबूल के लिए एक प्रकार का चयन करने के लिए सुरक्षित है क्योंकि कोई उनमें से एक बहुत बड़ा सरणी बना सकता है।

अपडेट: "सुरक्षित" द्वारा , मेरा मतलब है: संकलक और पुस्तकालय कार्यान्वयनकर्ताओं के लिए। मैं यह नहीं कह रहा हूं कि लोगों को सिस्टम प्रकार को फिर से लागू करने की आवश्यकता है।

Comments

+1 x86 पर ओवरहेड की कल्पना करें यदि boolबिट्स द्वारा प्रतिनिधित्व किया गया था; इसलिए बाइट कई कार्यान्वयन में गति / डेटा कॉम्पैक्टनेस के लिए एक अच्छा व्यापार होगा।

— हार्डमैथ

@ बिली: मुझे लगता है कि वह "उपयोग नहीं कर रहा था" के charबजाय bool" charटाइप" का अर्थ "1 बाइट" का उपयोग करता था जब संकलक boolवस्तुओं के आकार का चयन करता है।

— डेनिस ज़िकेफोज़

ओह, निश्चित रूप से, मेरा मतलब यह नहीं था कि प्रत्येक कार्यक्रम को चुनना चाहिए, मैं सिर्फ एक तर्क को आगे बढ़ा रहा था कि सिस्टम बूल प्रकार 1 बाइट क्यों है।

— DigitalRoss

@ डेनिस: आह, यह समझ में आता है।

— बिली ओनेल

Answer 6

हाँ, चर्चा का मज़ा। लेकिन अभी इसका परीक्षण करें:

टेस्ट कोड:

#include <stdio.h>
#include <string.h>

int testi(int);
int testb(bool);
int main (int argc, char* argv[]){
  bool valb;
  int  vali;
  int loops;
  if( argc < 2 ){
    return 2;
  }
  valb = (0 != (strcmp(argv[1], "0")));
  vali = strcmp(argv[1], "0");
  printf("Arg1: %s\n", argv[1]);
  printf("BArg1: %i\n", valb ? 1 : 0);
  printf("IArg1: %i\n", vali);
  for(loops=30000000; loops>0; loops--){
    //printf("%i: %i\n", loops, testb(valb=!valb));
    printf("%i: %i\n", loops, testi(vali=!vali));
  }
  return valb;
}

int testi(int val){
  if( val ){
    return 1;
  }
  return 0;
}
int testb(bool val){
  if( val ){
    return 1;
  }
  return 0;
}

एक 64-बिट उबंटू 10.10 लैपटॉप पर संकलित किया गया है: g ++ -O3 -o / tmp / test_i /tmp/test_i.cpp

पूर्णांक आधारित तुलना:

sauer@trogdor:/tmp$ time /tmp/test_i 1 > /dev/null

real    0m8.203s
user    0m8.170s
sys 0m0.010s
sauer@trogdor:/tmp$ time /tmp/test_i 1 > /dev/null

real    0m8.056s
user    0m8.020s
sys 0m0.000s
sauer@trogdor:/tmp$ time /tmp/test_i 1 > /dev/null

real    0m8.116s
user    0m8.100s
sys 0m0.000s

बूलियन परीक्षण / प्रिंट अनियंत्रित (और पूर्णांक टिप्पणी की गई):

sauer@trogdor:/tmp$ time /tmp/test_i 1 > /dev/null

real    0m8.254s
user    0m8.240s
sys 0m0.000s
sauer@trogdor:/tmp$ time /tmp/test_i 1 > /dev/null

real    0m8.028s
user    0m8.000s
sys 0m0.010s
sauer@trogdor:/tmp$ time /tmp/test_i 1 > /dev/null

real    0m7.981s
user    0m7.900s
sys 0m0.050s

वे 1 असाइनमेंट के साथ समान हैं और 2 प्रत्येक लूप की तुलना 30 मिलियन लूप से अधिक है। अनुकूलन करने के लिए कुछ और ढूंढें। उदाहरण के लिए, अनावश्यक रूप से strcmp का उपयोग न करें। ;)

Answer 7

यह ज्यादातर संकलक और अनुकूलन पर निर्भर करेगा। यहाँ एक दिलचस्प चर्चा (भाषा अज्ञेय) है:

क्या "if ([बूल] == सच)" को "if ([बूल])" की तुलना में एक और कदम की आवश्यकता है?

इस पोस्ट पर भी नज़र डालें: http://www.linuxquestions.org/questions/programming-9/c-compiler-handling-of-boolean-variables-290996/

Answer 8

अपने प्रश्न को दो अलग-अलग तरीकों से स्वीकार करना:

यदि आप विशेष रूप से C ++ या किसी भी प्रोग्रामिंग भाषा के बारे में बात कर रहे हैं जो उस मामले के लिए असेंबली कोड का उत्पादन करेगी, तो हम ASM में कंपाइलर किस कोड को उत्पन्न करेंगे, इसके लिए बाध्य हैं। हम सी ++ में भी सही और गलत के प्रतिनिधित्व के लिए बाध्य हैं। एक पूर्णांक को 32 बिट्स में संग्रहित करना होगा, और मैं बूलियन अभिव्यक्ति को संग्रहीत करने के लिए बस एक बाइट का उपयोग कर सकता था। सशर्त बयान के लिए एएसएम स्निपेट:

पूर्णांक के लिए:

  mov eax,dword ptr[esp]    ;Store integer
  cmp eax,0                 ;Compare to 0
  je  false                 ;If int is 0, its false
  ;Do what has to be done when true
false:
  ;Do what has to be done when false

बूल के लिए:

  mov  al,1     ;Anything that is not 0 is true
  test al,1     ;See if first bit is fliped
  jz   false    ;Not fliped, so it's false
  ;Do what has to be done when true
false:
  ;Do what has to be done when false

तो, यही कारण है कि गति तुलना इतनी निर्भर निर्भर है। उपरोक्त मामले में, बूल थोड़ा तेज cmpहोगा क्योंकि झंडे स्थापित करने के लिए एक घटाव होगा। यह आपके कंपाइलर के उत्पन्न होने का भी खंडन करता है।

एक और दृष्टिकोण, बहुत सरल है, यह अभिव्यक्ति के तर्क को देखने के लिए स्वयं है और इस बारे में चिंता न करने की कोशिश करें कि कंपाइलर आपके कोड का अनुवाद कैसे करेगा, और मुझे लगता है कि यह सोचने का बहुत स्वस्थ तरीका है। मुझे अभी भी विश्वास है, अंततः, कि संकलक द्वारा उत्पन्न किया जा रहा कोड वास्तव में एक सत्य संकल्प देने की कोशिश कर रहा है। मेरा मतलब यह है कि, हो सकता है कि यदि आप स्टेटमेंट में टेस्ट केस बढ़ाते हैं और एक पक्ष में बूलियन के साथ चिपके रहते हैं और दूसरे में पूर्णांक बनाते हैं, तो कंपाइलर इसे बना देगा जिससे उत्पन्न कोड मशीन स्तर में बूलियन एक्सप्रेशन के साथ तेजी से निष्पादित होगा।

मैं विचार कर रहा हूं कि यह एक वैचारिक प्रश्न है, इसलिए मैं एक वैचारिक उत्तर दूंगा। यह चर्चा मुझे उन चर्चाओं की याद दिलाती है, जिनके बारे में मुझे आमतौर पर पता चलता है कि कोड दक्षता असेंबली में कोड की कम लाइनों का अनुवाद करती है या नहीं। ऐसा लगता है कि इस अवधारणा को आम तौर पर सच होने के रूप में स्वीकार किया जाता है। यह देखते हुए कि ALU प्रत्येक स्टेटमेंट को कितनी तेजी से हैंडल करेगा, इस पर नज़र रखना व्यवहार्य नहीं है, दूसरा विकल्प जंपर्स पर ध्यान केंद्रित करना और असेंबली में तुलना करना होगा। जब ऐसा होता है, तो आपके द्वारा प्रस्तुत कोड में बूलियन स्टेटमेंट्स या पूर्णांकों के बीच का अंतर प्रतिनिधि बन जाता है। C ++ में एक अभिव्यक्ति का परिणाम एक मूल्य लौटाएगा जिसे तब एक प्रतिनिधित्व दिया जाएगा। विधानसभा में, दूसरी ओर, जंप और तुलना संख्यात्मक मानों पर आधारित होगी, चाहे वह किसी भी प्रकार के अभिव्यक्ति का मूल्यांकन किया गया हो यदि आप सी ++ पर बयान करते हैं। इन सवालों पर यह याद रखना महत्वपूर्ण है कि विशुद्ध रूप से तार्किक बयान जैसे कि ये एक विशाल कम्प्यूटेशनल ओवरहेड के साथ समाप्त होते हैं, भले ही एक ही बिट एक ही चीज के लिए सक्षम होगा।