Создать класс для работы с двумерным массивом целых чисел

@Ярослав92 · Регистрация: 07.03.2016

Студворк — интернет-сервис помощи студентам

Доброе время суток! Было такое задание)
Разработать следующие члены класса:
1. Поля:
• int [,] intTwoArray;
• int n;
• int m;
2. Конструктор, позволяющий создать массив размерности n × m, n × n.
3. Методы, позволяющие:
• ввести размер массива с клавиатуры;
• с генерировать элементы массива случайным образом;
• вывести элементы массива на экран;
• вычислить сумму элементов i-того столбца;
• вычислить сумму элементов i-й строки;
• вызвать метод сортировки;
• отсортировать элементы массива в порядке возрастания.
4. Свойство:
• позволяющее получить-установить значения соответствующих полей (доступное для чтения и записи);
• позволяющее определить количество строк массива (доступное только для чтения);
• позволяющее определить количество столбцов (доступное только для чтения);
• позволяющее вычислить количество нулевых элементов в массиве (доступное только для чтения);
• позволяющее установить значение всех элементов главной диагонали массива равное скаляру (доступное только для записи);
• позволяющее установить значение всех элементов вспомагательной диагонали массива равное скаляру (доступное только для записи);
• позволяющее домножить все элементы массива на скаляр (доступное только для записи);
• позволяющее определить является ли массив отсортированным (доступное только для чтения);
• позволяющее проверить на равенство массивы (доступное только для чтения);
• позволяющее проверить на неравенство массивы (доступное только для чтения).
5. Двумерный индексатор, позволяющий обращаться к соответствующему элементу массива.
6. Перегрузку:
• операции ++ (--): одновременно увеличивает (уменьшает) значение всех элементов массива на 1;
• констант true и false: обращение к экземпляру класса дает значение true, если двумерный массив является квадратным;
• операции !: возвращает значение true, если элементы массива не упорядочены по возрастанию, иначе false, связать со свойством;
• операции +: сложить два массива соответствующих размерностей;
• операции -: вычитать два массива соответствующих размерностей;
• операции *: перемножить два массива соответствующих размерностей;
• операции /: разделить два массива соответствующих размерностей;
• операции %: разделить два массива соответствующих размерностей;
• операции преобразования класса массив в двумерный массив (и наоборот);
• операция ==: проверка на равенство массивов, через свойство;
• операция !=: проверка на неравенство массивов, через свойство.
Хотелось услышать коментарии на правильность написания кода)

@Msey · 08.09.2016, 23:19

Класс делаете, методы и конструктор добавляете.
Перегружаете бинарные (+ - = итд) и унарные (++ --) операторы.
Тут особо не нужна "правильность написания" все в одну кучу сбрасываете и профит.

@Ярослав92 · 08.09.2016, 23:43 **[ТС]**

Да я уже сделал! только код не могу загрузить, сильно много кода говорит!

Добавлено через 43 секунды

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#region Fields
        /// <summary>
        /// Закрытый двухмерный массив целочисленных чисел
        /// </summary>
        private int[,] intTwoArray = null;
        /// <summary>
        /// Количество строк
        /// </summary>
        private int n = 0;
        /// <summary>
        /// Количество столбцов
        /// </summary>
        private int m = 0;
        /// <summary>
        ///  Закрытое поле value для переопределения метода Equals
        /// </summary>
        private int value = 0;
        #endregion

