1
00:00:00,000 --> 00:00:03,250
>> 1 વક્તા: હવે એક કાર્યક્રમ લખીએ
તેઓ ખરેખર બે શબ્દમાળાઓ સરખાવે

2
00:00:03,250 --> 00:00:04,245
પાત્ર માટે પાત્ર.

3
00:00:04,245 --> 00:00:06,830
માતાનો તરીકે 0 કરો વાપરો
અમારા શરૂ બિંદુ.

4
00:00:06,830 --> 00:00:11,550
પરંતુ સ્તર પાછા પ્રથમ છાલ દો કે
શબ્દમાળા પ્રકાર છે અને તે લખાણ લખે

5
00:00:11,550 --> 00:00:14,120
તે ખરેખર શું છે, જે
ચાર રચે સ્ટાર છે.

6
00:00:14,120 --> 00:00:17,740
તે એક અક્ષર ની સરનામા છે,
એક માં ખાસ પ્રથમ અક્ષર

7
00:00:17,740 --> 00:00:21,010
અમે વધુ છો કે અક્ષરો ક્રમ
સામાન્ય રીતે શબ્દમાળા તરીકે રજૂ છે.

8
00:00:21,010 --> 00:00:21,880
>> ટી માટે જ.

9
00:00:21,880 --> 00:00:25,660
ચાલો તેને શબ્દમાળા જાહેરાત લખાણ લખે દો
કોલસો બનાવો સ્ટાર તરીકે.

10
00:00:25,660 --> 00:00:28,690
અને હવે અમે જરૂર લાંબા સમય સુધી
કદાચ, ટી સામે એ કરો

11
00:00:28,690 --> 00:00:30,150
અમે બે સરનામા કરો.

12
00:00:30,150 --> 00:00:33,180
અમે ખરેખર કરો માંગો છો
બે શબ્દમાળાઓ પોતાને.

13
00:00:33,180 --> 00:00:37,520
આ કરવા માટે, અમે એક કાર્ય ઉપયોગ કરી શકો છો
string.h માં જાહેર કર્યું.

14
00:00:37,520 --> 00:00:40,920
તેથી હું સમાવેશ થાય છે કે ઉમેરીશ
મારા ફાઈલ ટોચ પર.

15
00:00:40,920 --> 00:00:43,130
>> અને પછી હું ફેરફાર કરવા જઇ રહ્યો છું
અહીં આ વાક્ય.

16
00:00:43,130 --> 00:00:47,920
ટી સામે એ કરો બદલે, હું છું
એક કાર્ય જગાડવો કમ્પોનન્ટ કહી રહ્યા,

17
00:00:47,920 --> 00:00:52,290
શબ્દમાળા માટે કરો, અને પસાર
દલીલો એ અને ટી તરીકે.

18
00:00:52,290 --> 00:00:56,480
અમે માટે કરો શબ્દમાળા પછી અલગ પાડવા પડશે
એ અને ટી ખરેખર સમાન છે જો આકૃતિ

19
00:00:56,480 --> 00:00:59,870
અને તેની સરખામણી બહાર આકૃતિ કેવી રીતે દો
પાત્ર માટે તેમને પાત્ર.

20
00:00:59,870 --> 00:01:02,410
>> હવે, દસ્તા અનુસાર
શબ્દમાળા કરો માટે, તે ખરેખર છે

21
00:01:02,410 --> 00:01:06,920
0 પાછા જઈ જો બે શબ્દમાળાઓ
એ અને ટી જ છે દ્વારા પર નિર્દેશ.

22
00:01:06,920 --> 00:01:09,490
તે નકારાત્મક નંબર પરત ચાલી રહ્યું છે
એસ ટી પહેલાં આવવું જોઈએ જો

23
00:01:09,490 --> 00:01:13,740
મૂળાક્ષરોની અથવા હકારાત્મક નંબર તો
એ મૂળાક્ષરોની ટી પાછળ આવવા જોઈએ.

