Массивы в С++

Массив это структура данных, представленная в виде группы ячеек одного типа, объединенных под одним единым именем. Массивы используются для обработки большого количества однотипных данных. Имя массива является указателем,   что такое указатели расскажу немного позже. Отдельная ячейка данных массива называется элементом массива.  Элементами массива могут быть  данные любого типа. Массивы могут иметь как одно, так и более одного измерений. В зависимости от количества измерений массивы делятся на одномерные массивы, двумерные массивы, трёхмерные массивы и так далее до n-мерного массива. Чаще всего в программировании используются одномерные и двумерные массивы, поэтому мы рассмотрим только эти  массивы.

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

Одномерный массив — массив, с одним параметром, характеризующим количество элементов одномерного массива. Фактически одномерный массив — это массив, у которого может быть только одна строка, и n-е количество столбцов. Столбцы в одномерном массиве — это элементы массива. На рисунке 1 показана структура целочисленного одномерного массива a. Размер этого массива — 16 ячеек.

массивы С++

Рисунок 1 — Массивы в С++

Заметьте, что максимальный индекс одномерного массива a равен 15, но размер массива 16 ячеек, потому что нумерация ячеек массива всегда начинается с 0. Индекс ячейки – это целое неотрицательное число, по которому можно обращаться к каждой ячейке массива и выполнять какие-либо действия над ней (ячейкой).

//синтаксис  объявления одномерного массива в С++:
/*тип данных*/  /*имя одномерного массива*/[/*размерность одномерного массива*/];
//пример объявления одномерного массива, изображенного на рисунке 1:
int a[16];

где, int  целочисленный тип данных;

        а —  имя одномерного массива;
16 — размер одномерного массива, 16 ячеек.

Всегда сразу после имени массива идут квадратные скобочки, в которых задаётся размер одномерного массива, этим массив и отличается от всех остальных переменных.

//ещё один способ объявления одномерных массивов
int mas[10], a[16];

Объявлены два одномерных массива  mas и а размерами 10 и 16 соответственно. Причём в таком способе объявления все массивы будут иметь одинаковый тип данных, в нашем случае — int.

// массивы могут быть инициализированы при объявлении:
int a[16] = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // инициализация одномерного массива

Инициализация одномерного массива выполняется в фигурных скобках после знака равно, каждый элемент массива отделяется от предыдущего запятой.

int a[]={5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15}; // инициализации массива без определения его размера.

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

// array.cpp: определяет точку входа для консольного приложения.

#include "stdafx.h"
#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
    cout << "obrabotka massiva" << endl;
    int array1[16] = { 5, -12, -12, 9, 10, 0, -9,
                    -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива
    cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков
    for (int counter = 0; counter < 16; counter++)  //начало цикла
    {
    //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число
     cout << "array1[" << counter << "]" << "\t\t" << array1[counter] << endl;
    }
    system("pause");
    return 0;
}

// код Code::Blocks

// код Dev-C++

// array.cpp: определяет точку входа для консольного приложения.

#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
    cout << "obrabotka massiva" << endl;
    int array1[16] = { 5, -12, -12, 9, 10, 0, -9,
                    -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива
    cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков
    for (int counter = 0; counter < 16; counter++)  //начало цикла
    {
    //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число
     cout << "array1[" << counter << "]" << "\t\t" << array1[counter] << endl;
    }
    return 0;
}

В строках 10 — 11 объявлен и проинициализирован целочисленный одномерный массив с именем array1, размер которого равен 16 ячейкам, то есть такой массив может хранить 16 чисел. Любая обработка массива осуществима только совместно с циклами. Какой цикл выбрать для обработки массива — это вам решать. Но лучше всего для этой задачи подходит цикл for. Переменную-счётчик counter будем использовать для обращения к элементам одномерного массива array1. В условии продолжения цикла for стоит строгий знак неравенства, так как шестнадцатого индекса в одномерном массиве array1  нет. А так как нумерация ячеек начинается с нуля, то элементов в массиве 16. В теле цикла for оператор  cout печатает элементы одномерного массива (см. Рисунок 2).

