Массивы в C ++ - Объявить - Инициализировать - Указатель на примеры массивов

Содержание:

Anonim

Что такое массив?

Массив - это структура данных, в которой последовательно хранятся элементы одного и того же типа данных. Массив C ++ имеет фиксированный размер.

Вы можете рассматривать массив как набор переменных схожего типа данных. Вместо объявления каждой переменной и присвоения ей значения по отдельности вы можете объявить одну переменную (массив) и добавить к ней значения различных переменных. Каждое добавленное значение в массив идентифицируется индексом.

В этом руководстве по C ++ вы узнаете:

  • Что такое массив?
  • Зачем нужны массивы?
  • Объявить массив в C ++
  • Инициализация массива
  • Типы массивов
    • Одномерный массив
    • Многомерный массив
    • Двумерный массив
    • Трехмерный массив
    • Указатель на массив
  • Доступ к значениям массива
  • Преимущества массива в C ++
  • Недостатки массива в C ++

Зачем нужны массивы?

Массивы очень важны в любом языке программирования. Они обеспечивают более удобный способ хранения переменных или набора данных схожего типа вместе вместо того, чтобы хранить их по отдельности. Доступ к каждому значению массива будет осуществляться отдельно.

Объявить массив в C ++

Объявление массива в C ++ включает указание типа, а также количества элементов, которые будут храниться в массиве. Синтаксис:

type array-Name [ array-Size ];

Правила объявления одномерного массива в C ++.

  • Тип: тип - это тип элементов, которые должны храниться в массиве, и он должен быть допустимым типом данных C ++.
  • Имя- массива : Имя-массива - это имя, которое будет присвоено массиву.
  • Размер массива : Размер массива - это количество элементов, которые будут храниться в массиве. Это должно быть целое число больше 0.

Например, вы можете создать массив с именем age и сохранить возраст 5 студентов следующим образом:

int age[5];

В массиве age будет храниться 5 целых чисел, представляющих возраст разных учеников.

Инициализация массива

Инициализация массива - это процесс присвоения / сохранения элементов массиву. Инициализация может быть выполнена в виде одного оператора или одного за другим. Обратите внимание, что первый элемент в массиве хранится с индексом 0, а последний элемент хранится с индексом n-1, где n - общее количество элементов в массиве.

В случае массива age первый элемент будет сохранен с индексом 0, а последний элемент будет сохранен с индексом 4.

Давайте использовать массив age, чтобы продемонстрировать, как можно выполнить инициализацию массива:

int age[5] = {19, 18, 21, 20, 17};

Общее количество элементов в {} не может превышать значение, указанное в []. Элемент 19 находится в индексе 0, 18 в индексе 1, 21 в индексе 2, 20 в индексе 3 и 17 в индексе 4. Если вы не укажете количество элементов, которые будут сохранены в массиве в [], массив будет достаточно большим, чтобы удерживать элементы, добавленные в {}. Например:

int age[] = {19, 18, 21, 20, 17};

Приведенный выше оператор создаст точно такой же массив, что и предыдущий. Вы также можете назначить один элемент массиву, используя его индекс. Например:

age[3] = 20;

Вышеупомянутый оператор сохранит значение 20 в индексе 3 массива с именем age. Это означает, что 20 будет 4- м элементом массива.

Типы массивов

Есть два типа массивов C ++:

  • Одномерный массив
  • Многомерный массив
  • Указатель на массив

Одномерный массив

Это массив, в котором элементы данных расположены линейно только в одном измерении. Его обычно называют одномерным массивом. Синтаксис:

datatype array-name[size];
  • Имя-массива - это имя массива.
  • Размер - это количество элементов, которые будут храниться в массиве.

Например:

#include using namespace std;int main(){int age[5] = { 19, 18, 21, 20, 17 };for (int x = 0; x < 5; x++){cout <

Выход:




Вот скриншот кода:




Пояснение к коду:


    

  1. Включение файла заголовка iostream в наш код. Это позволит нам читать и писать на консоли.
    2. 

  2. Включение пространства имен std, чтобы использовать его классы и функции, не вызывая его.
    3. 

  3. Вызов функции main (), внутри которой нужно добавить логику программы.
    4. 

  4. Начало тела функции main ().
    5. 

  5. Объявление массива с именем age для хранения 5 целых чисел. Также инициализированы 5 целых чисел.
    6. 

  6. Создайте целочисленную переменную x с помощью цикла for.
    7. 

  7. Начало тела цикла for.
    8. 

  8. Использование переменной цикла x для перебора значений возраста массива и их печати на консоли. «\ N» - это символ новой строки, который печатается с новой строки после каждой итерации.
    9. 

  9. Конец тела петли.
    10. 

  10. Конец тела функции main ().
    11. 



Многомерный массив


Это массив, в котором элементы данных расположены в виде массива массивов. Многомерный массив может иметь любое количество измерений, но двумерные и трехмерные массивы являются общими. Синтаксис:





datatype array-name[d1][d2][d3]… [dn];


Имя-массива - это имя массива, который будет иметь n измерений. Например:


Двумерный массив


В двумерном массиве данные хранятся в виде списка с одномерным массивом. Это матрица со строками и столбцами. Чтобы объявить 2D-массив, используйте следующий синтаксис:


type array-Name [ x ][ y ];


Тип должен быть допустимым типом данных C ++. Рассматривайте 2D-массив как таблицу, где x обозначает количество строк, а y обозначает количество столбцов. Это означает, что вы идентифицируете каждый элемент в 2D-массиве, используя форму a [x] [y], где x - это номер строки, а y - количество столбцов, в которых принадлежит элемент.


Вот пример того, как инициализировать 2D-массив:


int a[2][3] = {{0, 2, 1} , /* row at index 0 */{4, 3, 7} , /* row at index 1 */};


В приведенном выше примере у нас есть 2D-массив, который можно рассматривать как матрицу 2x3. Есть 2 строки и 3 столбца. К элементу 0 можно получить доступ как [0] [1], потому что он расположен на пересечении строки с индексом 0 и столбца с индексом 1. Доступ к элементу 3 можно получить как [1] ​​[2], потому что он расположен в пересечение строки с индексом 1 и столбца с индексом 2.


Обратите внимание, что мы просто добавили фигурные скобки, чтобы различать разные строки элементов. Инициализацию также можно было выполнить следующим образом:





int a[2][3] = {0, 2, 1, 4, 3, 7};};


В следующем примере C ++ демонстрируется, как инициализировать и обходить 2D-массив:


#include using namespace std;int main(){// a 2x3 arrayint a[3][2] = { {0, 2}, {1, 4}, {3, 7} };// traverse array elementsfor (int i=0; i<3; i++)for (int j=0; j<2; j++){cout << "a[" <

Выход:




Вот снимок экрана с приведенным выше кодом:




Пояснение к коду:


    

  1. Включение файла заголовка iostream в наш код. Это позволит нам читать и писать на консоли.
    2. 

  2. Включение пространства имен std, чтобы использовать его классы и функции, не вызывая его.
    3. 

  3. Вызов функции main (), в которую нужно добавить код.
    4. 

  4. Начало тела функции main ().
    5. 

  5. Комментарий. Компилятор C ++ пропустит это.
    6. 

  6. Объявление 2D-массива из 3 строк и 2 столбцов. В массив также добавлены элементы.
    7. 

  7. Комментарий. Компилятор C ++ пропустит это.
    8. 

  8. Создание переменной i с помощью цикла for. Эта переменная будет перебирать индексы строк массива.
    9. 

  9. Создание переменной j с помощью цикла for. Эта переменная будет перебирать индексы столбцов массива.
    10. 

  10. Начало тела петель.
    11. 

  11. Выведите значения переменных i и j на консоль в квадратных скобках на консоли.
    12. 

  12. Распечатайте значение, хранящееся в индексе [i] [j] массива a.
    13. 

  13. Конец тела петель.
    14. 

  14. Функция main () должна возвращать целочисленное значение, если программа работает нормально.
    15. 

  15. Конец тела функции main ().
    16. 



Трехмерный массив


Трехмерный массив - это массив массивов. Каждый элемент в трехмерном массиве идентифицируется набором из 3 индексов. Для доступа к элементам трехмерного массива мы используем три цикла for. Например:


#includeusing namespace std;void main(){int a[2][3][2] = {{{4, 8},{2, 4},{1, 6}}, {{3, 6},{5, 4},{9, 3}}};cout << "a[0][1][0] = " << a[0][1][0] << "\n";cout << "a[0][1][1] = " << a[0][1][1] << "\n";}


Выход:




Вот скриншот кода:




Пояснение к коду:


    

  1. Включение файла заголовка iostream в наш код. Это позволит нам читать и писать на консоли.
    2. 

  2. Включение пространства имен std, чтобы использовать его классы и функции, не вызывая его.
    3. 

  3. Вызов функции main (), внутри которой нужно добавить логику программы.
    4. 

  4. Начало тела функции main ().
    5. 

  5. Объявление трехмерного массива с именем an размером 2x3x2. Значения массива также были инициализированы.
    6. 

  6. Доступ к элементу, хранящемуся в индексе [0] [1] [0] массива, и его печать на консоли.
    7. 

  7. Доступ к элементу, хранящемуся в индексе [0] [1] [1] массива, и его печать на консоли.
    8. 

  8. Конец тела функции main ().
    9. 



Указатель на массив


Указатель - это переменная, содержащая адрес. Помимо использования указателя для хранения адреса переменной, мы можем использовать его для хранения адреса ячейки массива. Имя массива постоянно указывает на его первый элемент. Обратите внимание на заявление, приведенное ниже:


int age[5];


Возраст - это указатель на $ age [0], адрес первого элемента массива с именем age. Рассмотрим следующий пример:


#include using namespace std;int main(){int *john;int age[5] = { 19, 18, 21, 20, 17 };john = age;cout << john << "\n";cout << *john;}


Выход:




Обратите внимание, что первое значение вышеприведенного вывода может возвращать другое значение в зависимости от адреса, назначенного первому элементу массива в памяти вашего компьютера.


Вот скриншот кода:




Пояснение к коду:


    

  1. Включение файла заголовка iostream в наш код. Это позволит нам читать и писать на консоли.
    2. 

  2. Включение пространства имен std, чтобы использовать его классы и функции, не вызывая его.
    3. 

  3. Вызов функции main (), внутри которой нужно добавить логику программы.
    4. 

  4. Начало тела функции main ().
    5. 

  5. Объявление переменной-указателя с именем * john.
    6. 

  6. Объявление целочисленного массива с именем age для хранения 5 целых чисел. Значения целых чисел также были инициализированы.
    7. 

  7. Присваивание переменной john значения адреса элемента, хранящегося в первом индексе массива age.
    8. 

  8. Печать значения переменной john, которая является адресом элемента, хранящегося в первом индексе массива age.
    9. 

  9. Печать первого значения, хранящегося в массиве age.
    10. 

  10. Конец тела функции main ().
    11. 



Имена массивов могут использоваться как указатели на константы, и наоборот. Это означает, что вы можете получить доступ к значению, хранящемуся в индексе 3 возраста массива, с помощью * (age + 3). Например:


#include using namespace std;int main() {// an array of 5 elements.int age[5] = { 19, 18, 21, 20, 17 };int *p;p = age;// output array valuescout << "Using pointer: " << endl;for (int x=0; x<5; x++) {cout << "*(p + " << x << ") : ";cout << *(p + x) << endl;}cout << "Using age as address: " << endl;for (int x = 0; x < 5; x++) {cout << "*(age + " << x << ") : ";cout << *(age + x) << endl;}return 0;}


Выход:




Вот скриншот кода:




Пояснение к коду:


    

  1. Включение файла заголовка iostream в наш код. Это позволит нам читать и писать на консоли.
    2. 

  2. Включение пространства имен std, чтобы использовать его классы и функции, не вызывая его.
    3. 

  3. Вызов функции main () и начало тела функции main ().
    4. 

  4. Комментарий. Компилятор C ++ пропустит это.
    5. 

  5. Объявление массива с именем age для хранения 5 целых чисел.
    6. 

  6. Создание целочисленного указателя стр.
    7. 

  7. Присваиваем p значение адреса первого элемента массива age.
    8. 

  8. Комментарий. Компилятор C ++ пропустит это.
    9. 

  9. Распечатайте текст на консоли.
    10. 

  10. Создайте целое число x с помощью цикла for. {Отмечает начало тела цикла for.
    11. 

  11. Распечатайте значения x в сочетании с другим текстом на консоли.
    12. 

  12. Распечатайте значения * (p + x) на консоли.
    13. 

  13. Конец тела петли.
    14. 

  14. Распечатайте текст на консоли.
    15. 

  15. Создайте переменную x с помощью цикла for. {Отмечает начало тела цикла for.
    16. 

  16. Распечатайте значения x от 0 до 4 вместе с другим текстом.
    17. 

  17. Распечатайте значения * (возраст + x).
    18. 

  18. Конец тела цикла for.
    19. 

  19. Возвращаемое значение, если программа работает успешно.
    20. 

  20. Конец тела функции main ().
    21. 




Доступ к значениям массива


Доступ к элементам массива осуществляется с помощью их соответствующих индексов. Индекс элемента, к которому нужно получить доступ, добавляется в квадратных скобках [] сразу после имени массива. Например:


int john = age[2];


В приведенном выше примере мы просто указываем, что возраст Джона хранится в индексе 2 массива с именем age. Это означает, что возраст Джона является 3- м значением в массиве age. Вот полный пример C ++, который показывает, как получить доступ и распечатать это значение:


#includeusing namespace std;int main(){int age[5] = { 19, 18, 21, 20, 17 };int john = age[2];cout << "The age of John is:"<

Выход:




Вот скриншот кода:




Пояснение к коду:


    

  1. Включение файла заголовка iostream в наш код. Это позволит нам читать и писать на консоли.
    2. 

  2. Включение пространства имен std, чтобы использовать его классы и функции, не вызывая его.
    3. 

  3. Вызов функции main (), в которую нужно добавить код.
    4. 

  4. Запуск тела функции main ().
    5. 

  5. Объявление массива с именем age для хранения 5 целочисленных элементов.
    6. 

  6. Доступ к значению, хранящемуся в индексе 2 возраста массива, и сохранение его значения в переменной с именем john.
    7. 

  7. Печать значения переменной john на консоли рядом с другим текстом.
    8. 




Преимущества массива в C ++


Вот плюсы / преимущества использования Array в C ++:


    

  • Элементы массива можно легко перемещать.
    • 

  • Легко манипулировать данными массива.
    • 

  • Доступ к элементам массива может быть произвольным.
    • 

  • Массивы облегчают оптимизацию кода; следовательно, мы можем выполнять большую работу, используя меньше кода.
    • 

  • Легко сортировать данные массива.
    • 




Недостатки массива в C ++


    

  • Массив имеет фиксированный размер; следовательно, мы не можем добавлять к нему новые элементы после инициализации.
    • 

  • Выделение большего количества памяти, чем требуется, приводит к нерациональному использованию пространства памяти, а меньшее выделение памяти может создать проблему.
    • 

  • Количество элементов, которые будут храниться в массиве, должно быть известно заранее.
    • 



Резюме


    

  • Массив - это структура данных, в которой хранятся элементы одного типа данных.
    • 

  • Элементы массива хранятся последовательно.
    • 

  • Элементы массива обозначаются соответствующими индексами. Первый элемент имеет индекс 0, а последний элемент - индекс n-1, где - общее количество элементов массива.
    • 

  • Объявление массива включает определение типов данных элементов массива, а также количества элементов, которые будут храниться в массиве.
    • 

  • В одномерном массиве элементы хранятся последовательно.
    • 

  • Двумерный массив хранит элементы в строках и столбцах.
    • 

  • Трехмерный массив - это массив массивов.
    • 

  • Элементы могут быть добавлены в массив, используя их индексы.
    • 

  • Доступ к элементам массива осуществляется с помощью их индексов.
    • 

  • Многомерный массив имеет более одного измерения.
    • 

  • Имя массива указывает на его первый элемент.
    • 

  • Массивы имеют фиксированный размер, что означает, что новые элементы не могут быть добавлены в массив после его инициализации.
    •