1
00:00:00,000 --> 00:00:00,560

2
00:00:00,560 --> 00:00:02,460
>> డేవిడ్ J. మలన్: యొక్క విషయాలు తీసుకుందాం
మరొక్క అడుగు, ఇప్పుడు.

3
00:00:02,460 --> 00:00:05,450
నేను అనుకుంటున్న అనుకుందాం
నా ప్రోగ్రామ్ యొక్క అన్ని ముద్రించడానికి

4
00:00:05,450 --> 00:00:06,630
ఆదేశ పంక్తి వాదనలు.

5
00:00:06,630 --> 00:00:10,490
కానీ నేను, బదులుగా, అన్ని ప్రింట్ మీరు
ప్రతి వ్యక్తిగత అక్షరాలు

6
00:00:10,490 --> 00:00:14,060
నా ఆదేశ పంక్తి వాదనలు, ఒక శాతం
లైన్, కాబట్టి ఈ నడుస్తున్న మీద

7
00:00:14,060 --> 00:00:17,490
కార్యక్రమం, నేను కేవలం ఒక ప్రవాహం చూడవచ్చు
తెరపై పాత్రలు

8
00:00:17,490 --> 00:00:20,700
సమిష్టిగా నా క్రమం నుండి
కమాండ్ లైన్ వాదనలు.

9
00:00:20,700 --> 00:00:21,980
>> Well, నేను ఈ చేయవచ్చు?

10
00:00:21,980 --> 00:00:26,540
నేను ముందు నుండి నా లూప్ చెక్కుచెదరకుండా ఉంచుకోవచ్చు
నేను వరకు నేను నుండి పునరుత్థాన అనగా

11
00:00:26,540 --> 00:00:30,060
Argc పైగా సరదా
ఆదేశ పంక్తి వాదనలు తమను.

12
00:00:30,060 --> 00:00:34,460
కానీ ఇప్పుడు, ఆ యొక్క ప్రతి పునరావృతం లోపల
లూప్, నేను ఇప్పుడు ప్రతి పైగా iterate అవసరం

13
00:00:34,460 --> 00:00:38,550
అక్షరాలు లేదా అక్షరాలు
ఒక నిర్దిష్ట స్ట్రింగ్ లో.

14
00:00:38,550 --> 00:00:40,620
కాబట్టి అలా, నేను ఒక మరింత లూప్ అవసరం.

15
00:00:40,620 --> 00:00:42,090
>> యొక్క ఆ జోడించడానికి అనుమతిస్తుంది.

16
00:00:42,090 --> 00:00:46,890
Int కోసం, యొక్క j కాల్, 0 సమానం.

17
00:00:46,890 --> 00:00:49,980
ఇప్పుడు నేను ఇంటిగ్రేట్ అవసరం వెళుతున్న
పొడవు వరకు

18
00:00:49,980 --> 00:00:52,310
argv లో ప్రస్తుత స్ట్రింగ్.

19
00:00:52,310 --> 00:00:55,910
నాలో నాకు మరొక స్థానిక ఇస్తాను
వేరియబుల్, మేము n కాల్, సెట్ చేస్తాము

20
00:00:55,910 --> 00:01:00,120
యొక్క స్ట్రింగ్ పొడవు సమాన
అన్నారు ఇది ప్రస్తుత వాదన,

21
00:01:00,120 --> 00:01:04,230
argv బ్రాకెట్ కనిపించే నేను సెమికోలన్.

22
00:01:04,230 --> 00:01:08,500
>> నాకు ఇప్పుడు j అప్ నుండి iterate లెట్
n ఒక తరువాత వరకు

23
00:01:08,500 --> 00:01:10,400
ప్రతి పునరావృతం న పెంచడం.

24
00:01:10,400 --> 00:01:13,850
యొక్క ఇప్పుడు వ్యక్తిగత ప్రింట్ తెలియజేయండి
తెరపై అక్షరాలు.