CppStudio.com
obrabotka massiva
indeks          element massiva
array1[0]               5
array1[1]               -12
array1[2]               -12
array1[3]               9
array1[4]               10
array1[5]               0
array1[6]               -9
array1[7]               -12
array1[8]               -1
array1[9]               23
array1[10]              65
array1[11]              64
array1[12]              11
array1[13]              43
array1[14]              39
array1[15]              -15
Для продолжения нажмите любую клавишу . . .

Рисунок 2 — Массивы в С++

Разработаем ещё одну программу на обработку одномерного массива в С++. Программа должна последовательно считывать десять введённых чисел с клавиатуры. Все введённые числа  просуммировать, результат вывести на экран.

// array_sum.cpp: определяет точку входа для консольного приложения.

#include "stdafx.h"
#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
    int array1[10]; // объявляем целочисленный массив 
    cout << "Enter elementi massiva: " << endl;
    int sum = 0;
    for ( int counter = 0; counter < 10; counter++ ) // цикл для считывания чисел
        cin >> array1[counter];  // считываем вводимые с клавиатуры числа
    cout << "array1 = {";
    for ( int counter = 0; counter < 10; counter++ ) // цикл для вывода элементов массива
        cout << array1[counter] << " ";  // выводим элементы массива на стандартное устройство вывода
    for ( int counter = 0; counter < 10; counter++ ) // цикл для суммирования чисел массива
        sum += array1[counter]; // суммируем элементы массива
    cout << "}\nsum = " << sum << endl;
    system("pause");
    return 0;
}

// код Code::Blocks

// код Dev-C++

// array_sum.cpp: определяет точку входа для консольного приложения.

#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
    int array1[10]; // объявляем целочисленный массив
    cout << "Enter elementi massiva: " << endl;
    int sum = 0;
    for ( int counter = 0; counter < 10; counter++ ) // цикл для считывания чисел
        cin >> array1[counter];  // считываем вводимые с клавиатуры числа
    cout << "array1 = {";
    for ( int counter = 0; counter < 10; counter++ ) // цикл для вывода элементов массива
        cout << array1[counter] << " ";  // выводим элементы массива на стандартное устройство вывода
    for ( int counter = 0; counter < 10; counter++ ) // цикл для суммирования чисел массива
        sum += array1[counter]; // суммируем элементы массива
    cout << "}\nsum = " << sum << endl;
    return 0;
}


Перед тем как выполнять обработку массива его необходимо объявить, причём размер одномерного массива равен 10, так как это оговорено условием задачи. В переменной sum будем накапливать сумму элементов одномерного массива. Первый цикл for заполняет объявленный одномерный массив, введёнными с клавиатуры числами, строки 12 — 13. Переменная счётчик counter используется для последовательного доступа к элементам одномерного массива array1, начиная с индекса 0 и до 9-го включительно. Второй цикл for выводит на экран элементы массива, строки 15 — 16. Третий цикл for последовательно считывает элементы одномерного массива и суммирует их, сумма накапливается в переменной sum, строки 17 — 18. Результат работы программы смотреть на рисунке 3.

CppStudio.com
Enter elementi massiva:
0
1
2
3
4
5
6
7
8
9
array1 = {0 1 2 3 4 5 6 7 8 9 }
sum = 45
Для продолжения нажмите любую клавишу . . .

Рисунок 3 — Массивы в С++

Сначала последовательно были введены все 10 чисел, после чего отобразился одномерный массив, и напечаталась сумма чисел массива.

Двумерные массивы в С++

До этого момента мы рассматривали одномерные массивы, которыми не всегда можно ограничиться. Допустим, необходимо обработать некоторые данные из таблицы. В таблице есть две характеристики: количество строк и количество столбцов. Также и в двумерном массиве, кроме количества элементов массива, есть такие характеристики как, количество строк и количество столбцов двумерного массива. То есть, визуально, двумерный массив — это обычная таблица, со строками и столбцами. Фактически двумерный массив — это одномерный массив одномерных массивов. Структура двумерного массива, с именем a, размером m на n показана ниже (см. Рисунок 4).

двумерный массив С++

Рисунок 4 — Массивы в С++

где, m — количество строк двумерного массива;
n — количество столбцов двумерного массива;
m * n — количество элементов массива.

// синтаксис объявления двумерного массива
/*тип данных*/ /*имя массива*/[/*количество строк*/][/*количество столбцов*/];

В объявлении  двумерного массива, также как и в объявлении одномерного массива, первым делом, нужно указать:

  • тип данных;
  • имя массива.

