1
00:00:07,370 --> 00:00:09,760
[Powered by Google Translate] ٹومی MACWILLIAM: loops کے بارے میں چلو بات عام میں سے ایک

2
00:00:09,760 --> 00:00:13,380
پروگرامنگ کی تعمیر ہم نے CS50 بھر نظر آئے گا.

3
00:00:13,380 --> 00:00:15,570
ہم loops استعمال کرتے ہیں جب ہم ایک کو انجام دینے کے لئے چاہتے ہیں کریں گے

4
00:00:15,570 --> 00:00:17,200
کام ایک بار سے زیادہ.

5
00:00:17,200 --> 00:00:20,700
مثال کے طور پر، ہم نے "ہیلو" 100 بار یا پرنٹ کو پرنٹ کرنے کے لئے چاہتے ہو سکتا ہے

6
00:00:20,700 --> 00:00:22,700
حروف تہجی کے تمام حروف کے باہر.

7
00:00:22,700 --> 00:00:26,030
ان دونوں مقدمات کی میں، ہم ایک چیز جو ہم کرنا چاہتے ہیں

8
00:00:26,030 --> 00:00:28,700
کئی بار، کچھ باہر پرنٹ.

9
00:00:28,700 --> 00:00:31,970
تاہم، ہر وقت مختلف جو ہم پرنٹ کر سکتے ہیں.

10
00:00:31,970 --> 00:00:34,530
تو ہم نے ہر ایک پر کچھ تھوڑا سا مختلف کر سکتے ہیں

11
00:00:34,530 --> 00:00:37,820
iteration، لوپ یا کے ذریعے چلاتے ہیں،.

12
00:00:37,820 --> 00:00:41,280
ہم C میں loops کے تین مختلف اقسام کو دیکھ لیں گے، جبکہ

13
00:00:41,280 --> 00:00:44,700
loops، loops کے لئے، اور جبکہ loops کرتے ہیں.

14
00:00:44,700 --> 00:00:47,850
اگرچہ loops کے ان تین اقسام مختلف نحو ہے،

15
00:00:47,850 --> 00:00:50,630
ان کے پیچھے خیالات ایک جیسے ہیں.

16
00:00:50,630 --> 00:00:53,930
ہم گھوبگھرالی منحنی خطوط وحدانی کے اندر کوڈ کے کچھ بلاک کی وضاحت کریں گے،

17
00:00:53,930 --> 00:00:57,810
نے لوپ کے جسم کو فون کیا کہ ہم کو قتل کرنا چاہتے ہیں،

18
00:00:57,810 --> 00:00:59,790
کئی بار کچھ.

19
00:00:59,790 --> 00:01:03,370
متغیرات میں سے اقدار جسم میں استعمال میں تبدیلی سے ہم

20
00:01:03,370 --> 00:01:07,570
ہماری لوپ ہر وقت اسے چلانے کے کچھ مختلف کر سکتے ہیں.

21
00:01:07,570 --> 00:01:10,750
کوئی لوپ ہم لکھ کے ساتھ، ہم نے فیصلہ بھی ضرورت پڑے گی جب

22
00:01:10,750 --> 00:01:12,400
لوپ چلنا بند ہو جائیں گے.

23
00:01:12,400 --> 00:01:15,650
اگر ہم ایسا نہیں کرتے، ہمارے بروسیمند کمپیوٹر کو جاری رکھیں گے، تو

24
00:01:15,650 --> 00:01:19,040
اس لوپ کو چلانے کے جب تک ہم اس پروگرام کو قتل.

25
00:01:19,040 --> 00:01:22,490
شروع میں، ہم دوبارہ ن بار استعمال کر سکتے ہیں

26
00:01:22,490 --> 00:01:24,600
ایک لوپ پیدا بلاک.

27
00:01:24,600 --> 00:01:28,200
ایک بلاک کے اندر کر ٹکڑے ٹکڑے کر کے تمام 10 دوبارہ نے کہا کہ

28
00:01:28,200 --> 00:01:30,130
10 بار چلانے کے لئے کیا جائے گا.

29
00:01:30,130 --> 00:01:34,160
اور پھر، ہم نے اس لوپ کے بعد ٹکڑے ٹکڑے پر منتقل تھا.

30
00:01:34,160 --> 00:01:38,140
تو ہمارا سٹاپ حالت صرف تھا، اس بلاک کر دیا گیا ہے

31
00:01:38,140 --> 00:01:39,830
10 بار چلاتے ہیں.