25
00:01:13,850 --> 00:01:21,920
Printf% సి ఈసారి ఒక కొత్త తరువాత
లైన్, దగ్గరగా కోట్, కామా, మరియు ఇప్పుడు నేను

26
00:01:21,920 --> 00:01:25,565
j-th పాత్ర అవసరం
i-th వాదనలో.

27
00:01:25,565 --> 00:01:30,240
>> కాబట్టి ఆ వద్ద పొందడానికి, నేను కేవలం చెయ్యవచ్చు
ARV బ్రాకెట్ నేను విశదీకరిస్తుంది

28
00:01:30,240 --> 00:01:32,050
i-th వాదన పొందండి.

29
00:01:32,050 --> 00:01:36,140
ఆపై నేను లోతైన ఒక స్థాయి లో డైవ్ చేయవచ్చు
మరియు ఒక ఉన్నత ఇండెక్స్ చేయండి

30
00:01:36,140 --> 00:01:40,420
బ్రాకెట్ j, దగ్గరగా కుండలీకరణములలో
సెమికోలన్, సేవ్.

31
00:01:40,420 --> 00:01:43,610
మరియు ఇప్పుడు సంకలనం తెలియజేయండి మరియు
ఈ ప్రోగ్రామ్ రన్.

32
00:01:43,610 --> 00:01:46,630
>> ARGV2 చేయండి -

33
00:01:46,630 --> 00:01:48,440
అదేవిధంగా చెప్పుకోదగ్గ ఏ.

34
00:01:48,440 --> 00:01:50,740
మొదటి వరకు స్క్రోల్ లెట్
ఈ లోపం సందేశాలను.

35
00:01:50,740 --> 00:01:54,540
మరియు ఇక్కడ ఎరుపు లో, మేము తప్పు చూడండి,
పరిపూర్ణంగా ప్రకటించారు లైబ్రరీ ఫంక్షన్

36
00:01:54,540 --> 00:01:56,290
రకం strlen -

37
00:01:56,290 --> 00:01:57,380
ఓహ్, ఒక నిమిషం వేచి.

38
00:01:57,380 --> 00:02:00,340
ఈ నేను ఉపయోగించిన మొదటి సమయం
strlen, మరియు నేను ముందుగా లేదు

39
00:02:00,340 --> 00:02:04,970
మొదటి వద్ద ఇది కోరికతో అలా నేను చేర్చలేదు
ఉపయోగించడమనేది శీర్షికా ఫైలును

40
00:02:04,970 --> 00:02:06,290
ఒక స్ట్రింగ్ పొడవు ఫంక్షన్.

41
00:02:06,290 --> 00:02:09,419
>> , నా ఫైలు యొక్క పైభాగంలో
రీకాల్, నేను cs50.h. కలిగి

42
00:02:09,419 --> 00:02:11,080
నేను ప్రామాణిక io.h. కలిగి

43
00:02:11,080 --> 00:02:14,500
కానీ అవుతుంది, మరియు నేను నుండి ఈ తెలుసు
నేను అవసరమైన, డాక్యుమెంటేషన్ చదవడం

44
00:02:14,500 --> 00:02:18,320
మూడవ శీర్షికా ఫైలును ఉంటే నేను, నిజానికి,
strlen ఫంక్షన్ ఉపయోగించాలనుకుంటున్నాను.

45
00:02:18,320 --> 00:02:22,760
ఆ ఫంక్షన్ string.h లో ప్రకటిస్తారు.

46
00:02:22,760 --> 00:02:25,230
>> యొక్క ఫైలు resave లెట్,
కంపైల్ మరియు అమలు.

47
00:02:25,230 --> 00:02:32,360

48
00:02:32,360 --> 00:02:35,570
మరియు ఈ సమయంలో, మేము కేవలం చేయండి
వాదనలు ప్రతి చూడండి.

49
00:02:35,570 --> 00:02:40,470
మేము బదులుగా వాదనలు ప్రతి చూడండి
ఒక సమయంలో ఒక పాత్ర.

50
00:02:40,470 --> 00:02:43,165