После чего, в первых квадратных скобочках указывается количество строк двумерного массива, во вторых квадратных скобочках — количество столбцов двумерного массива. Двумерный массив визуально отличается от одномерного второй парой квадратных скобочек. Рассмотрим пример объявления двумерного массива. Допустим нам необходимо объявить двумерный массив, с количеством элементов, равным 15. В таком случае двумерный массив может иметь три строки и пять столбцов или пять строк и три столбца.

// пример объявление двумерного массива:
int a[5][3];
  • a — имя целочисленного массива
  • число в первых квадратных скобках указывает количество строк двумерного массива, в данном случае их 5;
  • число во вторых квадратных скобках указывает количество столбцов двумерного массива, в данном случае их 3.
// инициализация двумерного массива:
int a[5][3] = { {4, 7, 8}, {9, 66, -1}, {5, -5, 0}, {3, -3, 30}, {1, 1, 1} };

В данном массиве 5 строк, 3 столбца. после знака присвоить ставятся общие фигурные скобочки, внутри которых ставится столько пар фигурных скобочек, сколько должно быть строк в двумерном массиве, причём эти скобочки разделяются запятыми. В каждой паре фигурных скобочек записывать через запятую элементы двумерного массива. Во всех фигурных скобочках количество элементов должно совпадать. Так как в массиве пять строк, то и внутренних пар скобочек тоже пять. Во внутренних скобочках записаны по три элемента, так как количество столбцов — три. Графически наш массив будет выглядеть, как двумерная таблица (см. Рисунок 5).

двумерный массив С++

Рисунок 5 — Массивы в С++

В каждой ячейке двумерного массива показано значение, в нижнем правом углу показан адрес данной ячейки. Адресом ячейки двумерного массива является имя  массива, номер строки и номер столбца.

Разработаем несложную программу, на обработку двумерного массива, которая называется «Лабиринт». Лабиринт должен быть построен на основе двумерного массива. Размер лабиринта выберем на свое усмотрение.

// array2.cpp: определяет точку входа для консольного приложения.

#include "stdafx.h"
#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
// 1-условно "стенки лабиринта"
// 2-"правильный путь, выход из лабиринта"
// 0-"ложный путь"
    int mas[33][20] = { {1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,}, // инициализация двумерного массива
                        {1,2,1,0,0,1,0,1,2,2,2,1,1,1,1,0,0,0,0,1,},
                        {1,2,1,1,0,1,0,1,2,1,2,2,2,2,1,0,1,1,0,1,},
                        {1,2,2,2,2,2,2,1,2,1,1,1,1,2,1,0,0,1,0,1,},
                        {1,1,1,1,1,1,2,1,2,1,0,0,1,2,1,1,0,1,0,1,},
                        {1,0,0,1,0,0,2,2,2,1,1,0,0,2,0,0,0,1,0,1,},
                        {1,0,1,1,0,1,1,1,1,1,0,0,1,2,1,1,1,1,0,1,},
                        {1,0,0,0,0,0,0,0,0,1,1,1,1,2,1,0,0,0,0,1,},
                        {1,1,1,1,1,1,0,1,1,1,2,2,2,2,1,0,1,1,1,1,},
                        {1,1,0,0,0,1,0,0,1,1,2,1,1,1,1,0,0,0,0,1,},
                        {1,0,0,1,0,0,0,0,0,1,2,2,2,2,1,1,1,1,0,1,},
                        {1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,0,0,0,0,1,},
                        {1,2,2,2,2,2,2,2,2,2,2,2,2,2,1,0,1,1,1,1,},
                        {1,2,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,},
                        {1,2,1,0,0,0,1,2,2,2,1,0,0,0,0,0,1,1,0,1,},
                        {1,2,1,1,1,1,1,2,1,2,1,1,1,0,1,0,0,0,0,1,},
                        {1,2,1,2,2,2,1,2,1,2,2,2,1,1,1,1,1,1,1,1,},
                        {1,2,1,2,1,2,1,2,1,0,1,2,2,2,2,2,2,2,2,1,},
                        {1,2,1,2,1,2,1,2,1,0,1,1,1,1,1,1,1,1,2,1,},
                        {1,2,1,2,1,2,1,2,1,0,0,0,0,0,0,0,0,0,2,1,},
                        {1,2,1,2,1,2,2,2,1,0,1,1,1,1,1,1,0,1,2,1,},
                        {1,2,1,2,1,1,1,1,1,0,0,0,1,0,1,0,0,1,2,1,},
                        {1,2,1,2,2,1,0,0,1,1,1,0,0,0,1,0,1,1,2,1,},
                        {1,2,1,1,2,1,1,0,0,0,0,0,1,0,1,0,0,1,2,1,},
                        {1,2,1,1,2,1,0,0,1,1,1,1,1,1,1,1,1,1,2,1,},
                        {1,2,1,1,2,1,1,0,1,2,2,2,2,2,2,2,2,2,2,1,},
                        {1,2,1,1,2,1,0,0,1,2,1,1,1,1,1,1,1,1,1,1,},
                        {1,2,1,1,2,1,0,1,1,2,1,1,1,1,1,1,1,1,2,2,},
                        {1,2,1,1,2,1,0,0,1,2,1,1,2,2,2,2,2,2,2,1,},
                        {1,2,1,1,2,1,0,1,1,2,1,1,2,1,1,1,1,1,1,1,},
                        {1,2,1,1,2,1,0,0,1,2,1,1,2,1,0,0,0,1,0,1,},
                        {1,2,2,2,2,1,0,1,1,2,2,2,2,0,0,1,0,0,0,1,},
                        {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,} };