32
00:01:39,830 --> 00:01:43,900
تو سی کے لئے میں یہ دوبارہ سکریچ کو یقینی بنانے کے لئے

33
00:01:43,900 --> 00:01:46,920
کہ دوبارہ بلاک کے اندر اندر کر ٹکڑے ٹکڑے کر پھانسی

34
00:01:46,920 --> 00:01:51,180
بالکل 10 بار سکریچ ہر ایک کی ٹریک رکھنے کے لئے کی ضرورت ہے

35
00:01:51,180 --> 00:01:53,750
دوبارہ بلاک کی کارکردگی.

36
00:01:53,750 --> 00:01:56,790
کتنی بار ہماری لوپ جسم دیا گیا ہے ٹریک رکھنے کے لئے

37
00:01:56,790 --> 00:02:00,360
دو پھانسی، نامی میں متغیر بنانے کے.

38
00:02:00,360 --> 00:02:03,400
ہم نے صفر پر شروع ہمارے لوپ کے بعد کریں گے،

39
00:02:03,400 --> 00:02:04,650
ہے چلانے کے لئے ابھی تک نہیں کیا گیا ہے.

40
00:02:10,009 --> 00:02:10,949
ٹھیک ہے

41
00:02:10,949 --> 00:02:15,560
اب ہم نے دیر کے مطلوبہ الفاظ کا استعمال ہمارے لوپ شروع کر دیں گے.

42
00:02:20,100 --> 00:02:24,180
اب ہم یہ اعداد و شمار جب ہمارے لوپ بند ہو جائیں گے کے لئے کی ضرورت ہے، لیکن گے

43
00:02:24,180 --> 00:02:26,730
اب کے لئے یہ چھوڑ دو اور پھر اس کے بعد واپس آ.

44
00:02:30,970 --> 00:02:32,150
ٹھیک ہے.

45
00:02:32,150 --> 00:02:35,260
ہمارے لوپ کے اندر، صرف ایک پیغام پرنٹ، جیسے

46
00:02:35,260 --> 00:02:38,535
"ہیلو." ہم اس کے لئے printf کام کا استعمال کر سکتے ہیں.

47
00:02:48,400 --> 00:02:49,230
ٹھیک ہے.

48
00:02:49,230 --> 00:02:54,210
تو کیا اب ہم ریکارڈ کہ لوپ کے جسم کے ایک iteration ہے.

49
00:02:54,210 --> 00:02:55,750
کیا گیا ہے پھانسی.

50
00:02:55,750 --> 00:03:00,320
ہم 1 انہوں نے مزید کہا، یا incrementing کی طرف سے ایسا کر سکتے ہیں، ہماری انسداد

51
00:03:00,320 --> 00:03:01,740
متغیر،.

52
00:03:01,740 --> 00:03:09,180
ایسا کرنے کے لیے ہم کہتے ہیں، کر سکتے ہیں میں کے علاوہ 1، یا اس سے زیادہ کے برابر ہے

53
00:03:09,180 --> 00:03:16,520
صرف، میں پلس پلس.

54
00:03:16,520 --> 00:03:17,320
بہت اچھا ہے.

55
00:03:17,320 --> 00:03:21,810
تو کیا اب ہم دیکھتے ہیں کہ ہر وقت ہمارے لوپ چلایا جاتا ہے کر سکتے ہیں، ہماری

56
00:03:21,810 --> 00:03:24,500
انسداد متغیر ایک کے بعد تک جاتا ہے.

57
00:03:24,500 --> 00:03:29,410
تو ہم پتہ ہے بالکل کتنی تکرار ہم اب تک چلائے گئے.

58
00:03:29,410 --> 00:03:31,630
کے بعد لوپ میں سے ایک iteration، ہماری قیمت

59
00:03:31,630 --> 00:03:34,270
میں 1 ہو جائے گا.

60
00:03:34,270 --> 00:03:37,460
دو تکرار کے بعد، میں نے 2 ہو جائے گا.

61
00:03:37,460 --> 00:03:42,640
اور میں 10 تکرار کے بعد 10 ہو جائے گی.

62
00:03:42,640 --> 00:03:46,780
تو ٹھیک اگر ہم اس لوپ کو چلانا چاہتے ہیں 10 بار پھر،

63
00:03:46,780 --> 00:03:49,240
ہے جب ہم روکنا چاہتا ہوں.

64
00:03:49,240 --> 00:03:53,860
تو ہم اس لوپ جب میں سے کم 10 ہے چلانا چاہتے ہیں، اور

65
00:03:53,860 --> 00:03:57,630
جو بالکل ہم کیا لکھیں گے ہے، جبکہ میں

