घर
Top.Mail.Ru Yandeks.Metrika
मंच: "मुख्य";
वर्तमान संग्रह: 2004.12.12;
डाउनलोड करें: [xml.tar.bz2];

नीचे

डेल्फी 7 में त्रुटि इसी तरह की शाखाएँ खोजें


Sicilla   (2004-11-17 18:34) [0]

सभी को नमस्कार। एक डेल्फी 7 के बजाय एक डेल्फी 5 पोस्ट करें। डेल्फी 5 नहीं हटाई। और अब त्रुटि: जब F7 डिबगिंग, उदाहरण के लिए, चर i में, मान 2 है, और ऐसा लगता है कि 10 या -5 है। हालांकि यह सामान्य रूप से सही है।



begin...end ©   (2004-11-17 18:49) [1]


> सिसिला (17.11.04 18: 34)

मैं एक लूप काउंटर बेतरतीब ढंग से नहीं है?



Sicilla   (2004-11-17 19:07) [2]

हां, मूल रूप से यह बग लूप में है। और फिर भी जारी रखने के लिए चक्र में प्रतिक्रिया नहीं करता है। कमीने: (



begin...end ©   (2004-11-17 19:11) [3]


> [2] सिसिली (17.11.04 19: 07)

> हां, मूल रूप से यह बग लूप में है।

एक चक्र के मामले में, यह सामान्य व्यवहार है।

> और अभी भी जारी रखने के लिए चक्र में प्रतिक्रिया नहीं करता है।

कोड दें।



Sicilla   (2004-11-17 20:01) [4]

function Tform1.change_record(num: byte): integer;
var
  x,i,j: Integer;
  last, now_1: byte;
begin
    for x := 1 to prov do
        begin
             way_old[x] := prov_info.way[x];
             prov_info.way[x] := 0;
        end;
    for i := 1 to num do
        for x := 1 to prov do
            begin
                 if prov_info.P[x,1] = lstEntries.Items.Strings[i-1] then
                 prov_info.way[i] := x;
            end;
    j := num - ini.kol_prov;
    for x := 1 to num do
        begin
             if (prov_info.way[x] = 0) and (abs(j) > 0) then
                begin
                     prov_info.way[x] := abs(j) + ini.kol_prov;
                     if j > 0 then dec(j);
                     if j < 0 then inc(j);
                     if i = 0 then break;
                end;
        end;
    j := num - ini.kol_prov; // отсюда глюки
    if j > 0 then
       begin
            for i := num downto 1 do
                for x := prov downto 1 do
                    if (way_old[x] = prov_info.way[i]) and (prov_info.way[i] <> 0) and (way_old[x] <> 0) then
                       begin
                            last := way_old[x];
                            now_1 := i;
                            form1.Change(num,last,now_1);
                       end;
       end;
    if j < 0 then
       begin
            for i := 1 to num do
                for x := 1 to prov do
                    if (way_old[x] = prov_info.way[i]) and (prov_info.way[i] <> 0) and (way_old[x] <> 0) then
                       begin
                            last := way_old[x];
                            now_1 := i;
                            form1.Change(num,last,now_1);
                       end;
       end;
    EXE.P[last] := prov_info.p[now_1];
    //
    for i := 1 to prov do
        Prov_info.P[i,1] := "";
    for i := 1 to lstEntries.Items.Count do
        begin
             Prov_info.P[i,1] := lstEntries.Items.Strings[i-1];
             prov_info.way[i] := i
        end;
    ini.kol_prov := lstEntries.Items.Count;
    change_prov(col);
end;

पहले कुछ चक्रों के लिए, सामान्य लग रहा है, फिर कचरा शुरू होता है।
टाइप PRI = रिकॉर्ड पी: सरणी [1..prov, 1..20] स्ट्रिंग [50]; तरीका: बाइट की सरणी [1..prov]; अंत; Prov_info, Exe: PRI; const prov = 9



Anatoly Podgoretsky ©   (2004-11-17 20:09) [5]

कोड में जारी रखें नहीं मिला



begin...end ©   (2004-11-17 20:12) [6]


> जारी रखें कोड में नहीं मिला

तो गड़बड़ अब डेल्फी में नहीं है।



Defunct ©   (2004-11-17 21:41) [7]

लेकिन कंटिन्यू की आवश्यकता क्यों है?
साथ ही साथ गोटो और एग्जिट इन द कचरा कचरा आईएमएचओ।



Gero ©   (2004-11-17 21:46) [8]


> कमी © (17.11.04 21: 41)

फिर, ब्रेक टू बूट।
और चक्रों को बाहर फेंकना संभव है। उन्हें क्या चाहिए?

IMHO



Defunct ©   (2004-11-17 22:01) [9]

> फिर, भी, ब्रेक टू बूट।

बिल्कुल, और वहाँ तोड़।
IMHO जो उपयोग करते हैं
गोटो, ब्रेक, कंटिन्यू, एक्जिट
बस ठीक से कार्यक्रम के तर्क को लागू नहीं कर सकते।

> और आप सिर्फ साइकिल बाहर फेंक सकते हैं। उन्हें क्या चाहिए?

विचार को विकृत मत करो।

7 ऑपरेटरों की मदद से, आप किसी भी तर्क को लागू कर सकते हैं:
1। खाली ऑपरेटर -;
2। असाइनमेंट ऑपरेटर: =
3। सशर्त यदि कथन <> तो <बयान> और <कथन>
4। किसी शर्त के साथ साइकिल ऑपरेटर जबकि <कंडीशन> डू <ऑपरेटर>
5। पोस्टकॉन्डिशन के साथ लूप ऑपरेटर <ऑपरेटर> को <कंडीशन> तक दोहराते हैं
6। <से> के लिए <से> को <ऑपरेटर> के लिए सीमाओं के साथ साइकिल ऑपरेटर
7। कंपाउंड ऑपरेटर शुरू होता है <ऑपरेटर> .. अंत।

दो अतिरिक्त ऑपरेटर केस और के साथ कार्यक्रम की सुंदरता और दृश्यता के लिए इस्तेमाल किया जा सकता है।

जारी रखें, ब्रेक, गोटो, बाहर निकलें केवल कार्यक्रम के तर्क को भ्रमित करते हैं और कार्यक्रम को पढ़ने के लिए मुश्किल बनाते हैं।



Defunct ©   (2004-11-17 22:02) [10]

[9]
4। लोल सुपरप्रिंट



Defunct ©   (2004-11-17 22:14) [11]

2 जीरो,

[2] जिस तरह से मैं के बारे में बात कर रहा हूँ दर्शाता है।
कोड को पढ़ना मुश्किल है।

और जाहिरा तौर पर दोनों D5 और D7 पर काम नहीं करता है:
मैं के लिए: = 1 to lstEntries.Items.Count do



jack128 ©   (2004-11-17 22:28) [12]

अयोग्य © (17.11.04 22: 01) [9]
और चक्र का पूरा 3 (!!!) प्रकार क्यों ?? एक समय काफी है।



jack128 ©   (2004-11-17 22:29) [13]

अयोग्य © (17.11.04 22: 14) [11]
कोड को पढ़ना मुश्किल है।

गैर-मानक इंडेंट, IMHO के कारण कोड को पढ़ना मुश्किल है।



Defunct ©   (2004-11-17 22:35) [14]

x के लिए: = 1 को num करने के लिए
शुरू करना
अगर (prov_info.way [x] = 0) और (एब्स (j)> 0)
शुरू करना
prov_info.way [x]: = abs (j) + ini.kol_prov;
अगर j> 0 तब dec (j);
अगर j <0 तो inc (j);
अगर मैं = 0 तो तोड़;
अंत;
अंत;

क्या इस चक्र को लिखने से रोकता है:

अगर मैं <तो 0
x के लिए: = 1 को num करने के लिए
अगर (prov_info.way [x] = 0) और (एब्स (j)> 0)
शुरू करना
prov_info.way [x]: = abs (j) + ini.kol_prov;
अगर j> 0 तो dec (j) और inc (j)
अंत;

और किसी भी ब्रेक की आवश्यकता नहीं है, और कम कोड।

हालाँकि लेखक ने ब्रेक के साथ लाइन में गलती की हो सकती है (शायद ऐसा नहीं है अगर i = 0, लेकिन वहाँ होना चाहिए था अगर j = 0)

लेकिन इस मामले में, आप ब्रेक के बिना कर सकते हैं:

x: = 1;
दोहराना
अगर (prov_info.way [x] = 0) और (एब्स (j)> 0)
शुरू करना
prov_info.way [x]: = abs (j) + ini.kol_prov;
अगर j> 0 तो dec (j) और inc (j)
अंत;
inc (x);
तक (x> = num) या (j = 0);

और अब समझते हैं कि डिबगिंग और डिबगिंग के लिए सबसे अच्छा क्या है:
- एक लाइन में बाहर निकलने की स्थिति के साथ चिकनी तर्क
- या लूप बॉडी से सीधे लूप से बाहर कूदने की क्षमता वाला लॉजिक कर्व।



Palladin ©   (2004-11-17 23:13) [15]


> [14] कमी © (17.11.04 22: 35)

क्यों टूटते हैं और जारी रहते हैं? खैर, मुझे आपसे ऐसे बयानों की उम्मीद नहीं थी।

जबकि लूप कुछ भी संभालना, लूप से बाहर निकलने की स्थिति। लूप बॉडी की शुरुआत में प्रदर्शन को वापस करने के लिए कई शर्तें। केवल एक ही रास्ता है। जबकि ट्रू डू एंड ब्रेक एंड कंटिन्यू।



Defunct ©   (2004-11-17 23:19) [16]

> और चक्र का पूरा 3 (!!!) प्रकार क्यों ??

सभी अवसरों के लिए;>
यह सवाल अलग है कि आपको लूप के एक्सएनयूएमएक्स ऑपरेटर के साथ कुछ कंटिन्यू, ब्रेक आदि का उपयोग क्यों करना पड़ता है?



Gero ©   (2004-11-17 23:35) [17]


> IMHO जो उपयोग करते हैं
> गोटो, ब्रेक, जारी, बाहर निकलें
> बस कार्यक्रम के तर्क को ठीक से लागू नहीं कर सकता।

क्या यह वास्तव में ऐसा काम करता है?

मैं सक्रिय रूप से उपरोक्त सभी (गोटो को छोड़कर) का उपयोग करता हूं, और मैं यह नहीं कहूंगा कि कोड उनके बिना पठनीयता में बदतर है, और कभी-कभी बेहतर भी।

सबसे सरल उदाहरण है:
i: = 0 से उच्च (अर्र) के लिए शुरू करना यदि IsError (Arr [i]) तो ब्रेक; <Code> अंत;
ब्रेक के बिना इसे और अधिक खूबसूरती से लागू करें।



Gero ©   (2004-11-17 23:37) [18]


> IMHO जो उपयोग करते हैं
> गोटो, ब्रेक, जारी, बाहर निकलें
> बस कार्यक्रम के तर्क को ठीक से लागू नहीं कर सकता।

हां, वैसे, एक ही सफलता के साथ यह तर्क दिया जा सकता है कि जो लोग गोटो, ब्रेक, कंटिन्यू और एक्जिट का उपयोग नहीं करते हैं, वे कार्यक्रम के तर्क को ठीक से लागू नहीं कर सकते हैं।
यदि भाषा इसे अनुमति देती है, तो इसका उपयोग क्यों नहीं किया जाता है?



Defunct ©   (2004-11-17 23:38) [19]

पल्लेदिन © (17.11.04 23: 13) [15]

मैं अभी भी स्थिति को तोड़ता हूं और तोड़ता हूं। बिल्कुल अनावश्यक ऑपरेटरों.

आखिरकार, कोई भी इस तरह से चक्र के शरीर का निर्माण करने के लिए परेशान नहीं करता है:

प्रक्रिया चक्र; var संपन्न: बूलियन; शुरू करना संपन्न: = नहीं <सेट लॉन्च की स्थिति>; जबकि नहीं किया शुरू करना ... संपन्न: = <निकास स्थितियों का सेट> अंत; अंत; ... साइकिल;

के रूप में
> जबकि सच है
तब आश्चर्यचकित होने की मेरी बारी थी, क्योंकि आम तौर पर IMHO लिखना असंभव है।



Gero ©   (2004-11-17 23:41) [20]


> मैं अभी भी उस स्थिति को पकड़ता हूं जो तोड़ और प्रतियोगिता करता है। बिल्कुल
> निरर्थक ऑपरेटर।

किसी भी लूप ऑपरेटर की आवश्यकता नहीं है।
सब कुछ अगर "के माध्यम से किया जा सकता है।



jack128 ©   (2004-11-17 23:51) [21]

Gero © (17.11.04 23: 41) [20]
गोटो की अनुपस्थिति में - यह एक आवश्यकता है। कैसे निष्पादित करने के लिए <ऑपरेटर> एक पंक्ति में एन बार ?? (एन - चर)



Palladin ©   (2004-11-17 23:53) [22]

आप कर सकते हैं, आप भी कर सकते हैं। इसके अलावा आई.एम.एच.ओ.

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

A)

