1
00:00:00,000 --> 00:00:03,250
>> COLUMNA 1: Imos agora escribir un programa
realmente se compara dúas cadeas

2
00:00:03,250 --> 00:00:04,245
personaxe para personaxe.

3
00:00:04,245 --> 00:00:06,830
Imos usar como comparar 0
noso punto de partida.

4
00:00:06,830 --> 00:00:11,550
Pero primeiro imos pelar a capa que
é o tipo cadea e reescribir-lo

5
00:00:11,550 --> 00:00:14,120
para o que realmente é, o que
é unha estrela de char.

6
00:00:14,120 --> 00:00:17,740
Ese é o enderezo dun personaxe,
En concreto, o primeiro carácter nunha

7
00:00:17,740 --> 00:00:21,010
secuencia de carácteres que tiñamos máis
xeralmente saben como unha cadea.

8
00:00:21,010 --> 00:00:21,880
>> Mesmo para t.

9
00:00:21,880 --> 00:00:25,660
Imos ter que volver escribir esa declaración cadea
como char estrela.

10
00:00:25,660 --> 00:00:28,690
E agora necesitamos non máis
comparar s contra t, para que non

11
00:00:28,690 --> 00:00:30,150
compararmos dous enderezos.

12
00:00:30,150 --> 00:00:33,180
Queremos realmente comparar o
dúas propias cordas.

13
00:00:33,180 --> 00:00:37,520
Para iso, podemos utilizar unha función
declarou en string.h.

14
00:00:37,520 --> 00:00:40,920
Entón, eu vou engadir que inclúen
encima do meu ficheiro.

15
00:00:40,920 --> 00:00:43,130
>> E entón eu vou cambiar
esta liña aquí.

16
00:00:43,130 --> 00:00:47,920
No canto de comparar s contra t, eu son
vai chamar unha miniatura función trasfega,

17
00:00:47,920 --> 00:00:52,290
para cadea de comparación, e pasar
como argumentos s e t.

18
00:00:52,290 --> 00:00:56,480
Imos retrasar para despois comparar con corda
descubrir se s e t son realmente iguais

19
00:00:56,480 --> 00:00:59,870
e deixar descubrir como comparar
eles personaxe para personaxe.

20
00:00:59,870 --> 00:01:02,410
>> Agora, segundo a documentación
para cadea de comparación, é realmente

21
00:01:02,410 --> 00:01:06,920
Vai voltar 0 as dúas cadeas
apuntada por s e t son o mesmo.

22
00:01:06,920 --> 00:01:09,490
Vai voltar un número negativo
se s debe vir antes de t

23
00:01:09,490 --> 00:01:13,740
alfabeticamente ou un número positivo
s debe vir despois de t en orde alfabética.

24
00:01:13,740 --> 00:01:16,090
>> Pero, polo de agora, só lle importa
sobre a igualdade.

25
00:01:16,090 --> 00:01:19,270
Entón, eu vou simplemente examinar se o
valor de retorno de cadea de comparación,

26
00:01:19,270 --> 00:01:21,450
pasando en s e t, é igual a 0.

27
00:01:21,450 --> 00:01:24,940
E se é así, eu vou afirmar que
as dúas secuencias son iguais.

28
00:01:24,940 --> 00:01:26,820
>> Pero eu vou facer un
outro cambio ben.

29
00:01:26,820 --> 00:01:30,410
Acontece que corda get, pola súa
documentación, ás veces pode voltar

30
00:01:30,410 --> 00:01:34,320
nulo, un valor de sentinela que, segundo
para obter documentación cordas, medio

31
00:01:34,320 --> 00:01:35,450
algo de malo aconteceu.

32
00:01:35,450 --> 00:01:38,830
Por exemplo, estivemos sen memoria ou
o usuario de algunha maneira non cooperar.

33
00:01:38,830 --> 00:01:41,080
>> Cadea de comparación, con todo,
é un pouco fráxil.

34
00:01:41,080 --> 00:01:44,730
Se pasar null para tanto o seu
primeiro ou o segundo argumento, mal

35
00:01:44,730 --> 00:01:45,650
cousas poden ocorrer.

36
00:01:45,650 --> 00:01:47,970
Cousas malas xeralmente inclúen
fallos de segmentación.

37
00:01:47,970 --> 00:01:52,210
Entón, para evitar este potencial por completo,
Vou primeiro para romper ese uso

38
00:01:52,210 --> 00:01:56,350
Cadea de comparación polo recúo toda esta
bloque de código e primeiro só facendo

39
00:01:56,350 --> 00:02:03,140
que, se s non é igual a cero
e t non é igual a cero.

40
00:02:03,140 --> 00:02:08,280
>> Envolvendo que construír máis que eu
ingresaran anteriormente con claves como

41
00:02:08,280 --> 00:02:12,270
ben, para que esta vez eu só tocar
s e t se eu estou seguro de que

42
00:02:12,270 --> 00:02:13,450
eles non son nulos.

43
00:02:13,450 --> 00:02:17,220
Imos agora gardar, compilar e
re-executar este programa.

44
00:02:17,220 --> 00:02:22,240
>> Fai comparar 1 punto barra comparar 1.

45
00:02:22,240 --> 00:02:23,950
Eu vou dicir Hola de novo.

46
00:02:23,950 --> 00:02:25,890
Seguido por Ola unha vez máis.

47
00:02:25,890 --> 00:02:28,110
E esta vez, realmente
escribir o mesmo.

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