Добавлено через 22 секунды

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#region Constructor
        /// <summary>
        /// Конструктор 1 - по умолчанию
        /// </summary>
        public IntTwoArray() { }
        /// <summary>
        /// Конструктор 2 - создает ссылку на двухмерный массив
        /// </summary>
        /// <param name="intTwoArray">Ссылка на массив</param>
        public IntTwoArray(int[,] intTwoArray)
        {
            this.intTwoArray = intTwoArray;
        }
        /// <summary>
        /// Конструктор 3 - позволяющий создать массив размерности n×m
        /// </summary>
        /// <param name="intTwoArray">Ссылка на массив</param>
        /// <param name="n">Количество строк</param>
        /// <param name="m">Количество столбцов</param>
        public IntTwoArray(int n, int m)
        {
            intTwoArray = new int[n, m];
            this.n = n;
            this.m = m;
        }
        /// <summary>
        /// Конструктор 4 - позволяющий создать массив размерности n×n
        /// </summary>
        /// <param name="intTwoArray">Ссылка на массив</param>
        /// <param name="n">Количество строк и столбцов</param>
        public IntTwoArray(int n)
        {
            intTwoArray = new int[n, n];
            this.n = n;
        }
        #endregion

Добавлено через 40 секунд

C#
1
2
3
4
5
6
7
8
9
10
11
#region Destructor
        /// <summary>
        /// Деструктор класса
        /// </summary>
        ~IntTwoArray()
        {
            intTwoArray = null;
            n = 0;
            m = 0;
        }
        #endregion