24
00:01:13,740 --> 00:01:16,090
>> પરંતુ હવે માટે, અમે માત્ર કાળજી
સમાનતા વિશે.

25
00:01:16,090 --> 00:01:19,270
તેથી હું ફક્ત પરીક્ષણ જાઉં છું જો
શબ્દમાળા પરત કિંમત, કરો

26
00:01:19,270 --> 00:01:21,450
એ અને ટી માં પસાર, 0 સમકક્ષ હોય છે.

27
00:01:21,450 --> 00:01:24,940
અને તેથી જો, હું દાવો જાઉં છું કે
બે શબ્દમાળાઓ જ છે.

28
00:01:24,940 --> 00:01:26,820
>> પરંતુ હું એક બનાવવા જઈ રહ્યો છું
અન્ય ફેરફાર પણ.

29
00:01:26,820 --> 00:01:30,410
તે તેના પ્રતિ, કે ગેટ શબ્દમાળા તારણ
દસ્તાવેજીકરણ, ક્યારેક પાછા આવી શકો છો

30
00:01:30,410 --> 00:01:34,320
અનુસાર કે, નલ, એક સંત્રી કિંમત
શબ્દમાળાઓ દસ્તાવેજીકરણ, અર્થ વિચાર

31
00:01:34,320 --> 00:01:35,450
કંઇક ખરાબ થાય છે.

32
00:01:35,450 --> 00:01:38,830
ઉદાહરણ તરીકે, અમે મેમરી સમાપ્ત થઈ ગઈ છે અથવા
વપરાશકર્તા કોઈક સહકાર ન હતી.

33
00:01:38,830 --> 00:01:41,080
>> શબ્દમાળા દરમિયાન, કરો
થોડી નાજુક છે.

34
00:01:41,080 --> 00:01:44,730
તમે તેને નલ ક્યાં તેના માટે પાસ કરો તો
પ્રથમ કે તેની બીજી દલીલ, ખરાબ

35
00:01:44,730 --> 00:01:45,650
વસ્તુઓ થઇ શકે છે.

36
00:01:45,650 --> 00:01:47,970
સામાન્ય રીતે સમાવેશ ખરાબ વસ્તુઓ
સેગ્મેન્ટેશન ખામી.

37
00:01:47,970 --> 00:01:52,210
તેથી એકસાથે કે સંભવિત ટાળવા માટે,
હું આ ઉપયોગની લપેટી જાઉં છું

38
00:01:52,210 --> 00:01:56,350
આ સમગ્ર માંગયાદી દ્વારા કરો શબ્દમાળા
કોડ અને પ્રથમ જ કરવાની બ્લોક

39
00:01:56,350 --> 00:02:03,140
કે એ નલ સમાન ન હોય તો
અને ટી નલ સમાન નથી.

40
00:02:03,140 --> 00:02:08,280
>> બીજું કે જો હું રચવા કે રેપિંગ
સર્પાકાર કૌંસ સાથે અગાઉ લખ્યો

41
00:02:08,280 --> 00:02:12,270
સાથે સાથે, કે જેથી હું માત્ર સ્પર્શ આ સમય
એ અને ટી હું ચોક્કસ છું કે જો

42
00:02:12,270 --> 00:02:13,450
તેઓ નલ નથી.

43
00:02:13,450 --> 00:02:17,220
હવે, સેવ સંકલન કરીએ, અને
આ કાર્યક્રમ ફરી ચલાવો.

44
00:02:17,220 --> 00:02:22,240
>> 1 સરખામણી 1 કોઈ સ્લેશ કરો તેની ખાતરી કરો.

45
00:02:22,240 --> 00:02:23,950
હું ફરી હેલો કહો પડશે.

46
00:02:23,950 --> 00:02:25,890
હેલો હજુ સુધી ફરીથી દ્વારા અનુસરીને.

47
00:02:25,890 --> 00:02:28,110
અને આ જ સમયે, હું ખરેખર
આ જ વાત લખો.

48
00:02:28,110 --> 00:02:30,255