1
00:00:07,150 --> 00:00:08,850
[Powered by Google Translate] DAVID DICIURCIO: So ein wichtiges Konzept in erfassen

2
00:00:08,850 --> 00:00:11,010
Programmierung ist der Begriff der Umfang.

3
00:00:11,010 --> 00:00:13,860
Scope kann als Kontext, in dem eine Variable definiert werden

4
00:00:13,860 --> 00:00:15,610
sichtbar oder zugänglich.

5
00:00:15,610 --> 00:00:18,150
Zum Beispiel, sagen wir mal haben wir eine Funktion, Haupt-, das heißt

6
00:00:18,150 --> 00:00:22,570
soll eine Variable x, 1-2 inkrementieren.

7
00:00:22,570 --> 00:00:25,690
Wie wir sehen können, initialisiert wichtigsten x um eins, druckt

8
00:00:25,690 --> 00:00:28,740
aus einem Text, dann läuft die Funktion Inkrement, bevor

9
00:00:28,740 --> 00:00:30,540
Bedrucken mehr Text.

10
00:00:30,540 --> 00:00:32,545
Wenn diese Funktion wurden um korrekt zu funktionieren, wäre es

11
00:00:32,545 --> 00:00:34,120
auszudrucken x als 2.

12
00:00:34,120 --> 00:00:35,370
Lass es uns versuchen.

13
00:00:38,870 --> 00:00:43,075
>> Also, wie Sie sehen können, ist Haupt nicht, was wir zu erwarten.

14
00:00:43,075 --> 00:00:45,310
Es gibt den Wert 1, sondern

15
00:00:45,310 --> 00:00:47,150
als die 2 erwartet.

16
00:00:47,150 --> 00:00:50,060
Der Grund für diesen Fehler kann durch Umfang erklärt werden.

17
00:00:50,060 --> 00:00:52,185
In der Funktion main, initialisiert wir x

18
00:00:52,185 --> 00:00:53,820
nur innerhalb der Funktion.

19
00:00:53,820 --> 00:00:56,580
Mit anderen Worten wird die Variable x lokal innerhalb der angegebene

20
00:00:56,580 --> 00:00:58,640
Funktion main, und ist nicht zugänglich

21
00:00:58,640 --> 00:01:00,210
außerhalb der Funktion.

22
00:01:00,210 --> 00:01:03,580
Nur wichtigsten zugreifen kann x in dieser Situation.

23
00:01:03,580 --> 00:01:06,990
Wenn wir Inkrement nennen wir nicht passieren x als Eingang, aber

24
00:01:06,990 --> 00:01:08,960
nur eine Kopie von x.

25
00:01:08,960 --> 00:01:11,640
Als Ergebnis davon ist die Funktion fügt nur Inkrement

26
00:01:11,640 --> 00:01:14,190
der Wert 1 an eine Kopie des Werts von x.

27
00:01:14,190 --> 00:01:16,170
Aber nicht X selbst.

28
00:01:16,170 --> 00:01:19,090
Wenn wir zur Hauptseite zurückkehren, hat x selbst überhaupt nicht verändert.

29
00:01:19,090 --> 00:01:22,370
So Ausdruck x liefert nur den Wert 1.

30
00:01:22,370 --> 00:01:24,890
>> Na, dann, dass Bleibt die Frage: Wie sollen wir beheben

31
00:01:24,890 --> 00:01:26,230
diese Funktion?

32
00:01:26,230 --> 00:01:29,500
Eine Lösung wird mit Inkrement einen Wert zurückgeben.

33
00:01:29,500 --> 00:01:31,180
Auf diese Weise wird die Funktion Inkrement

34
00:01:31,180 --> 00:01:33,350
uns wieder eine ganze Zahl.

35
00:01:33,350 --> 00:01:35,420
Also hier ist unsere überarbeitete Code mit den

36
00:01:35,420 --> 00:01:37,480
alternative Inkrement-Funktion.

37
00:01:37,480 --> 00:01:41,510
Hier haben wir statt kehrte die x + 1, anstatt nur Ende

38
00:01:41,510 --> 00:01:44,070
wobei x gleich x + 1.

39
00:01:44,070 --> 00:01:46,290
Auch nehmen bemerken, dass wir die Ausgabe ersetzt

40
00:01:46,290 --> 00:01:49,630
Inkrement, zuvor nichtig, mit int, die besagt, dass

41
00:01:49,630 --> 00:01:52,230
Inkrement wird nun passieren wieder einen Integer-Wert.

42
00:01:52,230 --> 00:01:55,000
Jetzt, nach Inkrement läuft, wird es mit einem Wert von zurück

43
00:01:55,000 --> 00:01:56,535
2, genau so, wie wir wollten.

44
00:01:59,630 --> 00:02:02,260
>> Eine andere Situation, die Spielraum Bedeutung zeigt

45
00:02:02,260 --> 00:02:04,860
in scopeloop.c.

46
00:02:04,860 --> 00:02:07,320
In diesem Code haben wir eine for-Schleife, in der die Variable

47
00:02:07,320 --> 00:02:10,310
Insgesamt wird während jedes Schritts initialisiert.

48
00:02:10,310 --> 00:02:13,720
Leider funktioniert dieser Code nicht kompilieren.