66
00:03:57,630 --> 00:04:02,450
سے کم 10 ہے.

67
00:04:02,450 --> 00:04:06,380
یہ حالت صرف اگر کے حالات ہم کرتے تھے کی طرح لگتا ہے

68
00:04:06,380 --> 00:04:07,830
ورنہ بلاکس.

69
00:04:07,830 --> 00:04:11,690
کے بعد ہمارے لوپ کی لاش پھانسی ہو گیا ہے، ہمارے پروگرام

70
00:04:11,690 --> 00:04:14,690
loops حالت واپس کود جائے گا.

71
00:04:14,690 --> 00:04:17,290
اگر حالت درست ہے، تو کی لاش

72
00:04:17,290 --> 00:04:18,990
لوپ کو دوبارہ چلایا جائے گا.

73
00:04:18,990 --> 00:04:22,190
اگر حالت اب سچ ہے، تو ہمارے لوپ نہیں ہو جائے گا

74
00:04:22,190 --> 00:04:25,700
اب چلائیں اور کوڈ کی اگلی لائن پر منتقل نہیں کریں گے

75
00:04:25,700 --> 00:04:27,876
ہمارے لوپ کے نیچے.

76
00:04:27,876 --> 00:04:28,550
ٹھیک ہے.

77
00:04:28,550 --> 00:04:30,740
تو ایک دوسری قسم کی پر ایک نظر لے

78
00:04:30,740 --> 00:04:33,000
لوپ، لوپ کے لئے.

79
00:04:33,000 --> 00:04:37,310
جبکہ مطلوبہ الفاظ کے ساتھ دیئے گئے، قوسین میں، ہم ایک بات تھی،

80
00:04:37,310 --> 00:04:39,840
شرط یہ ہے کہ کے لئے درست کرنے کی ضرورت ہے

81
00:04:39,840 --> 00:04:42,010
لوپ جسم کو چلانے کے لئے.

82
00:04:42,010 --> 00:04:45,440
اس کا مطلب ہمیں ہمارے انسداد متغیر کے باہر تخلیق تھا

83
00:04:45,440 --> 00:04:48,760
کچھ نقطہ پر لوپ اور اضافہ یاد

84
00:04:48,760 --> 00:04:51,050
اندر لوپ.

85
00:04:51,050 --> 00:04:54,320
لوپ کے لئے ہماری کے لئے ہیڈر، دوسری طرف، تین ہے

86
00:04:54,320 --> 00:04:58,510
حصوں، جن میں سے ہر ایک نیم وقفہ سے علیحدہ رکھا جائے گا.

87
00:04:58,510 --> 00:05:01,950
ہماری پہلی تہائی میں، ہم کسی بھی کاؤنٹر یا مددگار کا اعلان کر سکتے ہیں

88
00:05:01,950 --> 00:05:05,000
متغیر ہم ہمارے لوپ میں استعمال کرنا چاہتے ہیں.

89
00:05:05,000 --> 00:05:07,350
عملی طور پر یہ بہت مددگار ثابت ہو سکتا ہے.

90
00:05:07,350 --> 00:05:10,590
ہم واقعی میں ہمارے دیر کے بعد اس متغیر، میں، کی ضرورت نہیں ہے

91
00:05:10,590 --> 00:05:13,650
لوپ ختم ہو گیا ہے، تو ہم واقعی اس کا اعلان کرنے نہیں ہونا چاہئے

92
00:05:13,650 --> 00:05:15,810
لوپ کے باہر.

93
00:05:15,810 --> 00:05:19,080
دوسری تیسری شرط یہ سچ ہونا ضروری ہے ہو جائے گا

94
00:05:19,080 --> 00:05:21,850
کے لئے جسم دوبارہ ویسے ہی جیسے پھانسی،

95
00:05:21,850 --> 00:05:23,330
ہمارے جبکہ لوپ میں.

96
00:05:23,330 --> 00:05:26,350
ہمارا آخری تہائی میں، ہم نے ایک بیان میں کہا ہے کہ ہو جائے گا چلائیں کر سکتے ہیں

97
00:05:26,350 --> 00:05:30,270
لوپ میں سے ہر ایک iteration کے بعد پھانسی دے دی ہے، تو ہمارے پاس نہیں ہے

98
00:05:30,270 --> 00:05:32,710
لوپ کے جسم میں تعمیر.

99
00:05:32,710 --> 00:05:38,390
تو لوپ کہ 5 سے 1 شمار کے لئے ایک لکھ.