DeviceConnect;
Thử
जबकि सच्चा करते हैं
शुरू करो
यदि IsDeviceConnected नहीं तो ब्रेक;
अगर रीडकमांड नहीं तो तोड़ो;
ProceedCommand;
अगर डिवाइसकनेक्टेड नहीं तो ब्रेक;
अगर नहीं लिखे गए कोकम और फिर ब्रेक;
अंत;
अंत में
TryDisconnectDevice;
अंत;

B)
प्रत्येक
isDone: बूलियन;
शुरू करो
DeviceConnect;
Thử
जबकि Not DoDone Do
शुरू करो
isDone: = IsDeviceConnected;
यदि है तो पूर्ण हो जाता है: = रीडकमांड;
यदि नहीं किया गया है तो ProceedCommand;
यदि नहीं किया गया है तो फिर हो गया है: = डिवाइस कनेक्ट किया गया;
यदि नहीं किया जाता है तो फिर नहीं किया जाता है: = लिखेंकमांड;
अंत;
अंत में
TryDisconnectDevice;
अंत;

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



Defunct ©   (2004-11-17 23:55) [23]

> i के लिए: = 0 से उच्च (Arr) करते हैं
> शुरू करो
> अगर Isrrror (Arr [i]) तो फिर;
> <कोड>
> अंत;

