[Powered by Google Translate] Давайте поговорим о массивах.
Так почему же мы все хотим использовать массивы?
Ну, скажем, у вас есть программа, которую необходимо хранить 5 идентификаторов студентов.
Казалось бы разумно иметь 5 отдельных переменных.
По причинам, которые мы увидим в немного, мы начнем отсчет с 0.
Переменных мы будем иметь будет id0 Int, Int id1, и так далее.
Любая логика, которую мы хотим выполнить на студенческий билет нужно будет скопировать и вставить
Для каждого из этих студентов идентификаторов.
Если мы хотим, чтобы проверить, какие студенты оказались в CS50,
мы сначала нужно проверить, если id0 представляет студентом на курсе.
Затем сделать то же самое на следующий студент, нам нужно скопировать и вставить код для id0
и заменить все вхождения id0 с id1 и так далее для id2, 3, и 4.
>> Как только вы услышите, что нам нужно скопировать и вставить,
Вы должны начать думать, что есть лучшее решение.
А что, если вы понимаете, что вы не нуждаетесь в 5 идентификаторы студентов, а 7?
Вам нужно вернуться в исходный код и добавить в ID5, ID6,
и скопировать и вставить логику для проверки, если идентификаторы относятся к классу для этих 2 новых идентификаторов.
Существует ничего подключения всех этих идентификаторов вместе, и поэтому нет способа просить
Программа сделать это для идентификаторов 0 до 6.
Ну теперь вы понимаете, у вас есть 100 идентификаторов студентов.
Это начинает казаться меньше, чем идеально нужно отдельно объявить каждую из этих идентификаторов,
и скопировать и вставить любой логики для этих новых идентификаторов.
Но, возможно, мы полны решимости, и мы делаем это для всех 100 студентов.
Но что, если вы не знаете, сколько студентов есть на самом деле?
Есть только некоторые российских студентов и ваша программа должна спросить пользователя, что это п.
Ой-ой. Это не будет работать очень хорошо.
Ваша программа работает только для некоторых постоянных числа студентов.
>> Решение всех этих проблем есть красота массивов.
Так что же такое массив?
В некоторых языках программирования типа массива могли бы сделать немного больше,
но здесь мы сосредоточимся на основной структуры массива данных так же, как вы увидите его в C.
Массив это просто большой блок памяти. Вот и все.
Когда мы говорим, у нас есть массив из 10 целых чисел, что просто означает, что у нас есть блок
памяти, достаточно большой, чтобы провести 10 отдельных чисел.
Предполагая, что целое 4 байта, это означает, что массив из 10 целых чисел
непрерывный блок из 40 байт в памяти.
Даже если вы используете многомерные массивы, которые мы не будем вдаваться в сюда,
это еще только большой блок памяти.
Многомерных обозначений просто для удобства.
Если у вас есть 3 на 3 многомерный массив целых чисел,
Затем ваша программа будет действительно только рассматривать это как большой блок из 36 байт.
Общее количество целых чисел в 3 раза 3, и каждое целое число занимает 4 байта.
>> Давайте взглянем на простой пример.
Мы видим здесь 2 различных способов объявления массивов.
Мы должны будем комментировать 1 из них за программа для компиляции
так как мы заявляем х в два раза.
Мы взглянем на некоторые различия между этими 2 типами заявлений в немного.
Обе эти линии объявить массив размера N,
где мы определим N # как 10.
Мы могли бы так же легко, попросил у пользователя натуральное
и использовал его как целое число элементов в массиве.
Нравится наш студенческий билет, например, перед, это вроде как объявить 10 полностью отдельный
мнимых переменных x0, x1, x2, и так далее до Xn-1.
Не обращая внимания на линиях, где мы объявляем массив, обратите внимание на квадратные скобки нетронутыми
внутри циклов.
Когда мы пишем что-то вроде X [3], который я только что прочитал, как х кронштейн 3,
Вы можете думать о нем, как просить мнимой x3.
Обратите внимание, чем массив размера N, это значит, что номер внутри скобок
который мы будем называть индексом, может быть что угодно от 0 до N-1,
которая является общей индексов N.
>> Думать о том, как это на самом деле работает
помните, что массив представляет собой большой блок памяти.
Предполагая, что целое 4 байта, весь массив х 40 байт блока памяти.
Так x0 относится к самым первым 4 байта блока.
X [1] ссылается на следующие 4 байта и так далее.
Это означает, что в начале х все программы никогда не должны отслеживать.
Если вы хотите использовать х [400], то программа знает, что это эквивалентно
только 1600 байт после начала х.
Откуда мы получаем 1600 байт из? Это всего лишь в 400 раз 4 байта на целое число.
>> Прежде чем двигаться дальше, это очень важно понимать, что в C
нет органов индекс, который мы используем в массиве.
Наш большой блок находится всего в 10 целых долго, но ничего не будет кричать на нас, если мы пишем х [20]
или даже х [-5].
Индекс не должны даже быть рядом.
Это может быть любое произвольное выражение.
В программе мы используем переменную я из цикла в качестве индекса в массиве.
Это очень распространенная картина, цикл от I = 0 до длины массива,
а затем с помощью я как индекс для массива.
Таким образом, вы эффективно цикл по всему массиву,
и вы можете присвоить каждому место в массиве, или использовать его для некоторых расчетов.
>> В первый цикл, я начинается с 0,
и так будет назначить на 0 месте в массиве, значение 0 раз 2.
Тогда я шагом, и мы присвоить первое место в массиве значение 1 раз 2.
Тогда я вновь увеличивается на единицу и так далее, пока мы не назначить в положение N-1 в массиве
Значение N-1 раз 2.
Таким образом, мы создали массив с первых 10 четных чисел.
Может быть, выравнивает было бы немного лучше, имя переменной, чем х,
но это дало бы вещи.
Второй цикл, то просто печатает значения, что мы уже хранится внутри массива.
>> Давайте попробуем запустить программу с обоими типами массива деклараций
и посмотрите на результат работы программы.
Насколько мы можем видеть, программа ведет себя так же для обоих типов деклараций.
Давайте же взглянем на то, что произойдет, если мы изменим первую петлю, чтобы не останавливаться на N
а сказать 10.000.
Пути за пределы массива.
Ой. Может быть, вы видели это раньше.
Ошибки сегментации означает, что ваши программы произошел сбой.
Вы начинаете видеть это, когда вы касаетесь области памяти, вы не должны касаться.
Здесь соприкасаются 10000 мест за начало х,
которая, очевидно, является местом в памяти, мы не должны соприкасаться.
Поэтому большинство из нас, вероятно, не случайно поставил 10000 вместо N,
Но что, если мы делаем что-то более тонкое, как говорят записи меньше или равно N
в цикле условие, а не меньше, чем N.
Помните, что массив имеет только индексами от 0 до N-1,
Это означает, что индекс N находится за пределами конца массива.
Программа не может привести к сбою в данном случае, но это все равно ошибка.
На самом деле, эта ошибка является настолько распространенным, что оно имеет свое собственное имя,
выключения на 1 ошибка.
>> Вот именно для основы.
Итак, какие же основные различия между 2 типами массива деклараций?
Одно из отличий является, где большой блок памяти идет.
В первую декларацию, в которой я буду называть брекет-тип массива,
хотя это отнюдь не условное наименование,
он будет идти в стеке.
В то время как во втором, который я буду называть указатель типа массива, он будет идти в кучу.
Это означает, что когда функция возвращает, кронштейн массив будет автоматически освобождается,
в то время как вы должны explicitily позвонить бесплатно на массив указателей
или же у вас есть утечка памяти.
Кроме того, кронштейн массива фактически не является переменной.
Это очень важно. Это просто символ.
Вы можете думать об этом как константа, компилятор выбирает для вас.
Это означает, что мы не можем сделать что-то вроде х + + с кронштейном типа,
хотя это вполне допустимо с указателем.
>> Указатель типа переменной.
Для указателей типа, у нас есть 2 отдельных блоков памяти.
Переменная х сам хранятся в стеке и только один указатель,
но большой блок памяти хранятся в куче.
Переменная х в стек только хранит адрес
большой блок памяти в куче.
Одним из следствий этого является с размером оператора.
Если вы попросите размер кронштейна массив, это даст вам размер большой блок памяти,
что-то вроде 40 байт,
Но если вы попросите размер указателя типа массива,
это даст вам размер переменной х себя, что на прибор, скорее всего, только 4 байт.
Использование указателей типа массива, нельзя напрямую обратиться за
Размер большой блок памяти.
Это обычно не много ограничений, так как мы очень редко хотят размера
большой блок памяти, и мы, как правило, вычислить его, если нам это нужно.
>> Наконец, кронштейн массива происходит, чтобы предоставить нам ярлык для инициализации массива.
Давайте посмотрим, как мы могли бы написать первые 10 четных чисел с помощью контекстного initilization.
С массива указателей, не существует способа сделать ярлык, как это.
Это всего лишь введение к тому, что вы можете сделать с массивами.
Они появляются почти в каждой программе вы пишете.
Надеюсь, теперь вы можете видеть лучший способ это сделать на примере студентов идентификаторы
С начала видео.
>> Меня зовут Боб Боуден, и это CS50.