100
00:05:38,390 --> 00:05:41,790
ہم اس کے لئے مطلوبہ الفاظ کے ساتھ شروع کریں گے.

101
00:05:41,790 --> 00:05:44,680
پہلے ہم نے ایک متضاد متغیر تشکیل دیتے ہیں، کر سکتے ہیں جو ہم کریں گے

102
00:05:44,680 --> 00:05:47,840
5 اس وقت کا تعین کے بعد ہم نیچے کی گنتی کر رہے ہیں،

103
00:05:47,840 --> 00:05:50,110
ایک نیم وقفہ کے بعد.

104
00:05:50,110 --> 00:05:53,660
اگلا، دوسرا ہماری حالت ہے، جس پر ہم واپس آ گے ہے.

105
00:05:53,660 --> 00:05:57,540
تیسرے، ہم نے کے بعد ہماری انسداد متغیر تدریج کریں کرنا چاہتے ہیں

106
00:05:57,540 --> 00:05:59,620
لوپ میں سے ہر ایک iteration.

107
00:05:59,620 --> 00:06:04,740
بلکہ میں پلس پلس کہہ رہے سے، ہم میں مائنس مائنس کہیں گے.

108
00:06:04,740 --> 00:06:05,300
ٹھیک ہے.

109
00:06:05,300 --> 00:06:09,490
تو ہم لوپ جسم کو چلانے کے کرنا چاہتے ہیں جبکہ میں اب بھی ہے

110
00:06:09,490 --> 00:06:11,960
0 سے بڑا ہے.

111
00:06:11,960 --> 00:06:16,160
لوپ کے جسم میں دو، میں کی قدر کو پرنٹ کریں.

112
00:06:16,160 --> 00:06:20,480
ایسا کرنے کے لئے، ہم printf تقریب کا استعمال،٪ د کا استعمال کرتے ہوئے کریں گے

113
00:06:20,480 --> 00:06:21,650
پلیس ہولڈر.

114
00:06:21,650 --> 00:06:24,820
یاد رکھنا چاہیے کہ پلیس ہولڈر کے ساتھ تبدیل کیا جائے گا

115
00:06:24,820 --> 00:06:27,040
میں کی قدر.

116
00:06:27,040 --> 00:06:32,060
آخر میں، لوپ کے لئے ہماری کے بعد ایک بیان شامل کریں.

117
00:06:32,060 --> 00:06:35,850
جب ہم اس لوپ کو چلاتے ہیں، میں 5 بجے شروع ہو جائے گا،

118
00:06:35,850 --> 00:06:38,070
تو 5 طباعت رکھا جائے گا.

119
00:06:38,070 --> 00:06:42,000
ایک بار میں 0 ہو جاتا ہے، تسلسل شرط میں ہے

120
00:06:42,000 --> 00:06:44,450
0 سے بڑا ہے، اب نہیں کریں گے.

121
00:06:44,450 --> 00:06:47,330
لہذا ہمارے لوپ قتل بند کرو، اور ہم دیکھیں گے

122
00:06:47,330 --> 00:06:49,850
لوپ کے بعد بیان.

123
00:06:49,850 --> 00:06:51,340
تو اس کوڈ کو چلانے کے.

124
00:06:51,340 --> 00:06:52,700
سب سے پہلے، ہم ایک مرتب کریں گے

125
00:06:52,700 --> 00:06:56,460
الٹی گنتی بنانے کے ساتھ countdown.c.

126
00:06:56,460 --> 00:06:59,320
اب، ہم الٹی گنتی / کے ساتھ اس کوڈ کو چلا سکتے ہیں.

127
00:07:02,340 --> 00:07:06,040
دونوں دیر loops اور loops کے لئے، ہماری جاری

128
00:07:06,040 --> 00:07:09,010
حالت جسم سے پہلے جانچ پڑتال کی جائے گی

129
00:07:09,010 --> 00:07:10,960
لوپ پھانسی ہے.

130
00:07:10,960 --> 00:07:13,840
اس کا مطلب ہے کہ اگر ہماری حالت ابتدائی طور پر نہیں ہے

131
00:07:13,840 --> 00:07:18,100
سچ، تو ہمارے لوپ کے جسم کو چلانے کے کبھی نہیں رکھا جائے گا.

132
00:07:18,100 --> 00:07:22,060
تو یہ کبھی کبھی مفید ہے کے بعد کی حالت چیک کرنے کے لیے

133
00:07:22,060 --> 00:07:25,150
لوپ کی لاش کی بجائے اس سے پہلے.