> ब्रेक के बिना इसे और अधिक खूबसूरती से महसूस करें।

जबकि NoError (Arr [i]) और (i <High (Arr)) करते हैं
शुरू करो
<Code>
अंत;

> यदि भाषा अनुमति देती है, तो इसका उपयोग क्यों नहीं किया जाता है?
यदि ऐसा है तो लेबल का उपयोग क्यों नहीं किया जाता है? भाषा सभी की अनुमति के बाद। इनलाइन का उपयोग क्यों नहीं करते? पूरे कार्यक्रम को आसमां पर क्यों नहीं लिखा जाए? सभी कथन एक पंक्ति में क्यों नहीं लिखे? सब के बाद भाषा, और यह सब अनुमति देता है। अधिक सटीक रूप से एक भाषा नहीं है, लेकिन एक संकलक है।

मैं इन सभी सवालों के जवाब इस तरह से दूंगा:
क्योंकि इस सब का उपयोग नहीं करते हुए, कार्यक्रम बहुत अधिक सुविधाजनक लगेगा, और समझने के लिए अधिक सुलभ होगा। कार्यक्रम के तर्क (एल्गोरिथ्म) को देखना बहुत आसान होगा, इसलिए कोड में एक संभावित त्रुटि ढूंढना बहुत आसान होगा।