49
00:02:13,720 --> 00:02:16,690
Dies ist, weil die Variable Gesamt tatsächlich nicht existiert

50
00:02:16,690 --> 00:02:18,550
außerhalb der for-Schleife.

51
00:02:18,550 --> 00:02:21,000
Variablen innerhalb von Schleifen erklärt existiert nur innerhalb der

52
00:02:21,000 --> 00:02:23,967
Schleife selbst und ist in unserer Fehler nachgewiesen

53
00:02:23,967 --> 00:02:25,880
Nachricht, insgesamt Schwarzarbeit.

54
00:02:25,880 --> 00:02:28,710
Die Variable insgesamt ist noch im Rahmen deklariert werden

55
00:02:28,710 --> 00:02:30,420
der Funktion main.

56
00:02:30,420 --> 00:02:33,610
Ferner ist bei jeder Iteration der for-Schleife, wir

57
00:02:33,610 --> 00:02:36,340
sind Reinitialisierung unserer gesamten auf 0 gesetzt.

58
00:02:36,340 --> 00:02:39,210
Dies allein nicht halten Sie den Code aus kompilieren, aber es

59
00:02:39,210 --> 00:02:42,920
würden insgesamt von immer Summierung auf einen Wert letzten 1 zu verhindern.

60
00:02:42,920 --> 00:02:45,760
>> Auch, was ist der beste Weg, um dieses Problem beheben?

61
00:02:45,760 --> 00:02:48,520
Einer der einfacheren Methoden gehört es, insgesamt lokal

62
00:02:48,520 --> 00:02:51,990
die Funktion, Haupt-und nicht an die Schleife sich.

63
00:02:51,990 --> 00:02:55,210
Dies wird insgesamt tatsächlich erhöhen und letztendlich

64
00:02:55,210 --> 00:02:57,880
damit sie nach der for-Schleife gedruckt werden.

65
00:02:57,880 --> 00:03:00,093
Eine andere Technik, die ich nur kurz zusammenfassen werde würde

66
00:03:00,093 --> 00:03:02,190
werden die Verwendung von globalen Variablen.

67
00:03:02,190 --> 00:03:04,890
Globale Variablen sind Variablen, die vor main deklariert werden

68
00:03:04,890 --> 00:03:07,860
das behalten ihren Wert während des gesamten Programms.

69
00:03:07,860 --> 00:03:10,710
Natürlich können die Funktionen ändern Sie den Wert eines globalen,

70
00:03:10,710 --> 00:03:13,470
aber sie gehen nicht out of scope wie lokale Variablen.

71
00:03:13,470 --> 00:03:15,880
Allerdings mit globalen Variablen tendenziell verpönt

72
00:03:15,880 --> 00:03:18,180
nach wie schlechtes Design, da gibt es bessere Möglichkeiten,

73
00:03:18,180 --> 00:03:20,080
Austausch von Daten zwischen den Funktionen.

74
00:03:20,080 --> 00:03:21,920
Zum Beispiel mit Zeigern.

75
00:03:21,920 --> 00:03:24,250
Aber mehr dazu ein andermal.

76
00:03:24,250 --> 00:03:26,670
>> Schließlich ist es wichtig, ein Verständnis von Umfang haben

77
00:03:26,670 --> 00:03:29,550
im Kontext der Speicher des Computers oder RAM.

78
00:03:29,550 --> 00:03:32,470
Wenn wir ein Programm auszuführen, lokale Variablen und Funktionen

79
00:03:32,470 --> 00:03:34,040
an einer bestimmten Stelle in das zugesetzte

80
00:03:34,040 --> 00:03:36,010
RAM genannt Stack.

81
00:03:36,010 --> 00:03:39,230
Als Funktionen geben, die Stack-Frames der Variablen

82
00:03:39,230 --> 00:03:43,910
effektiv aus dem Stapel somit mehr Speicher entfernt.

83
00:03:43,910 --> 00:03:46,750
So bei der Überprüfung Umfang, merken Sie sich diese drei

84
00:03:46,750 --> 00:03:47,980
Kernpunkte.

85
00:03:47,980 --> 00:03:51,220
Einer, der Umfang kann entweder lokal oder global.

86
00:03:51,220 --> 00:03:53,990
Es hängt von dem die Variable deklariert.

87
00:03:53,990 --> 00:03:57,040
Zwei Variablen deklariert oder in Funktionen initialisiert werden

88
00:03:57,040 --> 00:03:59,510
lokal für diese Funktion und kann nicht von anderen geändert werden

89
00:03:59,510 --> 00:04:02,790
Funktionen, zumindest nicht ohne Hilfe von Zeigern.

90
00:04:02,790 --> 00:04:05,340
Schließlich sind auch Variablen lokal zu Schleifen, die sich

91
00:04:05,340 --> 00:04:06,490
deklarierten.

92
00:04:06,490 --> 00:04:08,100
Die Variablen sind nicht zugänglich

93
00:04:08,100 --> 00:04:09,860
außerhalb der Schleife.

94
00:04:09,860 --> 00:04:11,170
>> Das ist alles für jetzt Anwendungsbereich.

95
00:04:11,170 --> 00:04:12,420
Danke fürs Zuschauen.