1.11a — आपके program को debug करना (variables और call stack पर नज़र रखना )

पिछले lesson Stepping और breakpoints में हमने सीखा की debugger की सहायता से हम program के execute होने के path पर कैसे नज़र रख सकते हैं । फिर भी, program में stepping करना debugger की केवल आधी खूबियों को दर्शाता है । Debugger stepping करते वक़्त हमे variables के value की जाँच करने की भी अनुमति देता है ।

यहाँ मौजूद हमारे examples Visual Studio Express debugger के अनुसार दिखाए गए हैं -- यदि आप कोई दूसरा IDE/debugger इस्तेमाल कर रहे हैं, तो commands के नाम थोड़े अलग हो सकते हैं, या फिर menu या options किसी दूसरी जगह स्थित हो सकते हैं ।

आगे बढने से पहले: पक्का कर ले की आपका program debug build configurationइस्तेमाल करने के लिए set किया गया है ।

Watching variables (variables पर नज़र रखना)

Variables पर नज़र रखना (watching a variable) एक process है जिसमे variables के value की जाँच की जाती है, जब program debug build configuration के साथ execute हो रहा हो । कई debuggers इसे करने के अलग-अलग तरीके प्रदान करते हैं। आइये एक उदाहरण देखते हैं:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

#include "stdafx.h" #include <iostream> int main() {     int x(1);     std::cout << x << " ";     x = x + 1;     std::cout << x << " ";     x = x + 2;     std::cout << x << " ";     x = x + 4;     std::cout << x << " ";     return 0; }

ये बहुत ही आसान सा example है -- ये 1, 2, 4, और 8 print करेगा ।

सबसे पहले, “Run to cursor” command का इस्तेमाल कर line std::cout << x << " ";को debug कर ले:

यहाँ पे, variable x value 1 के साथ पहले से ही initialize हो चूका है, इसलिए जब हम variable x के value की पड़ताल करेंगे, हमे value 1 दिखना चाहिए ।

साधारण variables (जैसे यहाँ x) के value की जाँच करने की सबसे आसान विधि है, mouse को variable (जैसे यहाँ x) के ऊपर point (hover) करना । कई सारे आधुनिक debuggers साधारण variables के लिए इस method को support करते हैं, और ये value की जाँच-पड़ताल करने का सबसे आसान तरीका भी है ।

ध्यान दे की आप x जैसे किसी भी variable पर hover (point) कर सकते हैं:

यदि आप Visual Studio में debug कर रहे हो, तो watching के लिए आप QuickWatch का भी इस्तेमाल कर सकते हो । इसके लिए, Variable x को आपके mouse से highlight (select) कर लीजिये, और इसके बाद right-click कर menu में से "QuickWatch" select कर लीजिये ।

ये एक subwindow open करेगा जिसमे variable का value दिखाया जायेगा:

आइये अब program में step करते वक़्त किसी variable के value को change होते हुए देखते हैं । सबसे पहले, "Step over" को दो बार चुने, ताकि execute होने वाला अगला line main का दूसरा line यानी std::cout << x << " "; बन जाये:

अब variable x का value 2 होना चाहिए । ऊपर बताये गये तरीके का इस्तेमाल कर इसे पक्का कर ले !

Watching window

किसी निश्चित समय में, program के किसी निश्चित जगह पर, QuickWatch या mouse hover वाले methods का इस्तेमाल कर के variables के value को जाँचना सही है, लेकिन program के run होते वक़्त variables के values को देखने या इनकी जाँच करने के लिए ये methods बहुत बढ़िया नहीं माने जा सकते । वो इसलिए, क्यूंकि इसके लिए आपको program के run होते समय बार-बार किसी variable पर hover या उसे select करना पडेगा ।

इससे बचने के लिए, आधुनिक compilers एक और feature प्रदान करते हैं जिसे watch window कहा जाता है । Watch window एक ऐसा window है जहाँ आप variables जिनकी आप जाँच करना चाहते हैं, उन्हें जोड़ सकते हैं और इन variables के values आपके program में आगे बढ़ते हुए अपने आप update होते चले जायेंगे । जब आप debug mode में enter करते हो, watch window वहाँ पहले से मौजूद होना चाहिए, लेकिन यदि ऐसा नहीं है, तो आप इसे अपने IDE के window commands (ये ज्यादातर debug menus में ही कही स्थित होते हैं) के द्वारा access कर सकते हैं ।
Visual Studio 2005 Express में, आप Debug Menu->Windows->Watch->Watch 1 अपर जाकर watch window को access कर सकते हैं (note: आपको debug mode में होना चाहिए, इसलिए पहले step into कर लीजिये) ।

आपको कुछ ऐसा दिखाई देना चाहिए:

अभी इस window में कुछ भी नहीं दिखेगा क्यूंकि अब तक हमने कोई भी watch नहीं set किया है । Watch set करने के दो तरीके हैं:

1) Watch window के “Name” column में, उस variable का नाम लिखो जिनपर आप watch set करना चाहते हो ।
2) जिस variable पर watch set करना है, उसे highlight/select कर right click menu में से "Add Watch" को चुन लो ।