Palladin ©   (2004-11-17 23:55) [24]

उफ़ .. गलती ... स्थितियों की भीड़ से लेने की ज़रूरत नहीं ... और हालत से भी, जबकि ...



Defunct ©   (2004-11-18 00:13) [25]

पल्लेदिन © (17.11.04 23: 53) [22]
> मेरी धारणा के लिए, ए) बी की तुलना में स्पष्ट है,

ईमानदारी से, मैं इसके साथ सहमत हूं (आपके कार्यान्वयन में, बी वास्तव में ए की तुलना में कम दृश्यमान है), लेकिन मैं नीचे सी की पेशकश कर रहा हूं, जो आईएमएचओ ए की तुलना में कम पारदर्शी नहीं है, और मेरी धारणा के लिए अधिक समझ में आता है।

C)
DeviceConnect;
NoError: = True;
Thử
जबकि NoError और DeviceConnected करते हैं
शुरू करना
यदि ReadCommand तो ProceedCommand;
यदि नहीं लिखा है
अंत;
अंत में
TryDisconnectDevice;
अंत;



Gero ©   (2004-11-18 00:16) [26]


> जबकि NoError (Arr [i]) और (i <High (Arr)) करते हैं
> शुरू करो
> <कोड>
> अंत;

यह कोड मेरे अनुरूप नहीं है।

