[Powered by Google Translate] GDB, GNU ప్రాజెక్ట్ డీబగ్గర్, సి ఒక శక్తివంతమైన డీబగ్గింగ్ సాధనం
అనేక ఇతర భాషలు పాటు.
వారు అమలు ఉన్నప్పుడు, మీ సి కార్యక్రమాలలో చుట్టూ దూర్చు అనుమతిస్తుంది
మరియు అది కూడా మీరు జరిగినప్పుడు సరిగ్గా చూడటానికి అవకాశం ఇస్తుంది
మీ ప్రోగ్రామ్ దూసుకుపోయింది.
ఇది కుడి, అందంగా నిఫ్టీ ఏమిటి?
GDB ఉచిత సాఫ్ట్వేర్, మరియు అనేక ప్రసిద్ధ UNIX అమలు మరియు
Windows-ఆధారిత ఆపరేటింగ్ వ్యవస్థలు, అందువలన ఇది చాలా విస్తృతమైన సాధనం.
>> మీరు ప్రేమించే గురించి తెలుసుకోవాలి.
GDB ప్రోస్ దోషాలు జాడ ఒక సులభంగా
అంచనాలు ఉపయోగించి ద్వారా గజిబిజి వారికంటే
మరియు ప్రింటవుట్ ప్రకటనలు అనంతమైన పరిమాణంలో.
GDB మీరు టెర్మినల్ లో వ్యవహరించవచ్చు, అనగా ఒక ఆదేశ పంక్తి సాధనం
మీ మౌస్ తో కీబోర్డు ద్వారా ఆదేశాలు బదులుగా క్లిక్ బటన్లు జారీ.
>> GDB అప్ ప్రారంభించడానికి, మీరు వాచ్యంగా ప్రాంప్ట్ మరియు హిట్ కేవలం రకం GDB ఎంటర్.
మీరు తెరకు ముద్రించిన కొన్ని పంక్తులు చూస్తారు
, మీరు రన్ చేస్తున్న మీరు GDB యొక్క చూపిస్తున్న
దాని కాపీరైట్ సమాచారం, మరియు చివరిలో మీరు GDB ప్రాంప్ట్ చూస్తారు: (GDB).
ఈ మీరు GDB ఆదేశాలను సిద్దంగా తెలియచేస్తుంది.
ఈ సమయంలో, ఎలా చెయ్యాలో తెలుసుకోవడం చాలా ముఖ్యమైన విషయం విడిచి ఉంది.
అదృష్టవశాత్తూ, ఈ అందంగా సులభం.
విడిచి ఆదేశం ఆ చేస్తుంది.
ఒక షార్ట్కట్, మీరు కేవలం q చాలా ఉపయోగించవచ్చు.
వినోదం GDB అప్ బూటింగ్ తరువాత వెంటనే త్యజించడం వంటి ఉంది,
ఒక ప్రోగ్రామ్ డీబగ్ సహాయం GDB ఉపయోగించడం గురించి మాట్లాడటానికి ఇప్పుడు చూద్దాం.
>> ప్రారంభించడానికి, నేను ఇక్కడ factorial.c లో ఒక ప్రోగ్రామ్ పొందారు
ఒక Int వచ్చి దాని కారకమైన గణించడం ప్రయత్నిస్తుంది.
ఒకవేళ మీరు, ముందు factorials చూడని లేదా వాటిని గుర్తు లేదు
సంఖ్య యొక్క కారకమైన n n యొక్క ఉత్పత్తి సమానంగా ఉంటుంది - (n - 1), (n - 2) మరియు ఆ విధంగా -
మీరు 1 హిట్ వరకు.
అందువలన, 3 యొక్క కారకమైన 3 * 2 * 1, లేదా 6,
మరియు 4 యొక్క కారకమైన 4 ఉంటుంది * 3 * 2 * 1, లేదా 24.
సున్నా కారకమైన బేసి సందర్భంలో, అది, 1 యొక్క
మరియు ప్రతికూల పూర్ణాంకాల factorials నిర్వచింపబడలేదు.
ఏమైనా, నా కారకమైన కార్యక్రమం గురించి అల్లరిగా ఉంది.
నేను దీన్ని అమలు, అది factorials తో లేదు ఆ విచిత్రమైన సంఖ్యలను ముద్రిస్తుంది.
>> కాబట్టి, మేము ఏమి గుర్తించడానికి సహాయంగా GDB ఉపయోగించవచ్చు.
GDB, ఎగ్జిక్యూటబుల్ ఫైళ్లు పనిచేస్తుంది
ఇది సంగ్రహంలో ద్వారా ఉత్పత్తి బైనరీ ఫైళ్లు.
అంటే, మేము మా. సి న GDB అమలు లేదా కాదు. Factorial.c వంటి h సోర్స్ కోడ్ ఫైళ్లు.
మేము బదులుగా కేవలం కారకమైన మీద అమలు చేయండి.
కార్యక్రమం ఏ ఆదేశ పంక్తి వాదనలు అవసరం ఉంటే,
మేము వాటిని పేర్కొనవచ్చు చోట ఈ ఉంది.
ఈ సందర్భంలో, కారకమైన, ఏ ఆదేశ పంక్తి వాదనలు అవసరం లేదు
కాబట్టి మేము కేవలం చిన్న పోటీ లేదా r టైప్ చేయండి.
>> ఈ కారకమైన ప్రోగ్రామ్ను అమలు ప్రారంభమౌతుంది.
ప్రోగ్రామ్ను అమలు ఆపి, నేను, నా GDB తిరిగి ప్రాంప్ట్ పొందుతారు.
సరే, యొక్క 4 యొక్క కారకమైన, మళ్ళీ ఇదే ప్రయత్నించండి తెలియజేయండి.
All right, మేము GDB ఇక్కడ వ్యర్థ రకమైన పొందడానికి మేము చూసాము.
కార్యక్రమం పూర్తి ఇప్పుడు ఆ,
మేము, లో వెళ్ళి దాని రాష్ట్ర ఏ యాక్సెస్ చేయలేరు
కనుక మేము ఏం చూడటానికి ముందు మళ్లీ అమలు ప్రారంభం చేయాలి.
అయితే, మేము దాని రన్ మధ్యలో ఉన్నప్పుడు అది ఆపే మార్గం అవసరం.
>> అలా చెయ్యడానికి, బ్రేక్పాయింట్ని అని ఏమి ఉపయోగించండి.
బ్రేక్ పాయింట్స్ ఒక నిర్దిష్ట విధిని లేదా సోర్సు కోడ్ లైన్ వద్ద విరామం కార్యక్రమానికి GDB చెప్పండి
కాబట్టి మేము, ప్రోగ్రామ్ యొక్క స్థితి పరిశీలించడానికి చేయవచ్చు
చరరాశులు యొక్క విలువలలో, మెమరీ రాష్ట్ర మరియు ఆ సమయంలో.
నేను నిజంగా విషయాలు తప్పు వెళ్తున్నారు పేరు తెలియదు కాబట్టి,
>> నేను, కుడి చాలా ప్రారంభంలో డీబగ్గింగ్ ప్రారంభం కావాలి
ప్రధాన ప్రారంభమవుతుంది కుడి ఉన్నప్పుడు.
మేము విరామం ఆదేశాన్ని ఉపయోగించి ప్రధాన ప్రారంభంలో ఒక బ్రేక్ పాయింట్ సెట్ చేస్తాము.
మేము కూడా బ్రేక్ నిర్వచించడం బి ఉపయోగించవచ్చు.
ఇప్పుడు ప్రోగ్రామ్ మళ్లీ అమలు ప్రారంభిద్దాం.
ఇక్కడ మేము GDB మాకు చెబుతుంది వలె, ప్రధాన ప్రారంభంలో ఉంటాయి.
అమలు గురించి కానీ ఇంకా ఆ కోడ్ యొక్క లైన్
printf లైన్.
మేము కోడ్ యొక్క ఈ లైన్ అమలు మరియు తరువాత లైన్ వెళ్ళడానికి GDB తెలియజేయవచ్చు
తదుపరి లేదా n ఆదేశంతో.
>> All right, ఇప్పుడు GDB మేము GetInt లైన్ లో మాకు చెబుతుంది.
నేను printf లైన్ అమలు చేయలేదు ఉన్నట్లు కనిపిస్తోంది తెలుసు
మేము చూడండి కాబట్టి, తెరపై print అవుట్ "ఒక సానుకూల పూర్ణాంక నమోదు చేయండి"
అయితే అమలు చేయలేదు.
మనం చూస్తూ ఆపరేటింగ్ సిస్టమ్ కు రచన ఏదైనా అణచివేయడానికి ఉంది
అది ఖచ్చితంగా ఎందుకు printouts తో డీబగ్గింగ్ ఇది ఉంటుంది వరకు
కొన్నిసార్లు నమ్మలేని వస్తున్నాయి.
ఏమైనా, కోడ్ యొక్క తదుపరి లైన్ కు వెళ్లండి మరియు Int లో ఎంటర్ మళ్ళీ చూద్దాం.
మళ్లీ, రకం 4 చూద్దాం.
కాబట్టి ఈ అసహజ కనిపిస్తోంది. మేము, GDB ప్రకారం లైన్ 12 లో ఉన్నారు
కానీ అమలు గురించి ఆ తర్వాత పంక్తి ఒక వంకర జంట కలుపు.
>> కేవలం మేము ఒక లూప్ యొక్క ముగింపు వద్ద ఉన్నారని అర్ధం మా విధంగా నిజానికి లూప్,
మరియు GDB మాకు చెప్పడం అని రద్దు పరిస్థితి, సున్నా కంటే అవి ఏవీ తక్కువ,
తదుపరి అమలు అవుతుంది.
ఇది ఒక చిన్న గందరగోళంగా గెట్స్ ఉంటే,
మేము జాబితా లేదా l ఆదేశంతో GDB లో సోర్స్ కోడ్ పుల్ అప్ చేయవచ్చు.
ఈ సోర్స్ కోడ్ అవుట్ ముద్రిస్తుంది
మేము ప్రస్తుతం ఉన్నట్లు లైన్ చుట్టూ ఉంది.
మేము మళ్ళీ జాబితా లేదా l టైప్ చేస్తే, మేము రేఖల తదుపరి సెట్లో ముద్రించాలా చూస్తారు.
మేము ఫైల్ ముగింపు హిట్ వరకు మేము చేయవచ్చు.
>> మేము ఉన్న తిరిగి పొందడానికి, మేము, ఒక లైన్ సంఖ్యలో జాబితా సరఫరా చేయవచ్చు
ఈ సందర్భంలో, లైన్ 12.
ఏమైనా, యొక్క ముందుకు తెలియజేయండి.
ఇప్పుడు మేము 4 లూప్ లో ఉన్నారు.
లెట్ యొక్క మా num వేరియబుల్ 4 కలిగి నిర్ధారించుకోండి.
మేము ప్రింట్, లేదా, p ఆదేశంతో దీన్ని.
కాబట్టి, GDB మేము అనుకున్న num నిజానికి 4 నిల్వ మాకు చెబుతుంది.
ఆ GDB ముద్రిస్తుంది $ 1 ప్రత్యేక GDB చరరాశి
ఇప్పుడు అదే సంఖ్య 4 నిల్వ కు సెట్.
మీరు ఇప్పుడు ఈ విస్మరించవచ్చు, కానీ ఈ GDB వేరియబుల్స్ సులభ సూపర్ వస్తాయి
మరింత ఆధునిక విషయాలలో మీరు గతంలో చేసిన ఏ గుర్తు ఉంటుంది.
ఏమైనా, తదుపరి తో కదిలే, మేము లూప్ ద్వారా తిరగటం మొదలు ఆ చూడండి.
బిట్ n బిట్ ఇక్కడ ద్వారా కొనసాగించడాన్ని యొక్క లెట్.
అయితే టైపింగ్ n ప్రతి సమయం కంటే, మీరు కూడా ఎంటర్ నొక్కండి కేవలం.
మీరు ఏదైనా టైప్ లేకుండా ఎంటర్ నొక్కండి చేసినప్పుడు, GDB కేవలం మునుపటి ఆదేశం పునరావృతమవుతుంది.
కాబట్టి ఇప్పుడు మేము printf కాల్ హిట్ చేసిన.
మేము నిజంగా లూప్ 4 సార్లు మా ద్వారా మారారు వంటి ఇది కనిపిస్తుంది
ఇది మేము 1, 2, 3, మరియు 4 ద్వారా హెచ్చించాము చేయడానికి మీరు ఏమి ఉంది.
>> ప్రతిదీ అది పనిచేస్తోందని వంటి ఉంది,
రాబోయే మళ్లీ హిట్ తప్ప మేము బదులుగా 24 ఈ భారీ సంఖ్యలో పొందండి.
మేము కారకమైన ఉపయోగించి p విలువ ముద్రించాలా ఉంటే,
మేము కారకమైన అది ఈ భారీ సంఖ్యలో లేని చూడండి.
ఏదో ఖచ్చితంగా తప్పు జరగబోతోంది.
ఈ సమయంలో, అయితే, మేము దాదాపు కార్యక్రమం చివరిలో ఉంటాయి
మరియు అది ఏదైనా పరిష్కరించడానికి ఆలస్యం.
>> అయితే, మేము నిర్ధారించడానికి మళ్ళీ తరువాత Y r టైప్ చేయడం ద్వారా కార్యక్రమం పునఃప్రారంభించుము చేయవచ్చు.
ఇప్పుడు మేము ప్రధాన ప్రారంభంలో మా బ్రేక్పాయింట్ని వద్ద వెనక్కి వచ్చారు.
మేము ప్రతిదీ n లో చదివిన చిన్నగా ఉంది తెలుసు.
కాబట్టి మేము n ముందుకు కెన్ జంప్.
ఏమి తరువాత ప్రత్యామ్నాయంగా, మేము ఒక కొత్త బ్రేక్పాయింట్ని సెట్ చేయవచ్చు, అయితే లూప్
మరియు అక్కడ దూకుతారు. యొక్క అలా లెట్.
లైన్ 14 కేవలం లూప్ తర్వాత వస్తుంది కనిపిస్తోంది.
యొక్క అక్కడ బ్రేక్పాయింట్ని సెట్ లెట్.
ఈ బ్రేక్పాయింట్ని ఆదేశం లో ఫైల్ పేరు తెలుపుటకు మంచి పద్ధతి యొక్క
మీరు బహుళ ఫైళ్లను పని మీరు GDB అయోమయం పొందవచ్చు నుండి.
ముందుకు ఈ బ్రేక్పాయింట్ని యొక్క తరలించడానికి, మేము కొనసాగింపును లేదా సి ఆదేశం ఉపయోగించండి.
>> సరే, ఇక్కడ మేము లూప్ ఉన్నాయి.
యొక్క లూప్ లోకి 1 మరింత లైన్ వెళ్ళి తెలపండి,
మరియు తర్వాత మేము ఏమి చూడటానికి ముద్రణ వేరియబుల్స్ ప్రారంభించగలరు.
లెట్ యొక్క అంచనా నేను నిజానికి 1 నిర్ధారించుకోండి.
అన్ని మంచి అయ్యో,.
గురించి కారకమైన ఏమి అయినప్పటికీ?
ఏ మంచి అయ్యో,.
మేము ఇక్కడ ఒక పెద్ద రుణ సంఖ్య పొందారు.
ఆ జరిగే How'd?
Well, మేము కోడ్ వద్ద తిరిగి చూస్తే,
మేము అది initialized ఎప్పుడూ చూడండి, కాబట్టి మేము అక్కడే ట్రాష్ పొందారు.
ఆ ఖచ్చితంగా మా లెక్కింపు పడగొట్టటానికి కనిపిస్తుంది.
>> అదృష్టవశాత్తూ, ఈ పరిష్కరించడానికి GDB వదిలి లేదు.
మేము ఇక్కడే అది ప్రారంభించడం మరియు తరువాత print ఆదేశాన్ని ఉపయోగించి కోడ్ పరిష్కరిస్తాము.
సున్నా మరియు 1 యొక్క factorials 1 రెండూ నుండి మేము, 1 కి ప్రారంభించడం చేస్తాము
మేము సున్నా దానిని ప్రారంభించటానికి ఉంటే, అప్పుడు మేము ఎల్లప్పుడూ మా ఫలితంగా సున్నా ముగిసేవి భావిస్తున్న.
మీరు సూపర్ సులభ ఉన్న ఏదైనా వేరియబుల్ ఈ విధంగా, సెట్ చేయవచ్చు.
ఇప్పుడు, యొక్క మా కార్యక్రమం చెయ్యనివ్వండి.
లెట్ యొక్క ఇది రావలసిన చోట ప్రతిదీ ను నిర్థారించండి.
Num 4 ఉండాలి, నేను 1 ఉండాలి, మరియు కారకమైన చాలా 1 అయి ఉండాలి.
మేము ఈ ప్రక్రియ సత్వరమార్గం మరియు మా స్థానిక వేరియబుల్స్ యొక్క అన్ని ముద్రించవచ్చు
సూపర్ ఉపయోగపడిందా ఆదేశం సమాచారం స్థానికులు,
ఇది మా లో-స్కోప్ స్థానిక వేరియబుల్స్ యొక్క అల్ అవ్ట్ ముద్రిస్తుంది.
ప్రతిదీ వెళ్ళడానికి మంచి వంటి ఏమైనా, కనిపిస్తోంది.
>> కేవలం నిర్ధారించడానికి మరొక Go-చుట్టూ ఉచ్చు యొక్క తెలియజేసేలా యొక్క.
సరే, ప్రతిదీ చాలా బాగుంది.
ఇప్పుడు మేము ముగింపు వెళ్లడాన్ని కొనసాగించాల్సిన ఆదేశం ఉపయోగించవచ్చు.
Sweet! 4 కారకమైన అనుకున్న 24 ముద్రించిన.
ఇప్పుడు మేము మా కోడ్ లో పరిష్కరిస్తాము వెళ్ళవచ్చు.
అయితే GDB నుండి నిష్క్రమించినప్పుడు కంటే, మేము దీన్ని మరొక టెర్మినల్ టాబ్ ఉపయోగిస్తాము.
మా GDB టాబ్ కు వెళుతున్నారు, మేము ఇప్పుడు మా executable మళ్ళీ కంపైల్ చెయ్యండి అవసరం.
GDB గురించి ఉత్తమ విషయాలు ఒకటి మీరు చేసే అమలు చేయడానికి GDB వదిలి లేదు అని.
కాబట్టి మేము పాత బ్రేక్ పాయింట్స్ కొట్టిన ఉంచేందుకు లేదు ఆ
లెట్స్ వాటిని డిసేబుల్, మీరు ఊహించిన, ఆదేశం అచేతనము చేయుము.
ఈ మా బ్రేక్ పాయింట్స్ అన్ని ఆపివేస్తుంది.
ఇప్పుడు మేము r తో కార్యక్రమం పునఃప్రారంభించుము మరియు ప్రతిదీ సరైందే ఖచ్చితంగా చేయవచ్చు.
ప్రతిదీ అన్నిటికి ఉన్నట్లు కనిపిస్తుంది.
24 4 అచ్చుల కారకమైన, కేవలం వంటి మేము ఆలోచన.
GDB మీ పేజీలు లో పొందారు అత్యంత సహాయపడే ఉపకరణాలు ఒకటి.
>> మీరు GDB చేయగలిగే ఒక టన్ను వస్తువుల ఉన్నాయి
మీరు సాధారణ printouts చేయగలిగే కంటే చాలా.
తరువాత మీ ప్రోగ్రామ్, మీకు కావలసిన ఏమి లేదు
లోపల ఏమి గుర్తించడానికి GDB నడుస్తున్న ప్రయత్నించండి.
సాధన కొంత, మీరు ఏ సమయంలో మీ బగ్ న డౌన్ రంధ్రములు చేసే పరికరము చేయగలరు.
నా పేరు నేట్ Hardison ఉంది. ఈ CS50 ఉంది.