अभी के लिए, variable “x” को watch list में डाल दें । आपको कुछ ऐसा देखने को मिलेगा:

अब यहाँ से एक-दो बार "Step over" command को चुनकर, आप देख सकते हैं की program के आगे execute होने के साथ-साथ variable का value किस तरह से change होता जाता है!

ध्यान दे की जो variables out of scope हैं (यानी variables जो किसी ऐसे function में define किये गए हैं, जो पहले execute हो चूका है पर फ़िलहाल execute/run नहीं हो रहा), वो भी watch window में दिखाई देंगे । जब variable scope में आता है (यानी यदि function को फिर से call किया जाता है), तो watch window इसे चुनकर इसका value दिखाने लगेगा ।

Program के step through होने के साथ-साथ किसी variable के value पर नज़र रखने के लिए watches सबसे ज्यादा उपयोगी हैं ।
Call stack window

आधुनिक debuggers में debugging से सम्बंधित एक और information window होता है जो program को debug करते वक़्त काफी मददगार साबित हो सकता है । इसे call stack के नाम से जानते हैं ।

आपको पहले से पता है की जब आपके program में किसी function को call किया जाता है, तो program function call वाले जगह को save/bookmark कर लेता है ताकि called functions से लौटने के बाद execution वापस वहीँ से शुरू हो सके, इसके बाद function को call किया जाता है और फिर called function से execution वापस caller पर आ जाता है । यहाँ सवाल ये उठता है की आखिर ये bookmark save कहाँ पे होता है, या फिर ऐसा कहा जाये की program को पता कैसे चलता है की लौटना कहाँ है ? इसका जवाब है: ये call stack पर नज़र रखता है और वही से जानकारियाँ हासिल करता है ।

Call stack सभी active functions जिन्हें अभी तक के execution में call किया गया है, का एक list है । Call stack, call किये गए सभी functions का entry record दायर करता है, जिसमे functions के कौन से lines execute किये गए हैं, इसकी भी जानकारी होती है । जब भी कोई नया function call किया जाता है, वो call stack में सबसे ऊपर जुड़ जाता है और control ठीक इसके नीचे के function पर चला आता है ।

यदि आपको call stack window नहीं दिख रहा, तो आपको IDE को इसे दिखाने का निर्देश देना होगा । Visual Studio 2005 Express में, आप Debug Menu->Windows->Call Stack menu में जाकर ये कर सकते हैं (note: आपको debug mode में होना चाहिए, इसलिए पहले step into कर लीजिये) ।

आइये एक simple से program से call stack का उदाहरण देखते हैं:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

#include "stdafx.h" #include <iostream> void CallC() {                 std::cout << "C called" << std::endl; } void CallB() {                 std::cout << "B called" << std::endl;                 CallC(); } void CallA() {                 CallB();                 CallC(); } int main() {                 CallA();     return 0; }

CallC() में एक breakpoint लगाकर debugging mode को शुरू कर दे । Program तब तक बिना रुके execute होगा जब तक ये breakpoint तक नहीं पहुँचता ।

भले ही आपको पता है की CallC() function execute हो रहा है, program में CallC() को दो बार call किया जा चूका है (एक call CallB() में, और दूसरा CallA() में) । अभी जब function breakpoint पर रूका है, function को किसने call किया था, CallB() ने या फिर CallA() ने ? इसका जवाब हमे call stack देगा:

Program main() को call कर के execute होना शुरू होता है । इसके बाद main(), CallA() को call करता है, जिसमे CallB() को call किया गया है, जो CallC() को call करता है । आप call करने वाले functions पर अधिक जानकारी के लिए अलग-अलग lines पर double-click कर सकते हैं । कुछ IDEs आपको सीधे function call पर ले जायेंगे । Visual Studio 2005 Express आपको function call की अगली line पर ले जाता है । इस functionality को खुद से try करें । जब आप अपने code में stepping को फिर से जारी रखने के लिए तैयार हो, तो call stack window में सबसे ऊपर double click कर लो । इस तरह आप program पहले जहाँ execute हो रहा था, उस point पर वापस पहुँच जाओगे ।
Program को run करना जारी रखे । आपका breakpoint CallC() के फिर से call होने पर दोबारा spot हो जायेगा (इस बार, CallA() के कारण) । Call stack में आपको ये दिखाई देना चाहिए :

निष्कर्ष

बधाई हो, अब आप code को debug करने के basics जान चुके हो! Stepping, breakpoints, watches, और call stack window का इस्तेमाल करते हुए आप अब किसी भी problem को debug करने में सक्षम हो । बहुत सारी दूसरी चीजों की तरह, debugger को अच्छी तरह से use करना सिखना ढेर सारा practice और थोड़ा समय ले सकता है । आपका program जितना बड़ा होगा, debugger आपके लिए उतना ही उपयोगी साबित होगा, इसलिए इसे अच्छी तरह से सिखने के लिए थोड़ा समय देना जायज़ है !