> अगर आप ऐसी बात करते हैं, तो एक लेबल का उपयोग क्यों न करें?
> भाषा क्योंकि यह अनुमति देता है। इनलाइन का उपयोग क्यों नहीं करते?

क्योंकि कोई जरूरत नहीं है।
व्यक्तिगत रूप से, मेरे पास कोई सिद्धांत नहीं है, यह मेरे लिए एक लेबल के साथ अधिक सुविधाजनक होगा - मैं इसे एक लेबल के साथ करूंगा, यह इनलाइन के साथ अधिक सुविधाजनक होगा - मैं इसे इनलाइन करूंगा, साथ ही जारी, तोड़, आदि।
एल्गोरिथ्म की सभी बारीकियों के बारे में अग्रिम रूप से सोचना असंभव है, इसके अलावा, आपको इसे संपादित करना पड़ सकता है।
और काम के सभी तर्क को फिर से लिखने के लिए नहीं, कभी-कभी यह सिर्फ सही जगह पर ब्रेक लगाने के लिए पर्याप्त है ...



Palladin ©   (2004-11-18 00:17) [27]

दुर्भाग्य से, यदि कमांड पठनीय नहीं है, तो आपको तुरंत बाहर निकलना होगा ...



Defunct ©   (2004-11-18 00:28) [28]

Gero © (18.11.04 00: 16) [26]
> क्योंकि कोई जरूरत नहीं है।
मैं आपके तर्क को स्वीकार करता हूं।

हमारे पास ब्रेक (जारी) के मामले में समान ("कोई आवश्यकता नहीं") है।

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

पल्लेदिन © (18.11.04 00: 17) [27]
ठीक है, तत्काल बाहर निकलने के साथ:

C)
DeviceConnect;
NoError: = True;
Thử
जबकि NoError और DeviceConnected करते हैं
शुरू करना
यदि नहीं पढ़े गए हैं तो NoError: = और गलत
यदि नहीं लिखा है
ProceedCommand
अंत;
अंत में
TryDisconnectDevice;
अंत;



Palladin ©   (2004-11-18 00:34) [29]

नहीं, कमांड पढ़ें, निष्पादित करें, कमांड लिखें।



Игорь Шевченко ©   (2004-11-18 00:40) [30]


> और मैं आपको गारंटी देता हूं कि ब्रेक के बिना, जारी रखें, गोटो, बाहर निकलें,
> इनलाइन और दूसरों का उल्लेख, आप आसानी से कर सकते हैं, और
> हमेशा। (ऑपरेटरों अनुभाग में पास्कल पर किसी भी पुस्तक में लिखा गया है)।


पुस्तक को कचरे में फेंक दें। ईमानदार सलाह।
कोड में मुख्य बात इसकी पठनीयता है, और प्रकार के अतिरिक्त चर की शुरुआत के साथ यह बिगड़ता है।



Palladin ©   (2004-11-18 00:42) [31]

और यह मजबूत है, क्योंकि पढ़ते समय चक्र के शरीर में इसके परिवर्तन का पता लगाना आवश्यक है। कभी-कभी यह नरक बन जाता है।



Defunct ©   (2004-11-18 00:47) [32]

पल्लेदिन © (18.11.04 00: 34) [29]

कार्यों के अनुक्रम का निरीक्षण करें:
D)

DeviceConnect; NoError: = True; कोशिश जबकि NoError और DeviceConnected करते हैं NoError: = ReadCommand और ProceedCommand और WriteCommand अंत में TryDisconnectDevice; समाप्त;

इगोर शेवचेंको © (18.11.04 00: 40) [30]
> कोड में मुख्य बात इसकी पठनीयता है
इसके बारे में और भाषण।
किया एक लाक्षणिक उदाहरण है।
उदाहरण D) A से कम स्पष्ट है] [22]

> पुस्तक को कूड़ेदान में फेंक दें। ईमानदार सलाह।
सिर्फ इसलिए कि यह पास्कल की "परिपूर्णता" को इंगित करता है?