// два цикла - внутренний и внешний, осуществляющие обращение к каждому элементу массива
    for (int i = 0; i < 33; i++) //переключение по строкам
    {
        for (int j = 0; j < 20; j++)// переключение по столбцам
            if (mas[i][j] == 1)
            {
                // вывести два раза символ (номер которого 176 в таблице аски) в консоль
                cout << static_cast<char>(176);
                cout << static_cast<char>(176);
            } else
                 cout << "  ";  // вывести два пробела
        cout << endl;
    }
    system("pause");
    return 0;
}

// код Code::Blocks

// код Dev-C++

// array2.cpp: определяет точку входа для консольного приложения.

#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
// 1-условно "стенки лабиринта"
// 2-"правильный путь, выход из лабиринта"
// 0-"ложный путь"
    int mas[33][20] = { {1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,}, // инициализация двумерного массива
                        {1,2,1,0,0,1,0,1,2,2,2,1,1,1,1,0,0,0,0,1,},
                        {1,2,1,1,0,1,0,1,2,1,2,2,2,2,1,0,1,1,0,1,},
                        {1,2,2,2,2,2,2,1,2,1,1,1,1,2,1,0,0,1,0,1,},
                        {1,1,1,1,1,1,2,1,2,1,0,0,1,2,1,1,0,1,0,1,},
                        {1,0,0,1,0,0,2,2,2,1,1,0,0,2,0,0,0,1,0,1,},
                        {1,0,1,1,0,1,1,1,1,1,0,0,1,2,1,1,1,1,0,1,},
                        {1,0,0,0,0,0,0,0,0,1,1,1,1,2,1,0,0,0,0,1,},
                        {1,1,1,1,1,1,0,1,1,1,2,2,2,2,1,0,1,1,1,1,},
                        {1,1,0,0,0,1,0,0,1,1,2,1,1,1,1,0,0,0,0,1,},
                        {1,0,0,1,0,0,0,0,0,1,2,2,2,2,1,1,1,1,0,1,},
                        {1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,0,0,0,0,1,},
                        {1,2,2,2,2,2,2,2,2,2,2,2,2,2,1,0,1,1,1,1,},
                        {1,2,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,},
                        {1,2,1,0,0,0,1,2,2,2,1,0,0,0,0,0,1,1,0,1,},
                        {1,2,1,1,1,1,1,2,1,2,1,1,1,0,1,0,0,0,0,1,},
                        {1,2,1,2,2,2,1,2,1,2,2,2,1,1,1,1,1,1,1,1,},
                        {1,2,1,2,1,2,1,2,1,0,1,2,2,2,2,2,2,2,2,1,},
                        {1,2,1,2,1,2,1,2,1,0,1,1,1,1,1,1,1,1,2,1,},
                        {1,2,1,2,1,2,1,2,1,0,0,0,0,0,0,0,0,0,2,1,},
                        {1,2,1,2,1,2,2,2,1,0,1,1,1,1,1,1,0,1,2,1,},
                        {1,2,1,2,1,1,1,1,1,0,0,0,1,0,1,0,0,1,2,1,},
                        {1,2,1,2,2,1,0,0,1,1,1,0,0,0,1,0,1,1,2,1,},
                        {1,2,1,1,2,1,1,0,0,0,0,0,1,0,1,0,0,1,2,1,},
                        {1,2,1,1,2,1,0,0,1,1,1,1,1,1,1,1,1,1,2,1,},
                        {1,2,1,1,2,1,1,0,1,2,2,2,2,2,2,2,2,2,2,1,},
                        {1,2,1,1,2,1,0,0,1,2,1,1,1,1,1,1,1,1,1,1,},
                        {1,2,1,1,2,1,0,1,1,2,1,1,1,1,1,1,1,1,2,2,},
                        {1,2,1,1,2,1,0,0,1,2,1,1,2,2,2,2,2,2,2,1,},
                        {1,2,1,1,2,1,0,1,1,2,1,1,2,1,1,1,1,1,1,1,},
                        {1,2,1,1,2,1,0,0,1,2,1,1,2,1,0,0,0,1,0,1,},
                        {1,2,2,2,2,1,0,1,1,2,2,2,2,0,0,1,0,0,0,1,},
                        {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,} };