Добавлено через 43 секунды

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
#region Methods
        /// <summary>
        /// Метод ShowArray отображает содержимое на экране
        /// </summary>
        public void ShowTwoArray()
        {
            WriteLine("Элементы массива intTwoArray: ");
            for (int i = 0; i < intTwoArray.GetLength(0); i++)
            {
                for (int j = 0; j < intTwoArray.GetLength(1); j++)
                {
                    Write($"{ intTwoArray[i, j]} ");
                }
                WriteLine();
            }
        }
        /// <summary>
        ///  Метод IntputSizeArray позволяет задать размер массива
        /// </summary>
        private void IntputSizeArray()
        {
            Write("Укажите количество строк массива: ");
            int n = ToInt32(ReadLine());
            Write("Укажите количество столбцов массива: ");
            int m = ToInt32(ReadLine());
            intTwoArray = new int[n, m];
        }
        /// <summary>
        /// Метод IntputArray позволяет ввести элементы массива с клавиатуры
        /// </summary>
        public void IntputTwoArray()
        {
            IntputSizeArray();
            for (int i = 0; i < intTwoArray.GetLength(0); i++)
            {
                for (int j = 0; j < intTwoArray.GetLength(1); j++)
                {
                    Write($"IntTwoArray [{i}, {j}]: ");
                    // Вводим числа с клавиатуры
                    intTwoArray[i, j] = ToInt32(ReadLine());
                }
            }
        }
        /// <summary>
        /// Метод RandomTwoArray позволяет ввести элементы массива с помощью генератора случайных чисел
        /// </summary>
        public void RandomTwoArray()
        {
            IntputSizeArray();
            // Генератор случайных чисел
            Random random = new Random();
            for (int i = 0; i < intTwoArray.GetLength(0); i++)
            {
                for (int j = 0; j < intTwoArray.GetLength(1); j++)
                {
                    Write($"IntTwoArray [{i}, {j}]: ");
                    // Заполняем массив случайными числами
                    intTwoArray[i, j] = random.Next();
                }
            }
        }
        /// <summary>
        /// Метод SumColumn вычисляет сумму i-го столбца
        /// </summary>
        /// <param name="colIndex">Индекс i-го столбца</param>
        /// <returns>Сумму i-го столбца</returns>
        public int SumColumn(int colIndex)
        {
            int sumCol = 0;
            for (int i = 0; i < intTwoArray.GetLength(0); i++)
            {
                sumCol += intTwoArray[i, colIndex];
            }
            return sumCol;
        }
        /// <summary>
        /// Метод SumRow вычисляет сумму i-й строки
        /// </summary>
        /// <param name="rowIndex">Индекс i-й строки</param>
        /// <returns>Сумму i-й строки</returns>
        public int SumRow(int rowIndex)
        {
            int sumRow = 0;
            for (int j = 0; j < intTwoArray.GetLength(1); j++)
            {
                sumRow += intTwoArray[rowIndex, j];
            }
            return sumRow;
        }
        /// <summary>
        /// Метод SortArray вызывает метод сортировки пузырьком BubbleSort
        /// </summary>
        public void SortTwoArray()
        {
            BubbleSort(intTwoArray);
        }
        /// <summary>
        /// Метод BubbleSort реализует алгоритм сортировки пузырьком
        /// </summary>
        /// <param name="intTwoArray">Сортируемый массив</param>
        private void BubbleSort(int[,] intTwoArray)
        {
            // Временный массив
            int[,] A = intTwoArray;
            for (int k = 0; k < intTwoArray.GetLength(0); k++)
            {
                for (int l = 0; l < intTwoArray.GetLength(1); l++)
                {
                    for (int i = 0; i < intTwoArray.GetLength(0); i++)
                    {
                        for (int j = 0; j < intTwoArray.GetLength(1); j++)
                        {
                            if (i + 1 == intTwoArray.GetLength(0) && j + 1 == intTwoArray.GetLength(1))
                            {
                                continue;
                            }
                            else
                            {
                                if (j + 1 == intTwoArray.GetLength(1) && A[i, j] > A[i + 1, 0])
                                {
                                    // Перестановка элементов в строках
                                    int t = A[i, j];
                                    A[i, j] = A[i + 1, 0];
                                    A[i + 1, 0] = t;
                                }
                                else
                                {
                                    if (j + 1 != intTwoArray.GetLength(1) && A[i, j] > A[i, j + 1])
                                    {
                                        // Перестановка элементов в столбцах
                                        int t = A[i, j];
                                        A[i, j] = A[i, j + 1];
                                        A[i, j + 1] = t;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        #endregion

Добавлено через 1 минуту

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
#region Properties
        /// <summary>
        /// Свойство, позволяющее получить-установить значение количества строк массива
        /// </summary>
        public int N
        {
            get { return n; }
            set { n = value; }
        }
        /// <summary>
        /// Свойство, позволяющее получить-установить значение количества столбцов массива
        /// </summary>
        public int M
        {
            get { return m; }
            set { m = value; }
        }
        /// <summary>
        /// Свойство, возвращающее количество строк
        /// </summary>
        public int GetLengthRow
        {
            get
            {
                return intTwoArray.GetLength(0);
            }
        }
        /// <summary>
        /// Свойство, возвращающее количество столбцов
        /// </summary>
        public int GetLengthColumn
        {
            get
            {
                return intTwoArray.GetLength(0);
            }
        }
        /// <summary>
        /// Свойство, возвращающее размерность массива
        /// </summary>
        public int Length
        {
            get
            {
                return intTwoArray.Length;
            }
        }
        /// <summary>
        /// Свойство, позволяющее вычислить количество нулевых элементов в массиве 
        /// </summary>
        public int ZeroQuantity
        {
            get
            {
                int quan = 0;
                for (int i = 0; i < intTwoArray.GetLength(0); i++)
                {
                    for (int j = 0; j < intTwoArray.GetLength(1); j++)
                    {
                        if (intTwoArray[i, j] == 0)
                        {
                            quan++;
                        }
                    }
                }
                return quan;
            }
        }
        /// <summary>
        /// Свойство, позволяющее установить значение всех элементов главной диагонали массива равное скаляру
        /// </summary>
        public int ValueMainDiagonalScalar
        {
            set
            {
                for (int i = 0; i < intTwoArray.GetLength(0); i++)
                {
                    intTwoArray[i, i] = value;
                }
            }
        }
        /// <summary>
        /// Свойство, позволяющее установить значение всех элементов вспомагательной диагонали массива равное скаляру
        /// </summary>
        public int ValueAuxiliarynDiagonalScalar
        {
            set
            {
                for (int j = 0; j < intTwoArray.GetLength(1); j++)
                {
                    intTwoArray[j, j] = value;
                }
            }
        }
        /// <summary>
        /// Свойство, позволяющее домножить все элементы массива на скаляр 
        /// </summary>
        public int MultiplyArray
        {
            set
            {
                for (int i = 0; i < intTwoArray.GetLength(0); i++)
                {
                    for (int j = 0; j < intTwoArray.GetLength(1); j++)
                    {
                        intTwoArray[i, j] = intTwoArray[i, j] * value;
                    }
                }
            }
        }
        /// <summary>
        ///  Свойство, позволяющее проверить отсортирован ли массив, не по возрастанию
        /// </summary>
        private bool TrueSort
        {
            get
            {
                // возвращает значение true, если элементы массива не упорядочены по возрастанию, иначе false
                for (int i = 1; i < intTwoArray.GetLength(0); i++)
                {
                    for (int j = 1; j < intTwoArray.GetLength(1); j++)
                    {
                        if (intTwoArray[i, j] < intTwoArray[i - 1, j - 1]) return true;
                    }
                }  
                return false;
            }
        }
        /// <summary>
        /// Свойство, позволяющее проверить равны ли два массива
        /// </summary>
        private bool Equality
        {
            get
            {
                // возвращает значение true, если массивы равны, иначе false
                for (int i = 1; i < intTwoArray.GetLength(0); i++)
                {
                    for (int j = 1; j < intTwoArray.GetLength(1); j++)
                    {
                        if (intTwoArray[i, j] == intTwoArray[i, j]) return true;
                    }
                }
                return false;
            }
        }
        /// <summary>
        /// Свойство, позволяющее проверить неравны ли два массива
        /// </summary>
        private bool Inequality
        {
            get
            {
                // возвращает значение true, если массивы неравны, иначе false
                for (int i = 1; i < intTwoArray.GetLength(0); i++)
                {
                    for (int j = 1; j < intTwoArray.GetLength(1); j++)
                    {
                        if (intTwoArray[i, j] != intTwoArray[i, j]) return true;
                    }
                }
                return false;
            }
        }
        #endregion

Добавлено через 35 секунд

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#region Indexators
        /// <summary>
        /// Двумерный индексатор, позволяющий обращаться к соответствующему элементу массива
        /// </summary>
        /// <param name="i">Индекс строки</param>
        /// <param name="j">Индекс столбца</param>
        /// <returns>Ссылку на ячейку массива</returns>
        public int this[int i, int j]
        {
            get
            {
                // Контроль границ массива, в двух измерениях
                if (i < 0 || i > intTwoArray.GetLength(0) - 1 && j < 0 || j > intTwoArray.GetLength(1) - 1)
                {
                    // Генерация исключения, если индексы выходят за границы
                    throw new ArgumentOutOfRangeException("Не корректно задан индекс!!!");
                }
                return intTwoArray[i, j];
            }
            set
            {
                // Контроль границ массива, в двух измерениях
                if (i < 0 || i > intTwoArray.GetLength(0) - 1 && j < 0 || j > intTwoArray.GetLength(1) - 1)
                {
                    // Генерация исключения, если индексы выходят за границы
                    throw new ArgumentOutOfRangeException("Не корректно задан индекс!!!");
                }
                intTwoArray[i, j] = value;
            }
        }
        #endregion

@Ярослав92 · 08.09.2016, 23:46 **[ТС]**

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
#region Operators
        //  
        /// <summary>
        /// Перегрузка унарного оператора " ++ "
        /// </summary>
        /// <param name="p">Ссылка на объект-массив</param>
        /// <returns>Возвращает элемент увеличенный на 1</returns>
        public static IntTwoArray operator ++(IntTwoArray p)
        {
            for (int i = 0; i < p.intTwoArray.GetLength(0); i++)
            {
                for (int j = 0; j < p.intTwoArray.GetLength(1); j++)
                {
                    ++p[i, j];
                }
            }
            return p;
        }
        /// <summary>
        /// Перегрузка унарного оператора " -- "
        /// </summary>
        /// <param name="p">Ссылка на объект-массив</param>
        /// <returns>Возвращает элемент уменьшенный на 1</returns>
        public static IntTwoArray operator --(IntTwoArray p)
        {
            for (int i = 0; i < p.intTwoArray.GetLength(0); i++)
            {
                for (int j = 0; j < p.intTwoArray.GetLength(1); j++)
                {
                    --p[i, j];
                }
            }
            return p;
        }
        /// <summary>
        /// Перегрузка  оператора " true ": обращение к экземпляру класса дает значение true, если двумерный массив является квадратным
        /// </summary>
        /// <param name="p">Ссылка на объект-массив</param>
        /// <returns>true или false</returns>
        public static bool operator true(IntTwoArray p)
        {
            int n = p.intTwoArray.GetLength(0);
            int m = p.intTwoArray.GetLength(1);
            if (n == m) return true;
            else return false;
        }
        /// <summary>
        /// Перегрузка  оператора " false ": обращение к экземпляру класса дает значение false, если двумерный массив является прямоугольным
        /// </summary>
        /// <param name="p">Ссылка на объект-массив</param>
        /// <returns>true или false</returns>
        public static bool operator false(IntTwoArray p)
        {
            int n = p.intTwoArray.GetLength(0);
            int m = p.intTwoArray.GetLength(1);
            if (n != m) return false;
            else return true;
        }
        /// <summary>
        /// Перегрузка бинарного оператора " ! ", через свойство isSort
        /// </summary>
        /// <param name="Sort">Ссылка на объект-массив</param>
        /// <returns>true или false</returns>
        public static bool operator !(IntTwoArray Sort)
        {
            return Sort.TrueSort;
        }
        /// <summary>
        /// Перегрузка операции бинарный " + ": сложить два массива соответствующих размерностей
        /// </summary>
        /// <param name="a">Ссылка на объект-массив</param>
        /// <param name="b">Ссылка на объект-массив</param>
        /// <returns>Сумма двух массивов</returns>
        public static IntTwoArray operator +(IntTwoArray a, IntTwoArray b)
        {
            if (a.intTwoArray.GetLength(1) != b.intTwoArray.GetLength(0)) throw new Exception("Матрицы нельзя сложить");
            int[,] intArray = new int[a.intTwoArray.GetLength(0), b.intTwoArray.GetLength(1)];
            IntTwoArray result = new IntTwoArray();
            for (int i = 0; i < a.intTwoArray.GetLength(0); i++)
            {
                for (int j = 0; j < a.intTwoArray.GetLength(1); j++)
                {
                    intArray[i, j] = a[i, j] + b[i, j];
                }
            }
            result.intTwoArray = intArray;
            return result;
        }
        /// <summary>
        /// Перегрузка операции бинарный " - ": вычитать два массива соответствующих размерностей
        /// </summary>
        /// <param name="a">Ссылка на объект-массив</param>
        /// <param name="b">Ссылка на объект-массив</param>
        /// <returns>Разница двух массивов</returns>
        public static IntTwoArray operator -(IntTwoArray a, IntTwoArray b)
        {
            if (a.intTwoArray.GetLength(1) != b.intTwoArray.GetLength(0)) throw new Exception("Матрицы нельзя вычитать");
            int[,] intArray = new int[a.intTwoArray.GetLength(0), b.intTwoArray.GetLength(1)];
            IntTwoArray result = new IntTwoArray();
            for (int i = 0; i < a.intTwoArray.GetLength(0); i++)
            {
                for (int j = 0; j < a.intTwoArray.GetLength(1); j++)
                {
                    intArray[i, j] = a[i, j] - b[i, j];
                }
            }
            result.intTwoArray = intArray;
            return result;
        }
        /// <summary>
        /// Перегрузка операции бинарный " * ": перемножить два массива соответствующих размерностей
        /// </summary>
        /// <param name="a">Ссылка на объект-массив</param>
        /// <param name="b">Ссылка на объект-массив</param>
        /// <returns>Результат произведения двух массивов</returns>
        public static IntTwoArray operator *(IntTwoArray a, IntTwoArray b)
        {
            if (a.intTwoArray.GetLength(1) != b.intTwoArray.GetLength(0)) throw new Exception("Матрицы нельзя перемножить");
            int[,] intArray = new int[a.intTwoArray.GetLength(0), b.intTwoArray.GetLength(1)];
            Parallel.For(0, a.intTwoArray.GetLength(0), (i) =>
            {
                for (int j = 0; j < a.intTwoArray.GetLength(1); j++)
                {
                    for (int k = 0; k < b.intTwoArray.GetLength(0); k++)
                    {
                        intArray[i, j] += a[i, k] * b[k, j];
                    }
                }
            });
            IntTwoArray result = new IntTwoArray();
            result.intTwoArray = intArray;
            return result;
        }
        /// <summary>
        /// Перегрузка операции бинарный " / ": разделить два массива соответствующих размерностей
        /// </summary>
        /// <param name="a">Ссылка на объект-массив</param>
        /// <param name="b">Ссылка на объект-массив</param>
        /// <returns>Результат деления двух массивов</returns>
        public static IntTwoArray operator /(IntTwoArray a, IntTwoArray b)
        {
            if (a.intTwoArray.GetLength(1) != b.intTwoArray.GetLength(0)) throw new Exception("Матрицы нельзя разделить");
            int[,] intArray = new int[a.intTwoArray.GetLength(0), b.intTwoArray.GetLength(1)];
            Parallel.For(0, a.intTwoArray.GetLength(0), (i) =>
            {
                for (int j = 0; j < a.intTwoArray.GetLength(1); j++)
                {
                    for (int k = 0; k < b.intTwoArray.GetLength(0); k++)
                    {
                        intArray[i, j] += a[i, k] / b[k, j];
                    }
                }
            });
            IntTwoArray result = new IntTwoArray();
            result.intTwoArray = intArray;
            return result;
        }
        /// <summary>
        /// Перегрузка операции бинарный " % ": разделить два массива соответствующих размерностей
        /// </summary>
        /// <param name="a">Ссылка на объект-массив</param>
        /// <param name="b">Ссылка на объект-массив</param>
        /// <returns>Результат остаток от деления двух массивов</returns>
        public static IntTwoArray operator %(IntTwoArray a, IntTwoArray b)
        {
            if (a.intTwoArray.GetLength(1) != b.intTwoArray.GetLength(0)) throw new Exception("Матрицы нельзя разделить");
            int[,] intArray = new int[a.intTwoArray.GetLength(0), b.intTwoArray.GetLength(1)];
            Parallel.For(0, a.intTwoArray.GetLength(0), (i) =>
            {
                for (int j = 0; j < a.intTwoArray.GetLength(1); j++)
                {
                    for (int k = 0; k < b.intTwoArray.GetLength(0); k++)
                    {
                        intArray[i, j] += a[i, k] % b[k, j];
                    }
                }
            });
            IntTwoArray result = new IntTwoArray();
            result.intTwoArray = intArray;
            return result;
        }
        /// <summary>
        /// Преобразования класса массив в двумерный массив
        /// </summary>
        /// <param name="p">Ссылка на объект-массив</param>
        public static explicit operator int[,] (IntTwoArray p)
        {
            return p.intTwoArray;
        }
        /// <summary>
        ///  Преобразования двумерный массив в класс массив
        /// </summary>
        /// <param name="intTwoArray">Параметр массив</param>
        public static explicit operator IntTwoArray(int[,] intTwoArray)
        {
            IntTwoArray p = new IntTwoArray(intTwoArray.GetLength(0), intTwoArray.GetLength(1));
            intTwoArray.CopyTo(p.intTwoArray, 0);
            return p;
        }
        public static bool operator !=(IntTwoArray x, IntTwoArray y)
        {
            return x.Inequality != y.Equality;
        }
        public static bool operator ==(IntTwoArray x, IntTwoArray y)
        {
            return x.Equality == y.Equality;
        }
        /// <summary>
        /// Перегрузка метода Equals
        /// </summary>
        /// <param name="obj">Ссылка на объект</param>
        /// <returns></returns>
        public override bool Equals(object obj)
        {
            if (!(obj is IntTwoArray)) return false;
            return value == ((IntTwoArray)obj).value;
        }
        /// <summary>
        ///  Перегрузка метода GetHashCode
        /// </summary>
        /// <returns></returns>
        public override int GetHashCode()
        {
            return value;
        }
        #endregion

Добавлено через 1 минуту
Хочу понять что я нарушил при написании этого класса!

@Msey · 09.09.2016, 00:04

У вас слишком много воды намешано.
что-то типа

C#
1
public IntTwoArray() { }

или деструкторы.
Конечно здорово, что вы демонстрируете наличие знаний подобных вещей, но не стоит добавлять то, что не указано в задании. Тем более, что деструктор тут бесполезен, тк при после вызова деструктора GC удаляет объект из кучи и код следующего рода

C#
1
2
3
            intTwoArray = null;
            n = 0;
            m = 0;

теряет смысл.

Второе, что бросается - это блоки summary, которые можно заменить комментариями в одну строку.
Конечно ясен пень, что это для того, чтобы можно было понять суть кода, но их абуз наоборот затрудняет чтение. (возможно это дело вкуса)

В общем, все, что хотел - высказал)

@Ярослав92 · 09.09.2016, 08:58 **[ТС]**

Учту замечания!)

Новые блоги и статьи Все статьи Все блоги /
SDL3 для Web (WebAssembly): Обработчик клика мыши в браузере ПК и касания экрана в браузере на мобильном устройстве 8Observer8 02.02.2026 Содержание блога Для начала пошагово создадим рабочий пример для подготовки к экспериментам в браузере ПК и в браузере мобильного устройства. Потом напишем обработчик клика мыши и обработчик. . .	Философия технологии iceja 01.02.2026 На мой взгляд у человека в технических проектах остается роль генерального директора. Все остальное нейронки делают уже лучше человека. Они не могут нести предпринимательские риски, не могут. . .	SDL3 для Web (WebAssembly): Вывод текста со шрифтом TTF с помощью SDL3_ttf 8Observer8 01.02.2026 Содержание блога В этой пошаговой инструкции создадим с нуля веб-приложение, которое выводит текст в окне браузера. Запустим на Android на локальном сервере. Загрузим Release на бесплатный. . .	SDL3 для Web (WebAssembly): Сборка C/C++ проекта из консоли 8Observer8 30.01.2026 Содержание блога Если вы откроете примеры для начинающих на официальном репозитории SDL3 в папке: examples, то вы увидите, что все примеры используют следующие четыре обязательные функции, а. . .
SDL3 для Web (WebAssembly): Установка Emscripten SDK (emsdk) и CMake для сборки C и C++ приложений в Wasm 8Observer8 30.01.2026 Содержание блога Для того чтобы скачать Emscripten SDK (emsdk) необходимо сначало скачать и уставить Git: Install for Windows. Следуйте стандартной процедуре установки Git через установщик. . . .	SDL3 для Android: Подключение Box2D v3, физика и отрисовка коллайдеров 8Observer8 29.01.2026 Содержание блога Box2D - это библиотека для 2D физики для анимаций и игр. С её помощью можно определять были ли коллизии между конкретными объектами. Версия v3 была полностью переписана на Си, в. . .	Инструменты COM: Сохранение данный из VARIANT в файл и загрузка из файла в VARIANT bedvit 28.01.2026 Сохранение базовых типов COM и массивов (одномерных или двухмерных) любой вложенности (деревья) в файл, с возможностью выбора алгоритмов сжатия и шифрования. Часть библиотеки BedvitCOM Использованы. . .	SDL3 для Android: Загрузка PNG с альфа-каналом с помощью SDL_LoadPNG (без SDL3_image) 8Observer8 28.01.2026 Содержание блога SDL3 имеет собственные средства для загрузки и отображения PNG-файлов с альфа-каналом и базовой работы с ними. В этой инструкции используется функция SDL_LoadPNG(), которая. . .

@Ярослав92 6 / 6 / 5 Регистрация: 07.03.2016 Сообщений: 89

	.NET 4.x Создать класс для работы с двумерным массивом целых чисел 08.09.2016, 23:10. Показов 8112. Ответов 5 Метки нет (Все метки) Доброе время суток! Было такое задание) Разработать следующие члены класса: 1. Поля: • int [,] intTwoArray; • int n; • int m; 2. Конструктор, позволяющий создать массив размерности n × m, n × n. 3. Методы, позволяющие: • ввести размер массива с клавиатуры; • с генерировать элементы массива случайным образом; • вывести элементы массива на экран; • вычислить сумму элементов i-того столбца; • вычислить сумму элементов i-й строки; • вызвать метод сортировки; • отсортировать элементы массива в порядке возрастания. 4. Свойство: • позволяющее получить-установить значения соответствующих полей (доступное для чтения и записи); • позволяющее определить количество строк массива (доступное только для чтения); • позволяющее определить количество столбцов (доступное только для чтения); • позволяющее вычислить количество нулевых элементов в массиве (доступное только для чтения); • позволяющее установить значение всех элементов главной диагонали массива равное скаляру (доступное только для записи); • позволяющее установить значение всех элементов вспомагательной диагонали массива равное скаляру (доступное только для записи); • позволяющее домножить все элементы массива на скаляр (доступное только для записи); • позволяющее определить является ли массив отсортированным (доступное только для чтения); • позволяющее проверить на равенство массивы (доступное только для чтения); • позволяющее проверить на неравенство массивы (доступное только для чтения). 5. Двумерный индексатор, позволяющий обращаться к соответствующему элементу массива. 6. Перегрузку: • операции ++ (--): одновременно увеличивает (уменьшает) значение всех элементов массива на 1; • констант true и false: обращение к экземпляру класса дает значение true, если двумерный массив является квадратным; • операции !: возвращает значение true, если элементы массива не упорядочены по возрастанию, иначе false, связать со свойством; • операции +: сложить два массива соответствующих размерностей; • операции -: вычитать два массива соответствующих размерностей; • операции *: перемножить два массива соответствующих размерностей; • операции /: разделить два массива соответствующих размерностей; • операции %: разделить два массива соответствующих размерностей; • операции преобразования класса массив в двумерный массив (и наоборот); • операция ==: проверка на равенство массивов, через свойство; • операция !=: проверка на неравенство массивов, через свойство. Хотелось услышать коментарии на правильность написания кода) 0

@Msey 14 / 14 / 5 Регистрация: 15.12.2014 Сообщений: 90
	08.09.2016, 23:19
	Класс делаете, методы и конструктор добавляете. Перегружаете бинарные (+ - = итд) и унарные (++ --) операторы. Тут особо не нужна "правильность написания" все в одну кучу сбрасываете и профит. 1

@Ярослав92 6 / 6 / 5 Регистрация: 07.03.2016 Сообщений: 89
	09.09.2016, 08:58 [ТС]
	Учту замечания!) 0

Создать класс для работы с двумерным массивом целых чисел

Решение