Palladin ©   (2004-11-18 00:49) [33]


> [32] कमी © (18.11.04 00: 47)

:) दुर्भाग्य से, ProceedCommand एक फ़ंक्शन नहीं है, निष्पादन का परिणाम लूप के निकास / निरंतरता को प्रभावित नहीं करता है।



Defunct ©   (2004-11-18 00:52) [34]

> :) दुर्भाग्य से, ProceedCommand एक फ़ंक्शन नहीं है, निष्पादन का परिणाम लूप के निकास / निरंतरता को प्रभावित नहीं करता है।

;)
यह कोई समस्या नहीं है:

समारोह ProceedCommand: बूलियन;
शुरू करना
<प्रक्रिया कोड>;
परिणाम: = सत्य
अंत;



Игорь Шевченко ©   (2004-11-18 00:55) [35]

अयोग्य © (18.11.04 00: 47) [32]

D का कोड तर्क से कोड A से अलग है। यानी मूल की तरह काम न करने की गारंटी। यद्यपि अधिक पठनीय है।


> सिर्फ इसलिए कि यह पास्कल की "परिपूर्णता" को इंगित करता है?


यह "पूर्णता" नहीं है। ऐसी सलाह प्रोग्रामिंग के समय या संरचित प्रोग्रामिंग के युग में दी गई थी। उसके बाद, वे इस निष्कर्ष पर पहुंचे कि नियंत्रण बयान (ब्रेक, कंटिन्यू, एग्जिट) की शुरूआत कोड की पठनीयता में सुधार करती है।



Игорь Шевченко ©   (2004-11-18 01:02) [36]

मैं कोड को निम्नानुसार व्यवस्थित करूंगा

ConnectDevice; कोशिश कोशिश जबकि सच्चा शुरू करते हैं ReadCommand; ProceedCommand; WriteCommand; अंत; सिवाय ई पर: EDeviceNotConnected करते हैं .... अंत में DisconnectDevice; अंत;

और अंदर ReadCommand और WriteCommand लिखेंगे
  यदि DeviceConnected नहीं है EDeviceNotConnected.Create (...) बढ़ाएँ; .....



Palladin ©   (2004-11-18 01:04) [37]

खैर, निश्चित रूप से यह कोई समस्या नहीं है। अगर ProceedCommand प्रक्रिया। लेकिन अगर यह अभी भी एक फ़ंक्शन है जो कमांड निष्पादन का परिणाम देता है? लेकिन बुलियन नहीं, बल्कि, कहते हैं, इंटेगर, जिसे तब भी विश्लेषण करने की आवश्यकता होती है और जो कुछ शर्तों के तहत लूप शरीर से बाहर निकलने को प्रभावित करता है ...

वैसे, ए में) एक गलती की गई थी। आखिरकार, रिकॉर्डिंग से पहले डिवाइस को तत्परता के लिए जांचना आवश्यक है ... लेकिन सिद्धांत रूप में यह बकवास है, और यह एक साथ बंधा हुआ है। एक और बिंदु: क्या आप सुनिश्चित हैं कि आदेशों को ठीक उसी क्रम में निष्पादित किया जाएगा जिस क्रम में वे लिखे गए हैं? किसी कारण के लिए, मैं नहीं जानता ... कौन जानता है, यह आशावादी ... ठीक है, कि इसके साथ नरक भी है ... लेकिन फिर यह एक गलती की तलाश में असुविधाजनक है ...

फिर, यह सबसे सरल उदाहरण है। इसके लिए, इसलिए, एक अस्थिर, लचीले रूप में "अनुकूलन" बोलने के लिए, आपको विकल्प A के लिए किए जाने की तुलना में बहुत अधिक समय लगा ...) आपको क्या लगता है ... क्या यह अच्छा है?



Palladin ©   (2004-11-18 01:11) [38]


> [36] इगोर शेवचेंको

ठीक है, तुम बहुत हो ... तलवार के साथ, फिर तुरंत गाँठ पर ... :)



Defunct ©   (2004-11-18 01:15) [39]

इगोर शेवचेंको © (18.11.04 00: 55) [35]
> मूल से अलग काम करने की गारंटी।

