До этого мы в большинстве случаев помещали метод Main в тот же класс, который испытывали:
using System;
namespace test{
class Test {
//... (поля, методы, ... класса)
static void Main() {
//...
}}}
Но для больших, настояших программ это не самый лучший способ. Гораздо лучше вынести метод Main в отдельный класс:
using System;
namespace test{
class Test {
//... (поля, методы, ... класса Test)
}
//Класс приложения для вызова метода Main.
class App {
static void Main() {
//Создаем экземпляр класса Test.
Test c = new Test();
//...
}
}
}
В программе, как правило, будет много классов. И лучше каждый из них хранить в отдельном файле (с расширением *.cs).
Для консольных приложений для ввода и вывода информации используется класс System.Console. Основные методы этого класса ReadLine() и WriteLine(). Метод WriteLine() выводит символьную строку, дополняя ее сиволами перехода на новую строку и возврата каретки. Метод Write() делает тоже самое, но уже без дополнения. Метод ReadLine() считывает информацию с консоли до символа перехода на новую строку, метод Read() – один символ.
Для вывода на консоль мы использовали следующую конструкцию:
...
int x=23, y=-4;
...
Console.WriteLine("x={0}, y={1}", x, y);
...
Здесь мы используем внутри кавычек подстановочные выражения {0}, {1} и т. д. (нумерация в них идет с нуля). Переменные при этом выводятся в формате по умолчанию. Для вывода в определеном формате надо использовать подстановочные выражения с параметрами. Вот некоторые их них:
d (D) - десятичный формат. Позволяет задать общее количество знаков (при необходимости число дополняется слева нулями).
f (F)- формат с фиксированной точностью. Позволяет задать количество знаков после запятой.
x (X)- шестнадцатеричный формат.
c (C)- денежный формат (добавляет знак доллара и показывает два знака после запятой).
e (E)- вывод числа в экспоненциальной форме.
g (G) – Общий формат. Позволяет выводить в экспоненциальном или вещественном формате.
n (N) – Выводит разделители (запятые) между разрядами.
А вот пример их использования:
...
int a=38;
//Выведется 0038
Console.WriteLine("a={0:d4}", a);
double pi=3.1415926;
//Выведется 3.14
Console.WriteLine("pi={0:f2}", pi);
int b=255;
//Выведется FF.
Console.WriteLine("b={0:X}", b);
int c=255;
//Выведется ff.
Console.WriteLine("c={0:x}", c);
double d=1003.14;
//Выведется $1, 003.14 в английской версии Windows и
//1 003,14 р. в русской.
Console.WriteLine("d={0:c}", d);
double e=213.1;
//Выведется 2.131000e+002
Console.WriteLine("e={0:e}", e);
...
Параметры подстановочных знаков можно использовать как строчные, таки и прописные - это все равно. Исключение - вывод числа в шестнадцатеричном виде (при использовании x цифры a, ..., f будут строчными, при использовании X - прописными).
Массивы в C#
Массив задает способ организации данных. Массивом называют упорядоченную совокупность элементов одного типа. Каждый элемент массива имеет индексы, определяющие порядок элементов. Число индексов характеризует размерность массива. Каждый индекс изменяется в некотором диапазоне [a,b]. В языке C#, как и во многих других языках, индексы задаются целочисленным типом. Диапазон [a,b] называется граничной парой, a - нижней границей, b - верхней границей индекса. При объявлении массива границы задаются выражениями. Если все границы заданы константными выражениями, то число элементов массива известно в момент его объявления и ему может быть выделена память еще на этапе трансляции. Такие массивы называются статическими. Если же выражения, задающие границы, зависят от переменных, то такие массивы называются динамическими, поскольку память им может быть отведена только динамически в процессе выполнения программы, когда становятся известными значения соответствующих переменных. Массиву, как правило, выделяется непрерывная область памяти.
Массивы в языке C# являются настоящими динамическими массивами. Как следствие этого, напомню, массивы относятся к ссылочным типам, память им отводится динамически в "куче".
В языке C#, соблюдая преемственность, сохранены одномерные массивы и массивы массивов. В дополнение к ним в язык добавлены многомерные массивы. Динамические многомерные массивы языка C# являются весьма мощной, надежной, понятной и удобной структурой данных.
...
int[] k; //k – одномерный массив
k=new int [3]; //Определяем массив из 3-х целых
k[0]=-5; k[1]=4; k[2]=55; //Задаем элементы массива
//Выводим третий элемент массива
Console.WriteLine(k[2].ToString());
...
Смысл приведенного фрагмента ясен из комментариев. Обратите внимание на некоторые особенности. Во-первых, массив определяется именно как
int[] k;
в отличии от способа в С/С++ int k[3]; //Неверно!
Во-вторых, так как массив представляет из себя ссылочный объект, то для создания массива необходима строка
k=new int [3]; или int[] k = new int [3];
Элементы массива можно задавать сразу при объявлении. Вот пример:
int[] k = {-5, 4, 55};
Разумеется, приведенные конструкции применимы не только к типу int и не только к массиву размера 3.
В C#, как и в C/C++, нумерация элементов массива идет с нуля. Таким образом, в нашем примере начальный элемент массива - это k[0], а последний - k[2].
Пример:
public void TestDeclaration(){
//объявляются три одномерных массива A,B,C
int[] A = new int[5], B= new int[5], C= new int[5];
Для поддержки работы с массивами создан специальный класс Arrs, статические методы которого выполняют различные операции над массивами. В частности, в примере использованы два метода этого класса, один из которых заполняет массив случайными числами, второй - выводит массив на печать.
for(int i = 0; i<A.GetLength(0);i++)
A[i] = rnd.Next(1,100);
Здесь rnd - это статическое поле класса Arrs, объявленное следующим образом:
private static Random rnd = new Random();
Процедура печати массива с именем name выглядит так:
Console.WriteLine(name);
for(int i = 0; i<A.GetLength(0);i++)
Console.Write("\t" + name + "[{0}]={1}", i, A[i]);
Console.WriteLine();
Чисто синтаксически нет существенной разницы в объявлении статических и динамических массивов. Выражение, задающее границу изменения индексов, в динамическом случае содержит переменные. Единственное требование - значения переменных должны быть определены в момент объявления. Это ограничение в C# выполняется автоматически, поскольку хорошо известно, сколь требовательно C# контролирует инициализацию переменных.
Пример, в котором описана работа с динамическим массивом:
public void TestDynAr() {
//объявление динамического массива A1
Console.WriteLine("Введите число элементов массива ");
int size = Int32.Parse(Console.ReadLine());
int[] A1 = new int[size];
}
Теперь переходим к многомерным массивам.
Вот как выглядит объявление многомерного массива в общем случае:
<тип>[, ... ,] <объявители>;
Число запятых, увеличенное на единицу, и задает размерность массива. Вот так задается двумерный массив:
int[,] k = new int [2,3];
Обратите внимение, что пара квадратных скобок только одна. Естественно, что в нашем примере у массива 6 (=2*3) элементов (k[0,0] - первый, k[1,2] - последний).
Аналогично мы можем задавать многомерные массивы. Вот пример трехмерного массива:
int[,,] k = new int [10,10,10];
А вот так можно сразу инициализировать многомерные массивы:
int[,] k = {{2,-2},{3,-22},{0,4}};
Приведенные выше примеры многомерных массивов называются прямоугольными. Если их представить в виде таблицы (в двумерном случае), то массив будет представлять из себя прямоугольник.
Рассмотрим классическую задачу умножения прямоугольных матриц. Нам понадобится три динамических массива для представления матриц и три процедуры, одна из которых будет заполнять исходные матрицы случайными числами, другая - выполнять умножение матриц, третья - печатать сами матрицы. Вот тестовый пример:
public void TestMultiMatr(){
int n1, m1, n2, m2,n3, m3;
Arrs.GetSizes("MatrA",out n1,out m1);
Arrs.GetSizes("MatrB",out n2,out m2);
Arrs.GetSizes("MatrC",out n3,out m3);
int[,]MatrA = new int[n1,m1], MatrB = new int[n2,m2];
int[,]MatrC = new int[n3,m3];
Arrs.CreateTwoDimAr(MatrA);
Arrs.CreateTwoDimAr(MatrB);
Arrs.MultMatr(MatrA, MatrB, MatrC);
Arrs.PrintAr2("MatrA",MatrA);
Arrs.PrintAr2("MatrB",MatrB);
Arrs.PrintAr2("MatrC",MatrC);
}//TestMultiMatr
Три матрицы - MatrA, MatrB и MatrC - имеют произвольные размеры, выясняемые в диалоге с пользователем, и использование для их описания динамических массивов представляется совершенно естественным. Метод CreateTwoDimAr заполняет случайными числами элементы матрицы, переданной ему в качестве аргумента, метод PrintAr2 выводит матрицу на печать.
Метод MultMatr выполняет умножение прямоугольных матриц. Это классическая задача из набора задач, решаемых на первом курсе. Вот текст этого метода:
Прежде чем проводить вычисления, производится проверка корректности размерностей исходных матриц при их перемножении, - число столбцов первой матрицы должно быть равно числу строк второй матрицы.
Наряду с прямоугольными массивами существуют так называемые ступенчатые. Вот пример:
//Объявляем 2-мерный ступенчатый массив
int[][] k = new int [2][];
//Объявляем 0-й элемент нашего ступенчатого массива
//Это опять массив и в нем 3 элемента
k[0]=new int[3];
//Объявляем 1-й элемент нашего ступенчатого массива
//Это опять массив и в нем 4 элемента
k[1]=new int[4];
k[1][3]=22; //записываем 22 в последний элемент массива
...
Обратите внимание, что у ступенчатых массивов мы задаем несколько пар квадратных скобок (столько, сколько размерность у массива). И точно так же мы что-нибудь делаем с элементами массива - записываем, читаем и т. п.
Самая важная и интересная возможность у ступенчатых массивов - это их "непрямоугольность". Так, в приведенном выше примере в первой "строке" массива k три целых числа, а во второй - четыре. Часто это оказывается очень к месту.
Пример:
//объявление и инициализация
int[][] jagger = new int[3][] {
new int[] {5,7,9,11},
new int[] {2,8},
new int[] {6,12,4}
};
Массив jagger имеет всего два уровня. Можно считать, что у него три элемента, каждый из которых является массивом. Для каждого такого массива необходимо вызвать конструктор new, чтобы создать внутренний массив. В данном примере элементы внутренних массивов получают значение, будучи явно инициализированы константными массивами. Конечно, допустимо и такое объявление:
int[][] jagger1 = new int[3][] {
new int[4],
new int[2],
new int[3]
};
В этом случае элементы массива получат при инициализации нулевые значения. Реальную инициализацию нужно будет выполнять программным путем. Стоит заметить, что в конструкторе верхнего уровня константу 3 можно опустить и писать просто new int[][]. Самое забавное, что вызов этого конструктора можно вообще опустить - он будет подразумеваться:
int[][] jagger2 ={
new int[4],
new int[2],
new int[3]
};
А вот конструкторы нижнего уровня необходимы. Еще одно важное замечание - динамические массивы возможны и здесь. В общем случае, границы на любом уровне могут быть выражениями, зависящими от переменных. Более того, допустимо, чтобы массивы на нижнем уровне были многомерными.