// два цикла - внутренний и внешний, осуществляющие обращение к каждому элементу массива
    for (int i = 0; i < 33; i++) //переключение по строкам
    {
        for (int j = 0; j < 20; j++)// переключение по столбцам
            if (mas[i][j] == 1)
            {
                // вывести два раза символ (номер которого 176 в таблице аски) в консоль
                cout << static_cast<char>(176);
                cout << static_cast<char>(176);
            } else
                 cout << "  ";  // вывести два пробела
        cout << endl;
    }
    return 0;
}

Правильный и ложный пути можно было бы обозначать одной и той же цифрой, например, нулём, но для наглядности правильный путь обозначен цифрой 2. Инициализация массива выполнялась вручную, только для того, что бы упростить программу. Так как в программе выполняется обработка двумерного массива, нужны два цикла, для переключения между элементами двумерного массива. Первый цикл for выполняет переключение между строками двумерного массива. Так как строк в двумерном массиве 33, то и переменная-счетчик i инкрементируется  от 0 до 33, строка 46. Внутри первого цикла стоит цикл for, который переключается между элементами строки двумерного массива. В теле второго цикла for внутри оператора условного выбора if выполняетcя унарная операция преобразования типа данных — static_cast<>(), которая печатает символ таблицы ASCII, под номером 176. операция преобразования типов данных дублируется для увеличения ширины лабиринта. Результат работы программы (см. Рисунок 6).

CppStudio.com
░░  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░  ░░    ░░  ░░      ░░░░░░░░        ░░
░░  ░░░░  ░░  ░░  ░░        ░░  ░░░░  ░░
░░            ░░  ░░░░░░░░  ░░    ░░  ░░
░░░░░░░░░░░░  ░░  ░░    ░░  ░░░░  ░░  ░░
░░    ░░          ░░░░            ░░  ░░
░░  ░░░░  ░░░░░░░░░░    ░░  ░░░░░░░░  ░░
░░                ░░░░░░░░  ░░        ░░
░░░░░░░░░░░░  ░░░░░░        ░░  ░░░░░░░░
░░░░      ░░    ░░░░  ░░░░░░░░        ░░
░░    ░░          ░░        ░░░░░░░░  ░░
░░░░░░░░░░░░░░░░░░░░░░░░░░  ░░        ░░
░░                          ░░  ░░░░░░░░
░░  ░░░░  ░░░░░░░░░░░░░░░░░░░░        ░░
░░  ░░      ░░      ░░          ░░░░  ░░
░░  ░░░░░░░░░░  ░░  ░░░░░░  ░░        ░░
░░  ░░      ░░  ░░      ░░░░░░░░░░░░░░░░
░░  ░░  ░░  ░░  ░░  ░░                ░░
░░  ░░  ░░  ░░  ░░  ░░░░░░░░░░░░░░░░  ░░
░░  ░░  ░░  ░░  ░░                    ░░
░░  ░░  ░░      ░░  ░░░░░░░░░░░░  ░░  ░░
░░  ░░  ░░░░░░░░░░      ░░  ░░    ░░  ░░
░░  ░░    ░░    ░░░░░░      ░░  ░░░░  ░░
░░  ░░░░  ░░░░          ░░  ░░    ░░  ░░
░░  ░░░░  ░░    ░░░░░░░░░░░░░░░░░░░░  ░░
░░  ░░░░  ░░░░  ░░                    ░░
░░  ░░░░  ░░    ░░  ░░░░░░░░░░░░░░░░░░░░
░░  ░░░░  ░░  ░░░░  ░░░░░░░░░░░░░░░░
░░  ░░░░  ░░    ░░  ░░░░              ░░
░░  ░░░░  ░░  ░░░░  ░░░░  ░░░░░░░░░░░░░░
░░  ░░░░  ░░    ░░  ░░░░  ░░      ░░  ░░
░░        ░░  ░░░░            ░░      ░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
Для продолжения нажмите любую клавишу . . .