मुझे नहीं पता कि मूल कैसे काम करता है, क्योंकि मैं नहीं जानता कि वास्तव में कितने उपकरण हैं। DeiveConnect की शुरुआत और अंत में अनुभाग यह स्पष्ट करता है कि डिवाइस एक है, लेकिन किसी कारण से दो कार्य हैं IsDeviceConnected और DeviceConnected। सवाल यह है कि डिवाइस के एक होने पर दो कार्य क्यों होते हैं? यदि हम उदाहरण ए के तर्क का पूरी तरह से पालन करते हैं तो हमें प्राप्त होता है:

जबकि कोई गुरेज़ नहीं NoError: = IsDeviceConnected और ReadCommand और ProceedCommand और DeviceConnected और WriteCommand

और ब्रेक अनिवार्य रूप से आवश्यक नहीं है।

> ऐसी सलाह प्रोग्रामिंग के समय या संरचित प्रोग्रामिंग के युग में दी गई थी।

हो सकता है कि।

> कि नियंत्रण कथनों को शुरू करने से कोड की पठनीयता में सुधार होता है।

IMHO जैसे किसी के लिए।
खैर, कम से कम मैं ज्यादातर asm के लिए खाना खाता हूं (और वहां आप ठोस "गोटो" को समझते हैं), लेकिन जब पास्कल की बात आती है तो मैं अतीत की सिफारिशों का पालन करने की कोशिश करता हूं (मैं ब्रेक, कंट, गोटो, एग्जिट का उपयोग किए बिना लिखता हूं)। और कोड काफी पठनीय हो जाता है और कोड से मुख्य चीज एल्गोरिथ्म है जो तुरंत दिखाई देती है, जिसके लिए मुझे पास्कल पसंद है।



Palladin ©   (2004-11-18 01:19) [40]

IsDeviceConnected और DeviceConnected समान हैं ... बस दूसरी बार लिखना भूल गए हैं ...



पन्ने: 1 2 3 4 पूरी शाखा

मंच: "मुख्य";
वर्तमान संग्रह: 2004.12.12;
डाउनलोड करें: [xml.tar.bz2];

ऊपर





मेमोरी: 0.74 एमबी
समय: 0.077 c
14-1101105848
IMHO
2004-11-22 09:44
2004.12.12
प्रवास के बारे में शब्द


4-1098942649
अतिथि
2004-10-28 09:50
2004.12.12
प्रोग्राम को स्टार्टअप पर व्यवस्थापक अधिकार कैसे प्राप्त करें


4-1099046847
छात्र KNTU
2004-10-29 14:47
2004.12.12
जीत एपीआई + मॉनिटर


8-1094655749
बीर पीने के लिये मिट्टी का प्याला
2004-09-08 19:02
2004.12.12
TImage के साथ काम करें


1-1101806334
एलेक्स
2004-11-30 12:18
2004.12.12
पॉपअप मेनू





अफ्रीकी अल्बानियन अरबी भाषा अर्मेनियाई आज़रबाइजानी बस्क बेलारूसी बल्गेरियाई कैटलन सरलीकृत चीनी) चीनी पारंपरिक) क्रोएशियाई चेक डेनिश डच अंग्रेज़ी एस्तोनियावासी फिलिपिनो फिनिश फ्रेंच
गैलिशियन् जॉर्जियाई जर्मन यूनानी हाईटियन यहूदी हिंदी हंगरी आइसलैंड का इन्डोनेशियाई आयरिश इतालवी जापानी कोरियाई लात्वीयावासी लिथुआनियाई मेसीडोनियन मलायी मोलतिज़ नार्वेजियन
फ़ारसी पोलिश पुर्तगाली रोमानियाई रूसी सर्बियाई स्लोवाक स्लोवेनियाई स्पेनिश स्वाहिली स्वीडिश थाई तुर्की यूक्रेनी उर्दू वियतनामी वेल्श यहूदी बंगाली बोस्नियाई
सिबुआनो एस्पेरांतो गुजराती हौसा हमोंग ईग्बो जावानीस कन्नड़ खमेर लाओ लैटिन माओरी मराठी मंगोलियन नेपाली पंजाबी सोमाली तामिल तेलुगु योरूबा
ज़ुलु
Английский Французский Немецкий Итальянский Португальский Русский Испанский