134
00:07:25,150 --> 00:07:28,270
تو ایک بڑی تعداد کے لئے صارف کو فوری طور پر کے لئے ایک لوپ لکھنے

135
00:07:28,270 --> 00:07:30,990
جب تک ایک مثبت نمبر فراہم کرتا ہے.

136
00:07:30,990 --> 00:07:34,740
اگر صارف ایک منفی نمبر آدانوں، ہم ان سے پوچھنا چاہتا ہوں گے

137
00:07:34,740 --> 00:07:36,260
دوسرے نمبر کے لئے.

138
00:07:36,260 --> 00:07:38,940
تو ہم اس کے اندر فوری طور پر کرنا چاہتے ہیں کریں گے

139
00:07:38,940 --> 00:07:41,050
لوپ بند جسم.

140
00:07:41,050 --> 00:07:44,730
تاہم، جب لوپ پہلی بار کے لئے چلایا جاتا ہے تو، صارف

141
00:07:44,730 --> 00:07:46,750
دیا ہے ہمیں نہیں تعداد ابھی تک.

142
00:07:46,750 --> 00:07:49,640
تو اس کا کوئی مطلب نہیں ہے اگر یہ چیک کرنے کے لیے مثبت ہے.

143
00:07:49,640 --> 00:07:54,020
اس کے بجائے، ہم جسم کے بعد نمبر چیک کرنے کے لیے چاہیں گے

144
00:07:54,020 --> 00:07:55,720
لوپ چلایا جاتا ہے.

145
00:07:55,720 --> 00:08:00,310
ہم لوپ جبکہ مت کے ساتھ یہ کر سکتے ہیں.

146
00:08:00,310 --> 00:08:03,560
سب سے پہلے، ہم متغیر بنانے، ن کریں گے گے

147
00:08:03,560 --> 00:08:05,230
صارف کی ان پٹ.

148
00:08:05,230 --> 00:08:09,960
اب ہم مطلوبہ الفاظ، گھوبگھرالی منحنی خطوط وحدانی کے بعد استعمال کریں گے کہ

149
00:08:09,960 --> 00:08:12,930
ہمارے لوپ کے جسم کا آغاز ہو جائے گا.

150
00:08:12,930 --> 00:08:16,230
جسم میں، ہم کے ساتھ ایک بڑی تعداد کے لیے صارف کو فوری طور پر کر سکتے ہیں

151
00:08:16,230 --> 00:08:18,480
تقریب GetInt.

152
00:08:18,480 --> 00:08:23,230
اب، ہم اس لوپ کی لاش کو پھانسی پر پھر چاہیں گے اگر

153
00:08:23,230 --> 00:08:28,370
صارف ایک منفی نمبر ٹائپ، ہم تو کہیں گے جبکہ این

154
00:08:28,370 --> 00:08:30,420
0 سے بھی کم ہے.

155
00:08:30,420 --> 00:08:33,140
نیم وقفہ دیر بیان کے بعد یہاں نوٹس

156
00:08:38,909 --> 00:08:40,679
تو اس کوڈ کو چلانے کے.

157
00:08:40,679 --> 00:08:44,780
سب سے پہلے، ہم مثبت بنانے کے ساتھ اس کی تیاری کریں گے.

158
00:08:44,780 --> 00:08:49,340
اب ہم پروگرام چلانے کے مثبت / سکتے ہیں.

159
00:08:49,340 --> 00:08:52,660
اگر ہم اس پروگرام کو منفی کی طرح ایک منفی نمبر، دیتا

160
00:08:52,660 --> 00:08:56,560
4، تو پھر ہم پھر کے بعد ایک بڑی تعداد کے لئے حوصلہ افزائی کی جائے گی

161
00:08:56,560 --> 00:09:00,490
ہمارے کرتے شرط ہے جبکہ لوپ سچ تھا.

162
00:09:00,490 --> 00:09:04,690
ایک بار ہم نے 8 کی طرح ایک مثبت عدد دے، تو

163
00:09:04,690 --> 00:09:08,560
ہماری کیا کرنے کی شرط جبکہ لوپ درست نہیں ہوں گے.

164
00:09:08,560 --> 00:09:12,080
تو لوپ پھر پھانسی نہیں رکھا جائے گا.

165
00:09:12,080 --> 00:09:15,290
اور یہ کہ اس loops کی تین اقسام ہم C. میں استعمال کریں گے کے لئے ہے

166
00:09:15,290 --> 00:09:18,840
میرا نام ٹومی ہے، اور اس CS50 ہے.