Рисунок 6 — Массивы в С++

Автор: admin
Дата: 25.08.2012
Поделиться:

Комментарии

  1. Egorewnep

    Egorewnep

    Стать Трейдером на Olymp Trade https://goo.gl/uBN2He

    Стать партнером Olymp Trade https://goo.gl/AjnNvg

    Стать Трейдером на Binomo https://goo.gl/aJBnrb

    Стать парнером Binomo https://goo.gl/VaFpHf

    Видео заработка https://www.youtube.com/watch?v=6gOf9zXufDY&t

    Сайт для заработка http://zarabotok—doma.ru

    через сколько после подключения заработает интернет мтс

  2. mpavelFax

    Официальное трудоустройство, работа через интернет.

  3. Сергей Улицкий

    А вот, что у меня получилось

    #include "stdafx.h"
    #include <iostream>
    #include <ctime>
    using namespace std;
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	// 0- пусто, 1- стены, 2- выход, 3- объект
    	char k = '1', e ;
    	while (k == '1')	// Инициирую повторное прохождение
    	{
    		srand(time(0));	
    		int a, b, d, y, x = 37; // Переменные для нумерации ячеек массива
    		d = (rand() % 22)+1;		
    		y = (rand() % 22) + 1;	   // d и y для места выхода и начала пути
    		int A[24][39];
    			for (int a = 0; a < 24; a++) // строки массива
    			{
    				for (int b = 0; b < 39; b++)  //столбцы масива
    				{
    					A[a][b] = (((rand() % 4) % 3)) % 2; // случайнное значение массива "0" или "1"
    					if ((a == 0) || (a == 23) || (b == 0) || (b == 38)) // Задаю значение периметра равное "1"
    					{
    						A[a][b] = 1;
    					}
    					A[d][0] = 2; // задаю местоположение выхода
    					A[d][1] = 0; // задаю значение ячейки перед выходом "0"
    					A[y][x] = 3; // задаю местоположение начала
    					A[y][36] = 0; // задаю значение ячейки перед  началом "0"
    				}
    			}
    			do  // оператор начала цикла прохождения
    	   {
    			for (int a = 0; a < 24; a++) // считываю и вывожу значение ячеек массива
    			{
    				for (int b = 0; b < 39; b++)
    				{
    					if (A[a][b] == 1)
    					{
    						cout << char(177) << char(177); // вывод стен
    					}
    					if (A[a][b] == 2)					// вывод выхода
    					{
    						cout << "  " ;
    					}
    					if (A[a][b] == 3)					
    					{
    						cout << char(219) << char(219); //вывод места положения
    					}
    					if (A[a][b] == 0)
    					{
    						cout << "  " ;				// свободное пространство
    					}
    				}
    				cout << endl;		// следующая строка
    			}
    			cin >> e;			// ввод переменной передвижения
    			switch (e)
    			{
    			case 'a':				// движение в лево
    			{
    						if (A[y][x - 1] != 1)
    						{
    							x = x - 1;
    							A[y][x] = 3;
    							A[y][x + 1] = 0;
    						}
    						break;
    			}
    			case 'd':				//движение в право
    			{
    						if (A[y][x + 1] != 1)
    						{
    							x = x + 1;
    							A[y][x] = 3;
    							A[y][x - 1] = 0;
    						}
    						break;
    			}
    			case 'w':				// движение в вех
    			{
    						if (A[y-1][x] != 1)
    						{
    							y = y - 1;
    							A[y][x] = 3;
    							A[y+1][x] = 0;
    						}
    						break;
    			}
    			case 's':				// движение в низ
    			{
    						if (A[y + 1][x] != 1)
    						{
    							y = y + 1;
    							A[y][x] = 3;
    							A[y - 1][x] = 0;
    						}
    						break;
    			}
    			default:
    			{
    					   x = x;
    					   y = y;
    			}
    			}
    			}
    			while (x>0);		//условие продолжения цикла
    			cout << "\n\n Vi pobedili !!! \a\a\a\a" << endl;
    			cout << "\n\n Dlya prodoljenia najmite \"1\" :";
    			cin >> k;			// переменная для решения продолжить игру с начала или выйти
    	}
    	system("pause");
    	return 0;
    }
    // Движение оссуществляется с помощю клавиш A, W, S, D , при нажатии на клавиши несколько раз
    // игрок переместится на соответствующее количество ячеек
    • Alisawhego

      Всем привет! Меня зовут Алина, мне 23 года, я здесь новенькая ;) Пишите пообщаемся :)
      Можете посмотреть мое видео:)

      Это мой канал:
      [url=https://www.youtube.com/channel/UCRtU_AaATN5UySIPqTdRthA]https://www.youtube.com/channel/UCRtU_AaATN5UySIPqTdRthA[/url]
      Смотрите мое видео :)
      [url= https://youtu.be/U9AmiajKirQвечерняя подработка с 19 00 [/url]

  4. -lucker-

    Народ зацените!
    
    #include <iostream>
    #include <cstdlib>
    
    
    using namespace std;
    
    
    
    
    int main()
    {
        setlocale(LC_ALL, "rus");
    
    
    
    
        // 1-условно "стенки лабиринта"
    // 2-"правильный путь, выход из лабиринта"
    // 0-"ложный путь"
        int k,i2,j2,l;
        char p;
        int mas[33][20] = { {1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,}, // инициализация двумерного массива
                            {1,2,1,0,0,1,0,1,2,2,2,1,1,1,1,0,0,0,0,1,},
                            {1,2,1,1,0,1,0,1,2,1,2,2,2,2,1,0,1,1,0,1,},
                            {1,2,2,2,2,2,2,1,2,1,1,1,1,2,1,0,0,1,0,1,},
                            {1,1,1,1,1,1,2,1,2,1,0,0,1,2,1,1,0,1,0,1,},
                            {1,0,0,1,0,0,2,2,2,1,1,0,0,2,0,0,0,1,0,1,},
                            {1,0,1,1,0,1,1,1,1,1,0,0,1,2,1,1,1,1,0,1,},
                            {1,0,0,0,0,0,0,0,0,1,1,1,1,2,1,0,0,0,0,1,},
                            {1,1,1,1,1,1,0,1,1,1,2,2,2,2,1,0,1,1,1,1,},
                            {1,1,0,0,0,1,0,0,1,1,2,1,1,1,1,0,0,0,0,1,},
                            {1,0,0,1,0,0,0,0,0,1,2,2,2,2,1,1,1,1,0,1,},
                            {1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,0,0,0,0,1,},
                            {1,2,2,2,2,2,2,2,2,2,2,2,2,2,1,0,1,1,1,1,},
                            {1,2,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,},
                            {1,2,1,0,0,0,1,2,2,2,1,0,0,0,0,0,1,1,0,1,},
                            {1,2,1,1,1,1,1,2,1,2,1,1,1,0,1,0,0,0,0,1,},
                            {1,2,1,2,2,2,1,2,1,2,2,2,1,1,1,1,1,1,1,1,},
                            {1,2,1,2,1,2,1,2,1,0,1,2,2,2,2,2,2,2,2,1,},
                            {1,2,1,2,1,2,1,2,1,0,1,1,1,1,1,1,1,1,2,1,},
                            {1,2,1,2,1,2,1,2,1,0,0,0,0,0,0,0,0,0,2,1,},
                            {1,2,1,2,1,2,2,2,1,0,1,1,1,1,1,1,0,1,2,1,},
                            {1,2,1,2,1,1,1,1,1,0,0,0,1,0,1,0,0,1,2,1,},
                            {1,2,1,2,2,1,0,0,1,1,1,0,0,0,1,0,1,1,2,1,},
                            {1,2,1,1,2,1,1,0,0,0,0,0,1,0,1,0,0,1,2,1,},
                            {1,2,1,1,2,1,0,0,1,1,1,1,1,1,1,1,1,1,2,1,},
                            {1,2,1,1,2,1,1,0,1,2,2,2,2,2,2,2,2,2,2,1,},
                            {1,2,1,1,2,1,0,0,1,2,1,1,1,1,1,1,1,1,1,1,},
                            {1,2,1,1,2,1,0,1,1,2,1,1,1,1,1,1,1,1,2,2,},
                            {1,2,1,1,2,1,0,0,1,2,1,1,2,2,2,2,2,2,2,1,},
                            {1,2,1,1,2,1,0,1,1,2,1,1,2,1,1,1,1,1,1,1,},
                            {1,2,1,1,2,1,0,0,1,2,1,1,2,1,0,0,0,1,0,1,},
                            {1,2,2,2,2,1,0,1,1,2,2,2,2,0,0,1,0,0,0,1,},
                            {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,} };
    // два цикла - внутренний и внешний, осуществляющие обращение к каждому элементу массива
        k=0;
        i2=0;
        j2=1;
            cout << "Чтобы передвигаться используйте следующие кнопки:" << endl;
            cout << "w  -  передвинуться вверх" << endl;
            cout << "a  -  передвинуться влево" << endl;
            cout << "s  -  передвинуться вниз" << endl;
            cout << "d  -  передвинуться вправо" << endl;
            cout << "Затем нажмите Enter." << endl << endl << endl;
            system("pause");
            system("cls");
        while (k==0)
        {
     for (int i = 0; i < 33; i++) //переключение по строкам
        {
            for (int j = 0; j < 20; j++)// переключение по столбцам
            {
                if ((i<i2-1) || (i>i2+1) || (j<j2-1) || (j>j2+1))
                {
                    cout << "   ";
                }
                else
                {
                    if ((i2==i) && (j2==j))
                    {
                    cout << " " << static_cast<char>(176) << " ";
                    }
                    else
                    {
                    if (mas[i][j]==1)
                    {
                    cout << static_cast<char>(182);
                    cout << static_cast<char>(182);
                    cout << static_cast<char>(182);
                    }
                    else
                    {
                    cout << "   ";
                    }
                    }
                }
            }
            cout << endl;
        }
        l=0;
        while (l==0)
        {
        cin >> p;
        if ((p=='s') && (mas[i2+1][j2]!=1))
        {
            system("cls");
            i2=i2+1;
            break;
        }
        if ((p=='w') && (mas[i2-1][j2]!=1) && (i2!=0))
        {
            system("cls");
            i2=i2-1;
            break;
        }
        if ((p=='d') && (mas[i2][j2+1]!=1))
        {
            system("cls");
            j2=j2+1;
            break;
        }
        if ((p=='a') && (mas[i2][j2-1]!=1))
        {
            system("cls");
            j2=j2-1;
            break;
        }
        if ((p=='d') && (i2==27) && (j2==19))
        {
            system("cls");
            j2=j2+1;
            break;
        }
        if ((p!='w') && (p!='a') && (p!='s') && (p!='d'))
        {
            cout << "Передвигаться можно только с помощью кнопок w,a,s,d..." << endl;
        }
        else
        {
            cout << "Кажется там стена..."<< endl;
        }
        }
        system("cls");
        if ((i2==27) && (j2==20))
        {
            k=1;
        }
        }
        cout << "Вы выиграли!!!" << endl;
        system("pause");
        return 0;
    }
    • Alisawhego

      Всем привет! Меня зовут Алина, мне 23 года, я здесь новенькая ;) Пишите пообщаемся :)
      Можете посмотреть мое видео:)

      Это мой канал:
      [url=https://www.youtube.com/channel/UCXhYgpqyvBoqqbdnEvpV8Ew]https://www.youtube.com/channel/UCXhYgpqyvBoqqbdnEvpV8Ew[/url]
      Смотрите мое видео :)
      [url= https://youtu.be/fd4UFu0g52E1с подработка131131 [/url]

  5. blablabla

    Здравствуйте, объясните подробнее как происходит заполнение массива значениям?

Оставить комментарий

Вы должны войти, чтобы оставить комментарий.